pil21/COPYING0000644000000000000000000000206614631347642007744 0ustar PicoLisp Copyright (c) Software Lab. Alexander Burger Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. pil21/README0000644000000000000000000001013014631350317007551 0ustar # 09jun24 Software Lab. Alexander Burger Perfection is attained not when there is nothing left to add but when there is nothing left to take away (Antoine de Saint-Exupery) The PicoLisp System =================== _PI_co Lisp is not _CO_mmon Lisp PicoLisp can be viewed from two different aspects: As a general purpose programming language, and a dedicated application server framework. (1) As a programming language, PicoLisp provides a 1-to-1 mapping of a clean and powerful Lisp derivate, to a simple and efficient virtual machine. It supports persistent objects as a first class data type, resulting in a database system of Entity/Relation classes and a Prolog-like query language tightly integrated into the system. The virtual machine was designed to be Simple The internal data structure should be as simple as possible. Only one single data structure is used to build all higher level constructs. Unlimited There are no limits imposed upon the language due to limitations of the virtual machine architecture. That is, there is no upper bound in symbol name length, number digit counts, or data structure and buffer sizes, except for the total memory size of the host machine. Dynamic Behavior should be as dynamic as possible ("run"-time vs. "compile"-time). All decisions are delayed till runtime where possible. This involves matters like memory management, dynamic symbol binding, and late method binding. Practical PicoLisp is not just a toy of theoretical value. PicoLisp is used since 1988 in actual application development, research and production. The language inherits the major advantages of classical Lisp systems like * Dynamic data types and structures * Formal equivalence of code and data * Functional programming style * An interactive environment PicoLisp is very different from any other Lisp dialect. This is partly due to the above design principles, and partly due to its long development history since 1984. You can download the latest release version at https://software-lab.de/pil21.tgz (2) As an application server framework, PicoLisp provides for NoSQL Database Management Index trees Object local indexes Entity/Relation classes Pilog (PicoLisp Prolog) queries Multi-user synchronization DB Garbage collection Journaling, Replication User Interface Browser GUI (X)HTML/CSS XMLHttpRequest/JavaScript Application Server Process management Process family communication XML I/O Import/export User administration Internationalization Security Object linkage Postscript/Printing PicoLisp is not an IDE. All program development in Software Lab. is done using the console, bash, vip (vi-style editor) and the Lisp interpreter. The only type of GUI supported for applications is through a browser via HTML. This makes the client side completely platform independent. The GUI is created dynamically. Though it uses JavaScript and XMLHttpRequest for speed improvements, it is fully functional also without JavaScript or CSS. The GUI is deeply integrated with - and generated dynamically from - the application's data model. Because the application logic runs on the server, multiple users can view and modify the same database object without conflicts, everyone seeing changes done by other users on her screen immediately due to the internal process and database synchronization. PicoLisp is free software, and you are welcome to use and redistribute it under the conditions of the MIT/X11 License (see "COPYING"). It is based on LLVM and compiles and runs on any 64-bit POSIX system. -------------------------------------------------------------------------------- Alexander Burger Software Lab. / 7fach GmbH Bahnhofstr. 24a, D-86462 Langweid abu@software-lab.de, http://www.software-lab.de, +49 8230 5060 pil21/INSTALL0000644000000000000000000000632214631350532007731 0ustar # 09jun24 Software Lab. Alexander Burger PicoLisp Installation ===================== PicoLisp needs a POSIX compatible system and the LLVM infrastructure. It supports two installation strategies: Local and Global. For a global installation, allowing system-wide access to the executable and library/documentation files, you can either install it from a ready-made distribution, or set some symbolic links to one of the local installation directories as described below. Note that you are still free to have local installations along with a global installation, and invoke them explicitly as desired. Local Installation ------------------ The following instructions work on Debian Linux. They should be similar on other systems. 1. Install required packages $ sudo apt install binutils make clang llvm libreadline-dev libffi-dev libssl-dev pkg-config 2. Unpack the tarball $ wget https://software-lab.de/pil21.tgz $ tar xfz pil21.tgz 3. Change the directory $ cd pil21 4. Compile the PicoLisp interpreter $ (cd src; make) Global Installation ------------------- The recommended way for a global installation is to use a picolisp package from the OS distribution. If that is not available, you can (as root) create symbolic links from /usr/lib and /usr/bin to a local installation directory: # ln -s //pil21 /usr/lib/picolisp # ln -s /usr/lib/picolisp/bin/picolisp /usr/bin # ln -s /usr/lib/picolisp/bin/pil /usr/bin For additional access to the man pages, utilities and bash completion: # ln -s //pil21/man/man1/picolisp.1 /usr/share/man/man1 # ln -s //pil21/man/man1/pil.1 /usr/share/man/man1 # ln -s //pil21 /usr/share/picolisp # ln -s //pil21/lib/bash_completion /usr/share/bash-completion/completions/pil Invocation ---------- In a global installation, the 'pil' command should be used. You can either start in plain or in debug mode. The difference is that for debug mode the command is followed by single plus ('+') sign. The '+' must be the very last argument on the command line. $ pil # Plain mode : $ pil + # Debug mode : In both cases, the colon ':' is PicoLisp's prompt. You may enter some Lisp expression, : (+ 1 2 3) -> 6 To exit the interpreter, enter : (bye) or just type Ctrl-D. For a local invocation, specify a path name, e.g. $ ./pil # Plain mode : $ ./pil + # Debug mode : or $ /home/app/pil # Invoking a local installation from some other directory Note that 'pil' can also serve as a template for your own stand-alone scripts. Documentation ------------- For further information, please look at "doc/index.html". There you find the PicoLisp Reference Manual ("doc/ref.html"), the PicoLisp tutorial ("doc/tut.html"), and the frequently asked questions ("doc/faq.html"). As always, the most accurate and complete documentation is the source code ;-) Any feedback is welcome! Hope you enjoy :-) -------------------------------------------------------------------------------- Alexander Burger Software Lab. / 7fach GmbH Bahnhofstr. 24a, D-86462 Langweid abu@software-lab.de, https://www.software-lab.de, +49 8230 5060 pil21/pil0000755000000000000000000000007610476737204007422 0ustar #!/bin/sh exec ${0%/*}/bin/picolisp ${0%/*}/lib.l @ext.l "$@" pil21/lib.l0000644000000000000000000004112114752055563007631 0ustar # 09feb25 Software Lab. Alexander Burger (de task (Key . Prg) (nond (Prg (del (assoc Key *Run) '*Run)) ((num? Key) (quit "Bad Key" Key)) ((assoc Key *Run) (push '*Run (conc (make (when (lt0 (link Key)) (link (eval (++ Prg) 1)) ) ) (ifn (sym? (car Prg)) Prg (cons (cons 'job (cons (lit (make (while (atom (car Prg)) (link (cons (++ Prg) (eval (++ Prg) 1)) ) ) ) ) Prg ) ) ) ) ) ) ) (NIL (quit "Key conflict" Key)) ) ) (de timeout (N) (if2 N (assoc -1 *Run) (set (cdr @) N) (push '*Run (list -1 N '(bye))) (del @ '*Run) ) ) (de tasks Task (task -2 (abs (run Task)) "Prg" Task (let (L (assoc @ *Run) P (run "Prg")) (if2 (lt0 (car L)) (lt0 P) (set (cdr L) (abs P)) # (-2 111 ..) -> (-2 999 ..) (ifn P (task -2) (set L P) # (-2 999 ..) -> (7 ..) (con L (cddr L)) ) (prog # (7 ..) -> (-2 999 ...) (set L -2) (con L (cons (abs P) (cdr L))) ) (ifn P (task (car L)) (set L P) ) ) ) ) ) # (3 ..) -> (7 ..) (de abort ("N" . "Prg") (catch 'abort (alarm "N" (throw 'abort)) (finally (alarm 0) (run "Prg")) ) ) (de macro "Prg" (run (fill "Prg")) ) (de later ("@Var" . "@Prg") (macro (task (pipe (pr (prog . "@Prg"))) (setq "@Var" (in @ (rd))) (task (close @)) ) ) "@Var" ) (de recur recurse (run (cdr recurse)) ) (de curry "Z" (let ("X" (++ "Z") "Y" (++ "Z") "P" (filter pat? "X")) (if2 "P" (diff "X" "P") (list "Y" (cons 'job (lit (env @)) (fill "Z" "P"))) (cons "Y" (fill "Z" "P")) (list "Y" (cons 'job (lit (env @)) "Z")) (cons "Y" "Z") ) ) ) ### Definitions ### (de expr ("F") (set "F" (list '@ (list 'pass (box (getd "F")))) ) ) (de subr ("F") (set "F" (getd (cadadr (getd "F")))) ) (de undef ("X" "C") (when (pair "X") (setq "C" (cdr "X") "X" (car "X")) ) (ifn "C" (prog1 (val "X") (set "X")) (prog1 (cdr (asoq "X" (val "C"))) (set "C" (delq (asoq "X" (val "C")) (val "C")) ) ) ) ) (de redef "Lst" (let ("Old" (car "Lst") "New" (name "Old")) (set "New" (getd "Old") "Old" "New" "Old" (fill (cdr "Lst") "Old") ) "New" ) ) (de sysdefs ("Sym" "Alt") (in (or "Alt" "@lib/sysdefs") (if (from (pack "\n[" "Sym" "]\n")) (while (and (skip) (<> "[" @)) (def (read) (read)) ) (quit "No sysdefs" "Sym") ) ) ) (de daemon ("X" . Prg) (prog1 (nond ((pair "X") (or (pair (getd "X")) (expr "X")) ) ((pair (cdr "X")) (method (car "X") (cdr "X")) ) (NIL (method (car "X") (get (or (cddr "X") *Class) (cadr "X"))) ) ) (con @ (append Prg (cdr @))) ) ) (de patch ("Lst" "Pat" . "Prg") (bind (fish pat? "Pat") (recur ("Lst") (loop (cond ((match "Pat" (car "Lst")) (set "Lst" (run "Prg")) ) ((pair (car "Lst")) (recurse @) ) ) (NIL (cdr "Lst")) (T (atom (cdr "Lst")) (when (match "Pat" (cdr "Lst")) (con "Lst" (run "Prg")) ) ) (setq "Lst" (cdr "Lst")) ) ) ) ) (de cache ("Var" "X" . "Prg") (let "K" (cons (char (hash "X")) "X") (nond ("Prg" (caar (idx "Var" "K"))) ((setq "Var" (caar (idx "Var" "K" T))) (set (car "K") (run "Prg" 1)) ) ((n== "Var" (val "Var")) (set "Var" (run "Prg" 1)) ) (NIL (val "Var")) ) ) ) ### I/O ### (de tab (Lst . @) (for N Lst (let V (next) (and (gt0 N) (space (- N (length V)))) (prin V) (and (lt0 N) (args) (space (- 0 N (length V)))) ) ) (prinl) ) (de beep () (prin "^G") (flush) NIL ) (de msg (X . @) (tty (print X) (pass prinl)) X ) (de script (File . @) (load File) ) (de once "Prg" (unless (idx '*Once (file) T) (run "Prg" 1) ) ) (de finish Prg (apply push1 (reverse Prg) '*Bye) ) (de rc (File Key . @) (ctl File (in File (let Lst (read) (ifn (args) (cdr (assoc Key Lst)) (let Val (next) (loop (if (assoc Key Lst) (con @ Val) (push 'Lst (cons Key Val)) ) (NIL (args)) (setq Key (next) Val (next)) ) (protect (out File (println Lst)) ) Val ) ) ) ) ) ) (de acquire (File) (ctl File (in File (let P (rd) (or (= P *Pid) (unless (and P (kill P 0)) (out File (pr *Pid)) ) ) ) ) ) ) (de release (File) (ctl File (out File)) ) # Temporary Files (de tmp @ (unless *Tmp (finish (call "rm" "-r" *Tmp)) (push '*Fork '(off *Tmp)) (call "mkdir" "-p" (setq *Tmp (pack (path "~/.pil/tmp/") *Pid "/")) ) ) (pass pack *Tmp) ) ### String ### (de pad (N Val) (pack (need N (chop Val) "0")) ) (de align (X . @) (pack (if (pair X) (mapcar '((X) (need X (chop (next)) " ")) X ) (need X (chop (next)) " ") ) ) ) (de center (X . @) (pack (if (pair X) (let R 0 (mapcar '((X) (let (S (chop (next)) N (>> 1 (+ X (length S)))) (prog1 (need (+ N R) S " ") (setq R (- X N)) ) ) ) X ) ) (let S (chop (next)) (need (>> 1 (+ X (length S))) S " ") ) ) ) ) ### List ### (de less (X N) (default N 4) (cond ((atom X) X) ((=0 N) '(..)) (T (cons (less (++ X) N) (less X (dec N)) ) ) ) ) (de uniq (Lst) (let R NIL (filter '((X) (not (idx 'R (cons (hash X) X) T)) ) Lst ) ) ) ### Symbol ### (de qsym "Sym" (cons (val "Sym") (getl "Sym")) ) (de loc (S X) (if (and (str? X) (= S X)) X (and (pair X) (or (loc S (car X)) (loc S (cdr X)) ) ) ) ) (de -symbols () (apply symbols (symbols) (intern (opt))) ) (de private () (symbols '(priv) (read)) ) (de local () (symbols (list (car (symbols))) (read) ) ) (de export (Sym) (symbols (list (or Sym (cadr (symbols)))) (read) ) ) (de import Lst (for Sym Lst (unless (== Sym (intern Sym T)) (quit "Import conflict" Sym) ) ) Lst ) (de all* (S Flg) (sort (conc (unless (=0 Flg) (let (L (split (chop S) "~") N NIL S) (while (cdr L) (setq N (intern (car L) N) S (pack S (++ L) "~") ) ) (let P (pack (car L)) (extract '((X) (and (pre? P X) (pack S X))) (all N) ) ) ) ) (unless (=T Flg) (let P (rot (split (chop S) "/")) (setq S (pack (car P))) (cond ((cdr P) (setq P (pack (glue "/" @) "/")) ) ((= "@" (caar P)) (setq S (pack (cdar P)) P "@") ) (T (off P)) ) (extract '((X) (when (pre? S X) (let F (pack P X) (if (=T (car (info F))) (pack F "/") F ) ) ) ) (dir P T) ) ) ) ) ) ) ### Date/Time ### (de *mon . (jan feb mar apr may jun jul aug sep oct nov dec .)) (de dat$ (Dat C) (when (date Dat) (pack (car @) C (pad 2 (cadr @)) C (pad 2 (caddr @))) ) ) (de tim$ (Tim F) (when (setq Tim (time Tim)) (pack (pad 2 (car Tim)) ":" (pad 2 (cadr Tim)) (and F ":") (and F (pad 2 (caddr Tim))) ) ) ) (de datSym (Dat) (when (date Dat) (pack (pad 2 (caddr @)) (get *mon (cadr @)) (pad 2 (% (car @) 100)) ) ) ) ### OOP ### (de class Lst (set (setq *Class (++ Lst)) (type *Class)) (putl *Class) (def *Class Lst) ) (de object ("Sym" "Val" . @) (putl "Sym") (def "Sym" "Val") (while (args) (put "Sym" (next) (next)) ) "Sym" ) (de extend X (setq *Class (car X)) ) # Class variables (de var X (if (pair (car X)) (def (cdar X) (car (++ X)) X) (def *Class (++ X) X) ) X ) (de var: X (apply meta X This) ) ### Math ### (de scl ("N" . "Prg") (if "Prg" (let *Scl "N" (run "Prg")) (setq *Scl "N") ) ) # (Knuth Vol.2, p.442) (de ** (X N) # N th power of X (if (ge0 N) (let Y 1 (loop (when (bit? 1 N) (setq Y (* Y X)) ) (T (=0 (setq N (>> 1 N))) Y ) (setq X (* X X)) ) ) 0 ) ) # Accumulate (de accu ("Var" Key Val) (when Val (if (assoc Key (val "Var")) (con @ (+ Val (cdr @))) (push "Var" (cons Key Val)) ) ) ) ### REPL ### (de complete (S) (when S (setq "*Cmpl" (if (=T S) (list " ") (flip (all* S)) ) ) ) (pop '"*Cmpl") ) (de remark ("X") (let? Lst (recur ("X") (make (cond ((num? "X") (when (>= 799999 "X" 700000) (link (dat$ "X" "-")) ) (unless (=0 *Scl) (link (format "X" *Scl)) ) ) ((sym? "X") (let? Nsp (nsp "X") (or (== 'pico Nsp) (== 'priv Nsp) (link (pack (sym Nsp) "~" (sym "X"))) ) ) (when (type "X") (link (sym @)) ) ) (T (and (recurse (car "X")) (chain @))) ) ) ) (prin " " (and (=1 (%@ "isatty" 'I (fd))) "\e[0;36m") "#" ) (for X Lst (prin " " X) ) (when (=1 (%@ "isatty" 'I (fd))) (prin "\e[0m") ) ) ) ### Pretty Printing ### (de pretty (X N) (setq N (abs (space (or N 0)))) (while (and (pair X) (== 'quote (car X))) (prin "'") (++ X) ) (cond ((atom X) (print X)) ((memq (car X) '(de dm redef)) (_pretty (spPrt (++ X)) (spPrt (++ X)) (prtty1 X N Z) ) ) ((memq (car X) '(let let?)) (_pretty (cond ((atom (car X)) (spPrt (++ X)) (prtty? (++ X) N) ) ((>= 12 (size (car X))) (prin " (") (let (P (circ? X) Z (++ X)) (prtty2 Z NIL Z) ) (prin ")") ) (T (nlPrt N) (prin "(") (let (P (circ? X) Z (++ X)) (prtty2 Z (+ N 3) Z) ) (prin " )") ) ) (prtty1 X N Z) ) ) ((== 'for (car X)) (_pretty (cond ((or (atom (car X)) (atom (cdar X))) (spPrt (++ X)) (prtty? (++ X) N) ) ((>= 12 (size (car X))) (spPrt (++ X)) ) (T (nlPrt N) (prtty0 (++ X) (+ 3 N)) ) ) (prtty1 X N Z) ) ) ((== 'if2 (car X)) (_pretty (when (>= 12 (size (head 2 X))) (spPrt (++ X)) (spPrt (++ X)) ) (prtty1 X N Z) ) ) ((memq (car X) '(while until do state finally co)) (prtty3 X N) ) ((>= 12 (size X)) (ifn (memq (car X) '(set setq default)) (print X) (prin "(") (let (P (circ? X) Z X) (printsp (++ X)) (prtty2 X NIL Z) ) (prin ")") ) ) ((memq (car X) '(=: use later recur tco tab new)) (_pretty (space) (print (++ X)) (prtty1 X N Z) ) ) ((memq (car X) '(setq default)) (_pretty (if (cdddr X) (prog (nlPrt N) (prtty2 X N Z) ) (spPrt (++ X)) (nlPrt1 (++ X) N) ) ) ) ((memq (car X) '(T NIL ! if ifn when unless case casq with catch throw push bind job in out err ctl)) (prtty3 X N) ) (T (prtty0 X N)) ) ) (de _pretty "Prg" (prin "(") (let (P (circ? X) Z X) (print (++ X)) (run "Prg") ) (prin " )") ) (de prtty0 (X N) (prin "(") (let (P (circ? X) Z X) (pretty (++ X) (- -3 N)) (prtty1 X N Z) ) (prin " )") ) (de prtty1 (X N Z) (loop (NIL X) (T (atom X) (prin " . ") (print X) ) (T (== Z X) (prin " ." (unless P " )")) ) (when (== P X) (nlPrt N) (inc 'N 3) (prin ". (") (setq Z P P) ) (nlPrt1 (++ X) N) ) ) (de prtty2 (X N Z) (loop (print (++ X)) (NIL X) (T (atom X) (prin " . ") (print X) ) (T (== Z X) (prin " ." (unless P " )")) ) (when (== P X) (nlPrt N) (inc 'N 3) (prin ". (") (setq Z P P) ) (if N (prtty? (++ X) N) (space) (print (++ X)) ) (NIL X) (T (atom X) (prin " . ") (print X) ) (T (== Z X) (prin " ." (unless P " )")) ) (when (== P X) (nlPrt N) (inc 'N 3) (prin ". (") (setq Z P P) ) (if N (nlPrt N) (space 2) ) ) ) (de prtty3 (X N) (prin "(") (let (P (circ? X) Z X) (print (++ X)) (when (or (atom (car X)) (>= 12 (size (car X)))) (spPrt (++ X)) ) (when X (prtty1 X N Z) (space) ) ) (prin ")") ) (de prtty? (X N) (ifn (or (atom X) (>= 12 (size X))) (nlPrt1 X N) (spPrt X) ) ) (de spPrt (X) (space) (print X) ) (de nlPrt (N) (prinl) (space (+ 3 N)) ) (de nlPrt1 (X N) (prinl) (pretty X (+ 3 N)) ) (de pp ("X" C) (let *Dbg NIL (pretty (cond ((or C (pair "X")) (cons 'dm "X" (if (pair "X") (method (car "X") (cdr "X")) (method "X" C) ) ) ) ((getd "X") (cons 'de "X" @)) (T (cons 'def (lit "X") (val "X"))) ) ) (prinl) "X" ) ) (de show ("X" . @) (let *Dbg NIL (setq "X" (pass get "X")) (when (sym? "X") (print "X" (less (val "X"))) (prinl) (maps '((X) (space 3) (if (atom X) (prog (print X) (remark X)) (print (cdr X) (less (car X))) (remark (car X)) ) (prinl) ) "X" ) ) "X" ) ) (de view (X Y) (let *Dbg NIL (if (=T Y) (let N 0 (recur (N X) (when X (recurse (+ 3 N) (cddr X)) (space N) (println (car X)) (recurse (+ 3 N) (cadr X)) ) ) ) (let (P (circ? X) Z X) (loop (T (atom X) (println X)) (if (atom (car X)) (println '+-- (++ X)) (print '+---) (view (++ X) (append Y (cons (if X "| " " "))) ) ) (NIL X) (mapc prin Y) (T (== Z X) (println '*)) (ifn (== P X) (println '|) (prinl "|*") (setq Z P P) ) (mapc prin Y) ) ) ) ) ) ### Check ### # Assertions (de assert Prg (when *Dbg (let A (if (cdr Prg) (cons 'and Prg) (car Prg)) (cons (list 'unless A (list 'quit "'assert' failed" (lit A)) ) ) ) ) ) # Unit tests (de test ("Pat" . "Prg") (bind (fish pat? "Pat") (unless (match "Pat" (run "Prg")) (msg "Prg") (quit "'test' failed" "Pat") ) ) ) ### Debug ### `*Dbg (and (info "~/.pil/rc") (load @@)) (load "@lib/lint.l" "@lib/debug.l" "@lib/vip.l") (noLint 'recurse) (mapc noLint '(pretty _pretty) 'Z) (mapc noLint '(pretty _pretty prtty0 prtty1 prtty2 prtty3) 'P) pil21/ext.l0000644000000000000000000000021413746027226007656 0ustar # 27oct20 Software Lab. Alexander Burger (load "@lib/net.l" "@lib/misc.l" "@lib/btree.l" "@lib/db.l" "@lib/pilog.l") `*Dbg (docs "@doc/") pil21/man/man1/picolisp.10000644000000000000000000000573214030304301012201 0ustar .\" 26oct20abu .\" .TH PICOLISP 1 "" "" "User Commands" .SH NAME pil, picolisp \- a fast, lightweight Lisp interpreter .SH SYNOPSIS .B pil [arguments ...] [-] [arguments ...] [+] .br .B picolisp [arguments ...] [-] [arguments ...] [+] .SH DESCRIPTION .B PicoLisp is a Lisp interpreter with a small memory footprint, yet relatively high execution speed. It combines an elegant and powerful language with built-in database functionality. .P .B pil is the startup front-end for the interpreter. It takes care of starting the binary base system and loading a useful runtime environment. .P .B picolisp is just the bare interpreter binary. It is usually called in stand-alone scripts, using the she-bang notation in the first line, passing the minimal environment in .I lib.l and loading additional files as needed: .P .RS #!/usr/bin/picolisp /usr/lib/picolisp/lib.l .RE .RS (load "@ext.l" "myfiles/lib.l" "myfiles/foo.l") .RE .RS (do ... something ...) .RE .RS (bye) .RE .SH INVOCATION .B PicoLisp has no pre-defined command line flags; applications are free to define their own. Any built-in or user-level Lisp function can be invoked from the command line by prefixing it with a hyphen. Examples for built-in functions useful in this context are .B version (print the version number) or .B bye (exit the interpreter). Therefore, a minimal call to print the version number and then immediately exit the interpreter would be: .P .RS $ pil -version -bye .RE .P Any other argument (not starting with a hyphen) should be the name of a file to be loaded. If the first character of a path or file name is an at-mark, it will be substituted with the path to the installation directory. .P All arguments are evaluated from left to right, then an interactive .I read-eval-print loop is entered (with a colon as prompt). .P A single hyphen stops the evaluation of the rest of the command line, so that the remaining arguments may be processed under program control. .P If the very last command line argument is a single plus character, debugging mode is switched on at interpreter startup, before evaluating any of the command line arguments. A minimal interactive session is started with: .P .RS $ pil + .RE .P Here you can access the reference manual (expects the shell variable BROWSER to be set, defaults to "w3m") .P .RS : (doc) .RE .P and the online documentation for most functions, .P .RS : (doc 'vi) .RE .P or directly inspect their sources: .P .RS : (vi 'doc) .RE .P The interpreter can be terminated with .P .RS : (bye) .RE .P or by typing Ctrl-D. .SH FILES Runtime files are maintained in the ~/.pil directory: .IP ~/.pil/tmp// Process-local temporary directories .IP ~/.pil/rc Loaded after interpreter startup .IP ~/.pil/viprc Loaded by the Vip editor .SH BUGS .B PicoLisp doesn't try to protect you from every possible programming error ("You asked for it, you got it"). .SH AUTHOR Alexander Burger .SH RESOURCES .B Home page: http://home.picolisp.com .br .B Download: http://www.software-lab.de/down.html pil21/man/man1/pil.10000644000000000000000000000002411535376005011151 0ustar .so man1/picolisp.1 pil21/doc/man.html0000644000000000000000000001076514030304521011102 0ustar Content-type: text/html; charset=UTF-8 Man page of PICOLISP

PICOLISP

Section: User Commands (1)
Updated:
Index Return to Main Contents
 

NAME

pil, picolisp - a fast, lightweight Lisp interpreter  

SYNOPSIS

pil [arguments ...] [-] [arguments ...] [+]
picolisp [arguments ...] [-] [arguments ...] [+]  

DESCRIPTION

PicoLisp is a Lisp interpreter with a small memory footprint, yet relatively high execution speed. It combines an elegant and powerful language with built-in database functionality.

pil is the startup front-end for the interpreter. It takes care of starting the binary base system and loading a useful runtime environment.

picolisp is just the bare interpreter binary. It is usually called in stand-alone scripts, using the she-bang notation in the first line, passing the minimal environment in lib.l and loading additional files as needed:

#!/usr/bin/picolisp /usr/lib/picolisp/lib.l
(load "@ext.l" "myfiles/lib.l" "myfiles/foo.l")
(do ... something ...)
(bye)
 

INVOCATION

PicoLisp has no pre-defined command line flags; applications are free to define their own. Any built-in or user-level Lisp function can be invoked from the command line by prefixing it with a hyphen. Examples for built-in functions useful in this context are version (print the version number) or bye (exit the interpreter). Therefore, a minimal call to print the version number and then immediately exit the interpreter would be:

$ pil -version -bye

Any other argument (not starting with a hyphen) should be the name of a file to be loaded. If the first character of a path or file name is an at-mark, it will be substituted with the path to the installation directory.

All arguments are evaluated from left to right, then an interactive read-eval-print loop is entered (with a colon as prompt).

A single hyphen stops the evaluation of the rest of the command line, so that the remaining arguments may be processed under program control.

If the very last command line argument is a single plus character, debugging mode is switched on at interpreter startup, before evaluating any of the command line arguments. A minimal interactive session is started with:

$ pil +

Here you can access the reference manual (expects the shell variable BROWSER to be set, defaults to "w3m")

: (doc)

and the online documentation for most functions,

: (doc 'vi)

or directly inspect their sources:

: (vi 'doc)

The interpreter can be terminated with

: (bye)

or by typing Ctrl-D.  

FILES

Runtime files are maintained in the ~/.pil directory:
~/.pil/tmp/<pid>/
Process-local temporary directories
~/.pil/rc
Loaded after interpreter startup
~/.pil/viprc
Loaded by the Vip editor
 

BUGS

PicoLisp doesn't try to protect you from every possible programming error ("You asked for it, you got it").  

AUTHOR

Alexander Burger <abu@software-lab.de>  

RESOURCES

Home page: http://home.picolisp.com
Download: http://www.software-lab.de/down.html

 

Index

NAME
SYNOPSIS
DESCRIPTION
INVOCATION
FILES
BUGS
AUTHOR
RESOURCES
This document was created by man2html, using the manual pages.
Time: 08:01:21 GMT, March 29, 2021 pil21/doc/ChangeLog0000644000000000000000000014744114771741541011240 0ustar ####### 25.3 ####### 25.3.24 Don't skip empty value in 'create' for updates More 'create' tuning lib/db.l 25.3.20 'stdEval' must preserve '$At2' src/io.l 'rt' function src/glob.l src/main.l doc/ref.html doc/refR.html 25.3.19 Remove parallelization with 'later' from 'create' lib/db.l 25.3.13 KeyEvent 'keyCode' and 'charCode' are deprecated lib/form.js 25.3.11 "onkeypress" is deprecated lib/xhtml.l 25.3.9 Fix description of 'peek' (does not block, but returns only the next byte) doc/refP.html 25.3.8 Scroll page on horizontal touch movements in tables lib/form.js Cosmetics src/io.l lib/form.l 25.3.7 Move 'pagehide' handling (back/forward cache) from 'html' to 'form' lib/xhtml.l lib/form.l 25.3.6 Remove @lib/tinymce.l from distribution 25.3.2 Change type of '$NsLink' from 'i64*' to 'any' src/glob.l 25.2.27 Export namespace list from 'repl' via 'T' argument to 'symbols' src/glob.l src/sym.l src/io.l doc/refS.html 25.2.26 Typo doc/refI.html doc/refN.html Use 'any' instead of 'intern' for '+' arguments bin/vip 25.2.21 Move cursor left in final left scroll lib/vip.l 25.2.17 Scroll two steps with horizontal arrow keys lib/vip.l 25.2.13 'tco' continued lib/lint.l 25.2.9 'tco' continued src/flow.l lib.l test/src/flow.l 25.2.8 'tco' and 'tc' tail call optimization functions src/glob.l src/flow.l doc/ref.html doc/refR.html doc/refT.html 25.2.5 'if@@' function src/glob.l src/flow.l test/src/flow.l doc/ref.html doc/refC.html doc/refI.html 25.2.1 Missing 'F' argument to 'packJson' lib/json.l 25.1.22 Change 'permute' to use a callback function lib/simul.l 25.1.21 Postpone first move event for better double-click detection lib/canvas.js 25.1.9 Re-introduce "array" feature lib/json.l 25.1.5 Handle "^?" lib/vip.l Read and print decimal unicode in symbol names src/io.l lib.l 25.1.4 Wrong examples for 'eval' and 'run' offset doc/refE.html doc/refR.html Fix 'remark' lib.l ####### 24.12 ####### 24.12.30 Remove '*SesAdr' check lib/http.l lib/adm.l 24.12.23 Automatic lib configuration (Mike Pechkin) src/Makefile Reset form on 'pagehide' event to disable back/forward cache lib/xhtml.l 24.12.22 Reduce Cache-Control to 'no-store' lib/http.l 24.12.17 'remark' continued lib.l lib/vip.l Typo doc/refT.html 24.12.16 'remark' function to generalize REPL-comments src/glob.l src/io.l lib.l lib/vip.l doc/refR.html 'complete' reference doc/refC.html 24.12.14 Print namespace of symbols in REPL-comments src/io.l lib/vip.l 24.12.13 Cyan attribute for REPL-comments src/io.l 'markup' also in 'scratch' Print numbers as fixnum-comments also in Vip REPL lib/vip.l 24.12.10 New file lib/vip/load.l 24.12.5 Add ":wq" as alias for ":x" lib/vip.l 24.12.2 Add section about namespaces doc/ref.html doc/refE.html doc/refI.html doc/refL.html doc/refN.html doc/refP.html doc/refS.html 24.11.23 Example for catching errors doc/refC.html 24.11.21 Intern mark names into 'vip' lib/vip.l 24.11.20 Generalize 'llvm~fmtNum' Print numbers as fixnum-comments in REPL src/big.l src/io.l src/subr.l doc/rc.sample doc/refR.html doc/refS.html doc/ref_.html 24.11.7 Remove obsolete C-level 'lisp' descriptions doc/refN.html doc/native.html 24.10.16 Support also HOME and END keys lib/vip.l ####### 24.9 ####### 24.9.7 '0' for empty name in minimal symbol diagram doc/ref.html 24.8.19 Stop 'gps' via 'Flg' argument lib/android.l 24.8.16 'pil' is obsolete doc/refT.html 24.8.7 Add 'L' and 'S' to private symbols lib/vip.l 24.8.6 Pass TERM environment variable to 'psh' lib/http.l bin/psh 24.8.4 'wake' returns 'isHeld' lib/android.l 24.8.3 Fix 'gps' with two Location Listeners lib/android.l 24.7.30 Typo doc/refN.html 24.7.23 Call 'restart' as a UI thread (avoid 'java' reentrancy) lib/android.l 24.7.15 Cosmetics src/io.l src/ht.l 24.7.10 'volatile' access to '$Signal' src/lib/llvm.l src/dec.l 24.7.9 'Exe' argument to 'xName' not used src/main.l src/sym.l src/io.l src/db.l src/flow.l src/ext.l 'prompt' function src/glob.l src/main.l doc/ref.html doc/refP.html Typo doc/structures 24.7.7 Check for stale I/O frames in 'unwind' src/main.l 24.7.5 Change pbPut/pbGet to Zip transfers bin/pty Bug in 'erVar' lib/form.l Typo doc/refD.html 24.7.4 Mention '~' in the 'pico' reference doc/refP.html 24.7.3 Check for SDK_INT >= 31 in 'alarm?' lib/android.l 24.7.2 Adjust 'alarm' for changed numeric arguments lib/android.l ####### 24.6 ####### 24.6.27 Minimal delay time 1 ms in 'des' lib/simul.l Force frame buffer register through runCo() src/flow.l Re-arrange structures for alignment src/glob.l src/dec.l 24.6.26 'otg' in coroutine structure missing doc/structures 24.6.23 Show terminated originator in 'yield' error src/flow.l 24.6.22 'prv' in coroutine structure is obsolete doc/structures Fix 'This' upon coroutine termination Bug in coroutines with non-symbolic tags src/flow.l 24.6.21 Change 'opt' from "-O3" to "-O2" src/Makefile Generalize 'all*' lib.l dirString() function src/main.l Bug in coroutine free-list management src/flow.l 24.6.20 Generalize output in 'tty' src/main.l src/gc.l Check for terminated originator in 'yield' src/flow.l 24.6.18 Clear 'at' in coroutine 'unwind' src/main.l 'putCrtEnv' clean up src/dec.l src/flow.l 24.6.17 Reentrant 'co' checks src/flow.l 24.6.16 Thread exceptions revisited lib/android.l 24.6.14 'alarm?' function lib/android.l 24.6.13 Call fcntlSetFl() in 'accept' if OpenBSD or FreeBSD lib/net.l 24.6.12 Disallow reentrant 'co' calls src/flow.l doc/ref.html doc/refC.html 24.6.9 Default format 72 columns lib/vip.l COPYING README INSTALL doc/microTemplates 24.6.5 Handle thread exceptions in 'java1' lib/android.l 24.6.2 Make 'dirname' and 'basename' non-destructive lib/misc.l 24.5.30 'catch' stores throw/error-flag in '@@' src/flow.l test/src/flow.l doc/refC.html lib/vip.l lib/form.l 24.5.24 'iter' returns 'NIL' doc/refI.html 24.5.23 Typo doc/search.html 24.5.8 Minor mismatch doc/faq.html 24.4.4 TAB-completion also for search commands lib/vip.l 24.4.3 No 'flushAll' in child process 'bye' src/main.l src/lib.c 24.4.1 'for' instead of 'while' in 'des' lib/simul.l 24.3.31 Change 'sendCmd' protocol to UDP -> background task bin/pty ####### 24.3 ####### 24.3.29 Include lib/sysdefs in "clean2" src/Makefile 24.3.28 Ignore ESC in command mode lib/vip.l 24.3.11 Call (raw T) at start and (raw NIL) when done lib/vip.l 24.3.10 'scale' function lib/svg.l 24.3.5 Bug in "words" doc/viprc.sample 24.2.3 Fix 'stack' reference doc/refS.html 24.1.29 Runtime relations via 'erVar' function lib/form.l 24.1.21 Add "apk" to '*Mimes' lib/http.l 23.12.29 Minor comment lib/simul.l ####### 23.12 ####### 23.12.18 requestAnimationFrame() not helpful lib/canvas.js 23.12.13 'P' instead of 'N' in native call (malloc() returns pointer) test/src/main.l '*DB' is 'NIL' while no database is open src/glob.l src/main.l src/gc.l src/db.l doc/refD.html 23.12.12 'server' single-shot (non-forking) mode with 'Flg' argument lib/http.l 23.12.9 ZERO-cache also for 'co' stopping src/flow.l 23.12.8 ZERO-cache and free-list for 'co' speedup src/glob.l src/dec.l src/main.l src/flow.l doc/ref.html 23.12.6 'co' crashes when gc() runs in put() src/flow.l 23.12.5 Return 1 from ulimStk() for minimal stack address src/lib.c 23.12.4 Use 'key' instead of 'line' (because of GNU readline behaviour change) in 'more' and 'bt' lib/debug.l doc/refM.html doc/refB.html in 'select' lib/sq.l doc/refS.html and in 'query' (and thus also '?') lib/pilog.l doc/refQ.html doc/ref_.html 23.12.3 Global '$StkBrk' not needed src/glob.l src/main.l 23.12.1 Change transient "U" in 'bench' to private lib/debug.l 23.11.30 Typo doc/refN.html 23.11.29 Default '*Rt' off lib/simul.l doc/des.html Check for empty 'lst' in renderCanvas() lib/canvas.js 23.11.28 Transient "U" in 'bench' lib/debug.l 23.11.27 Resume all coroutines waiting for the same point in time lib/simul.l doc/des.html 23.11.26 Use '*@@' instead of '@@' lib/vip.l 'make' stores linkage cell in '@@' src/subr.l doc/refM.html 23.11.22 Simplify key loop in 'des' lib/simul.l 23.11.19 Fix 'help' for new reference format lib/debug.l doc/refH.html 23.11.18 Handle optional count in ":bd" lib/vip.l Explicit symbol argument to 'new' src/flow.l doc/refN.html 23.11.17 'sext' constexprs are deprecated (Mike Pechkin) src/lib/llvm.l 23.11.12 Use 'push1' instead of 'push' in 'finish' lib.l Mark end of layout in 'tracks' also with "#" lib/simul.l Remove @lib/compat.l from distribution 23.11.7 Fix 'cancel' call in 'alarm' Checks for SDK_INT >= 26 are obsolete lib/android.l 23.11.3 Search also for inherited indexes in 'select' Clean up lib/sq.l doc/refS.html 23.10.31 Handle external symbols in 'xName' src/main.l 'flg' argument to 'ext?' to check physical existence src/db.l lib/debug.l lib/vip.l 23.10.30 More general matching in 'search' lib/db.l Skip duplicates in 'hintQ' lib/form.l 23.10.29 Load @lib/sq.l at the end of @lib/db.l lib/db.l lib/pilog.l Keep relative file position lib/vip/html.l 23.10.28 Change 'hintQ' to use 'match>' lib/form.l Return 'Val' from 'match>' methods lib/db.l 23.10.27 Minor comment lib/svg.l Change 'dump' to use 'search' lib/too.l 23.10.26 Insert "# VIP " headers Fix 
 markups
      *.html

23.10.25
   Typo
      doc/search.html
   Minor comments
      src/subr.l
      doc/refC.html

23.10.24
   Typo
      doc/search.html

23.10.23
   Continued
      doc/search.html
   Add "search.html"
      doc/toc.html
   Comments
      lib/db.l

23.10.22
   Style for 
 tags
      doc/doc.css

23.10.21
   Documentation continued
      doc/refS.html
      doc/search.html

23.10.20
   New file
      doc/search.html
   Use (sys "BROWSER") if set
      lib/vip.l

23.10.19
   Cosmetics
      lib/vip/draw.l
   New file
      lib/vip/html.l
   Check for "# VIP " in the first three lines
      lib/vip.l

23.10.18
   Use inherited tree
      lib/db.l

23.10.17
   Optional extract-function argument to 'search'
      lib/db.l
      doc/refS.html

23.10.16
   Bug in 'iter>' for '+Sn'
      lib/db.l

23.10.15
   Change 'select' to use 'search'
      lib/sq.l
   '+DbChart' and 'hintQ' functions
      lib/form.l
   'search' function with 'iter>' and 'match>' methods
      lib/db.l
      doc/ref.html
      doc/refC.html
      doc/refS.html
   New file
      doc/search

23.10.5
   Check 'status != 200' in 'onload'
      lib/form.js

####### 23.9 #######
23.9.27
   Add namespace "-ap~main"
      doc/select.html

23.9.26
   Cosmetics
      lib/form.l

23.9.23
   Use '*Evt' mechanism instead of 'Busy'
      lib/form.l
      lib/form.js
   Remove 'vf'
      lib/vip.l

23.9.20
   Change global 'FormReq' to local
      lib/form.js

23.9.19
   Optionally cache image in 'csDrawImage'
      lib/canvas.l
      lib/canvas.js

23.9.17
   Missing semicolon
      lib/canvas.js

23.9.13
   Remove 'Queue' global
      lib/form.js

23.9.9
   Remove "form.html" and "app.html", add "des.html"
      doc/toc.html

23.9.8
   Don't fall back to stdin/stdout for closed files
      src/io.l
   Load also @lib/lint.l in 'psh'
      lib/http.l

23.9.7
   Realtime mode 'off' in "dining" demo
      doc/des.html

23.9.6
   Preserve initial 'This' in coroutines
      src/flow.l
      doc/ref.html

23.9.5
   Adjust LLVM version check (Mike Pechkin)
      src/Makefile

23.9.4
   Mark 'tag' and 'prg' also in non-running coroutines
      src/gc.l

23.9.3
   Allow reentrancy in coroutines
      src/flow.l
      doc/ref.html

23.8.31
   Tag checks in 'co' and 'yield'
      src/dec.l
      src/flow.l
   Cosmetics
      doc/des.html

23.8.29
   'noLint' for 'RED'
      lib/term.l

23.8.28
   Homogenize 'input' and' 'output'
      src/glob.l
      src/dec.l
      src/main.l
      src/gc.l
      src/io.l
      src/flow.l
   'null' instead of '@null' in 'table'
      src/lib/llvm.l

23.8.27
   Set namespace for '+' argument in debug mode
      bin/vip

23.8.26
   Handle $ErrFrames and $CtlFrames in coroutines
      src/flow.l
      src/dec.l
   'yield' bug revisited
      src/flow.l

23.8.25
   Release reference to Java object (Todd Coram)
      lib/android.l

23.8.22
   Bug in 'yield' for nested coroutines
      src/flow.l

23.8.21
   Move 'getSize' to lib/term.l
      lib/term.l
      lib/vip.l
   'clear' function
      lib/term.l

23.8.20
   Generalize 'attr'
      lib/term.l

23.8.15
   Note about coroutine environments
      doc/ref.html

23.8.13
   Clarify 'stack' reference
      doc/refN.html

23.8.12
   Avoid 'read' in 'download'
      lib/misc.l

23.8.8
   Search first 'priv' in 'nsp'
      src/sym.l
      doc/refP.html
   Rename lisp-level functions '_xxx' to '_Xxx'
      src/glob.l
      src/main.l
      src/gc.l
      src/big.l
      src/sym.l
      src/io.l
      src/db.l
      src/apply.l
      src/flow.l
      src/subr.l

23.8.7
   'startForeground' with service type
      lib/android.l

23.8.6
   Set SSL_CERT_FILE only if on mobile device
      lib/android.l

23.8.4
   Check local variables for lower case in 'lint'
      lib.l
      lib/lint.l
      lib/xhtml.l
      lib/form.l
      lib/svg.l

23.8.3
   Defer advancing the list pointer in 'for'
      src/flow.l

23.8.1
   Fixes to 'native' description
      doc/refN.html
      doc/native.html
   Target SDK 34 / androidx
      lib/android.l

23.7.28
   opaque-pointers for '18 > LLVM >= 15' (Mike Pechkin)
      src/Makefile

23.7.24
   Partially revert style simplification from 21.11.21
      lib/form.l
      lib/form.js

23.7.23
   New Vip commands
      - "gw" View Web page
      - "gh" View HTTP code
      - "gb" Invoke Browser (w3m)
   Implicit writing to 'scratch' files
   Extend 'map+', 'map+g' and 'map+q'
      lib/vip.l

23.7.21
   Minor clarification of @-result
      doc/ref.html

23.7.20
   Revisit 'allow'
      lib/svg.l

23.7.19
   Missing arg to "getnameinfo" in 'host'
      lib/net.l

23.7.17
   Generalize 'def' for 'any' keys
      src/flow.l
      doc/refD.html
   Don't 'allow' temporary files by default any longer
      lib/http.l
      lib/xhtml.l
      lib/svg.l

23.7.13
   Bug in 'input' and 'output': Must preserve '@'
      src/io.l

23.7.10
   Revert change from 23.7.6
      bin/vip
   TAB-completion also from command history
      lib/vip.l

23.7.8
   Note about accessing symbol values in ':'
      doc/ref_.html

23.7.7
   'all*' function
      doc/ref.html
   Exponent notation in 'parseJson' and 'readJson'
      lib/json.l

23.7.6
   Use 'str' instead of direct 'intern' to handle namespaces
      bin/vip

23.7.4
   Generalize HTTP method support
      src/httpGate.c

23.7.2
   Deprecate 'zxing?' / 'queryIntentActivities'
      lib/android.l

####### 23.6 #######
23.6.25
   Print current coroutine in 'stkErr'
      src/main.l

23.6.18
   Minor comment
      bin/pty

23.6.16
   Minor elaboration on the 'sect' reference
      doc/refS.html

23.6.6
   Disallow append mode (via "+file") in 'in' and 'load'
      src/io.l
      doc/refI.html
      doc/refO.html

23.6.4
   '+' defaults to tag in debug mode
      bin/vip
   Accept 'any' in 'intern'
      src/lib/llvm.l
      src/sym.l
      lib.l
      test/src/sym.l
      doc/refI.html
      lib/form.l
      lib/dbgc.l

23.5.27
   Global '*AlwaysAsk'
      lib/form.l

23.5.25
   Track network functions
      lib/simul.l
   New file
      doc/Tracks
   Add more stack checks
      src/main.l
      src/flow.l

23.5.24
   Change stack segment safety margin from 4096 to 1024
      src/glob.l
      src/flow.l

23.5.15
   Remove 'Cpy' from getCrtEnv(), set 'env' and '$StkLimit' in loadCoEnv()
      src/dec.l
      src/main.l
      src/flow.l

23.5.7
   Show buffer and dirty status also for long path names
      lib/vip.l

23.5.6
   Deprecate "ta" abbreviation for "tag" command
      lib/vip.l

23.5.5
   Fix description of left/right fork signals
      doc/des.html

23.4.28
   Set 'home' property in '' to '*Top'
      lib/canvas.l

23.4.25
   Wait for multiple events in 'pause'
      lib/simul.l
      doc/des.html

23.4.24
   Use 'idx' instead of 'rank' in '*Next'
      lib/simul.l
      doc/des.html
   Bug in 'compare' for anonymous symbols
      src/main.l

23.4.22
   New file
      doc/des.html
   Return max and min from 'idx' for 'T' and 'NIL' key arguments
   Randomize 'idx' if 'flg' is '0'
      src/sym.l
      src/io.l
      doc/refI.html
   chance() function
      src/dec.l
      src/lib.c

23.4.18
   Needs 'symb?' instead of 'sym?' in 'repl'
      src/io.l
   Cache coroutines for 'yield' in ZERO-properties
      src/main.l
      src/flow.l
   Clean up ZERO key handling in 'put' and 'get'
      src/sym.l
      src/flow.l
   Bug in ffiPrep() for direct Lisp arguments
      src/lib.c

23.4.16
   'private' cosmetics
      lib/net.l

23.4.13
   'finish' function
      lib.l
      lib/app.l
      lib/heartbeat.l
      bin/pty
      bin/watchdog
      doc/ref.html
      doc/refB.html
      doc/refF.html
      doc/refO.html

23.4.5
   Evaluate list arguments in 'select'
      lib/sq.l
      doc/refS.html

23.4.3
   Examples and test cases for 'ext:Base64' in 'input' and 'output'
      test/src/ext.l
      doc/refI.html
      doc/refO.html

####### 23.3 #######
23.3.29
   Make second port for pbPut/pbGet optional
      bin/pty

23.3.28
   Suppress duplicates in 'db/[345]'
      lib/pilog.l

23.3.27
   Fix escapes for special characters
      lib/debug.l
      doc/ref.html
      doc/refB.html
      doc/refD.html
      doc/refE.html
      doc/refN.html
      doc/refM.html
      doc/refP.html
      doc/refR.html
      doc/refU.html
      doc/refX.html
      doc/ref_.html
      doc/tut.html
      doc/native.html

23.3.26
   Fix various markup issues
      lib/debug.l
      lib/form.l
      ref.html
      ref?.html
      faq.html
      tut.html
      native.html
      select.html
      httpGate.html
   Set download link to demoApp.tgz
      doc/select.html

23.3.25
   Undo tag argument restriction from 14feb23
      src/flow.l
      doc/refC.html
      doc/refY.html

23.3.19
   Allow one "-" in uppercase global constants
   Handle 'default'
      lib/lint.l
   'noLint' for 'null'
      lib/android.l

23.3.17
   Repeat last shell command with ":$"
      lib/vip.l

23.3.13
   Support more attributes in 'serverSentEvent'
   Force chunked transfer in 'serverSend'
      lib/xhtml.l

23.3.5
   Typo
      lib/vip.l
   Restrict 'words' command to 'delimNs'
      doc/viprc.sample

23.2.27
   Bug in 'js>' for '+Url'
      lib/form.l

23.2.22
   Default hasbangs to /usr/bin/pil
      bin/pty
      bin/psh
      bin/watchdog

23.2.14
   Tag argument to 'co' and 'yield' must be a symbol
      src/flow.l
      doc/refC.html
      doc/refY.html

23.2.9
   Add "mp4" to '*Mimes'
      lib/http.l

####### 23.2 #######
23.2.8
   Check for atomic argument in 'made'
      src/subr.l

23.2.6
   Undo cosmetics from 14jul22
      lib/btree.l

23.2.5
   Keep 'prg' argument to 'des' private
      lib/simul.l

23.2.4
   Allow numeric argument to 'repl'
      src/io.l
   Add BROWN and PURPLE
      lib/term.l

23.2.1
   Numeric '*Rt' as speedup factor
   Optional 'prg' argument to 'des'
   Change '*Key' to fifo structure '*Keys'
      lib/simul.l

23.1.31
   Optional 'var' argument to 'key'
      src/io.l
      doc/refK.html

23.1.27
   Optional anchor for ''
   '' anchor function
      lib/xhtml.l

23.1.21
   Init '*Key' in 'des'
   Bug in 'wake'
      lib/simul.l

23.1.15
   Handle 'onOff'
      lib/lint.l

23.1.14
   Auto-quote 'null'
      lib/android.l

23.1.13
   'setCooked', 'setRaw' not needed in 'main' and 'brkLoad'
      src/main.l
      src/flow.l
   Call rl_deprep_terminal() in 'setCooked'
      src/lib.c

23.1.9
   Minor cosmetics
      src/main.l

23.1.6
   Add link to @lib/bash_completion
      INSTALL

23.1.2
   Separate buffer for each "$" (shell) command call
      lib/vip.l

23.1.1
   Clear *Complete upon backspace
      lib/vip.l

22.12.30
   Handle destructuring function parameters
      lib/lint.l

22.12.28
   Move 'less' to @lib.l
      lib.l
      lib/debug.l
      doc/refL.html

####### 22.12 #######
22.12.21
   Use 'less' in 'show'
      lib.l
      doc/refB.html
      doc/refM.html
      doc/tut.html
   Minor fix indentation
      lib/debug.l
   'circ' for atomic mapping arguments no longer needed
      lib/http.l

22.12.20
   Global '*Key'
      lib/simul.l

22.12.18
   Add GREEN and BLUE
      lib/term.l

22.12.15
   Handle destructuring function parameters in 'funq'
      src/main.l

22.12.12
   Fix 'tword' to go to the last space
      lib/vip.l

22.12.11
   Clear 'last' for deleted buffer
      lib/vip.l
   Directly call 'symbols' in 'tag'
      lib/vip.l

22.12.2
   Add percentage display to ''
      lib/xhtml.l
   Commented example for LEFT and RIGHT
      doc/viprc.sample

22.12.1
   Check for ":" delimiter in TAB-completion
      lib/vip.l

22.11.22
   'boss' is obsolete
      lib/android.l
   TAB-completion also for colon-commands
      lib/vip.l

22.11.20
   Minor privates
      lib/vip.l

22.11.19
   Fix 'unwind'ing coroutines
      src/dec.l
      src/main.l
      src/flow.l
   Reset screen and namespaces upon error
      lib/vip.l
      bin/vip

22.11.18
   'namespaces' function
      lib/debug.l
      doc/refN.html
      doc/refS.html
   Exchange also 'last', 'mark' and 'sc' in ":bx"
      lib/vip.l

22.11.15
   'shadows' function
      lib/debug.l
      doc/refS.html
   Allow also new namespace for '-symbols'
      lib.l

22.11.14
   Wrong 'save' / 'safe' in 'rdList'
      src/io.l
   Private 'queue'
      lib/simul.l

22.11.12
   'tabs' command to replace tabs with spaces
   'words' command to toggle between Lisp an C
      doc/viprc.sample
   Generalize delimiter checking
      lib/vip.l

22.11.11
   Store 'symbols' source info after the change
      src/sym.l

22.11.10
   'info' returns local time instead of UTC if the flag argument is zero
      src/dec.l
      src/main.l
      src/lib.c
      doc/refI.html
      lib/vip.l

22.11.9
   Set blob symlinks in mirror destination directories
      src/ssl.c

22.11.2
   Clear references to deleted buffer in ":bd"
      lib/vip.l

22.10.30
   Don't clear '@' and '@@' before (gc)
      src/gc.l
      doc/refG.html

22.10.26
   Passing zero to 'tell' refers to the parent process
      src/io.l
      src/db.l
      doc/refT.html
   Remove @lib/boss.l from distribution

22.10.21
   Use 'delete' instead of 'replace'
      lib/dbgc.l

22.10.20
   Minor cosmetics
      src/main.l
      src/subr.l

22.10.17
   Decrement 'Ms' in 'waitFd' only if not 292MY
      src/io.l
   Include external declaration of ppoll()
      src/lib.c
   Fix reference of '*CPU'.
      doc/refC.html

22.10.15
   Avoid setting 'last' to current buffer
      lib/vip.l
   Call 'flush' in 'beep'
      lib.l

22.10.6
   'able' checks in 'val>' for '+ObjVal' and '+ObjVar'
      lib/form.l

22.10.4
   Add 'put' and 'get' to reference of '+Joint'
      doc/refJ.html

####### 22.9 #######
22.9.29
   Bitmask bug in 
      lib/xhtml.l

22.9.24
   Use opaque-pointers in LLVM >= 15 (Mike Pechkin)
      src/Makefile

22.9.16
   Support partially circular lists in 'pretty' and 'view'
   Print 'def' in 'pp' instead of 'de' for non-functions
      lib.l
   Simplify printing of circular lists
      src/io.l

22.9.13
   Move "ix.io" to @doc/viprc.sample, added "pb1n"
      lib/vip.l
      doc/viprc.sample
   Bug in 'server' for non-numeric arguments
      lib/net.l

22.9.9
   Allow empty 'url' argument
      src/ssl.c

22.9.6
   Pass FLAG_IMMUTABLE to PendingIntent
      lib/android.l

22.9.4
   Avoid multiple auto timers
      lib/canvas.js

22.9.3
   Pass flag 'T' for mouse/touch events
      lib/canvas.l
      lib/canvas.js

22.9.1
   Make 'all*' selective with 'T' or '0'
      lib.l
      doc/refA.html
      lib/vip.l

22.8.31
   Change 'http' abort time to 20 minutes
      lib/http.l

22.8.30
   '' function
      lib/xhtml.l
   Abort 'http' after 7 seconds
      lib/http.l

22.8.29
   Remove stale symbolic links
      src/ssl.c

22.8.26
   'cmd' function
      lib/vip.l

22.8.22
   Store debug source info in 'symbols'
      src/dec.l
      src/sym.l
      lib/debug.l
      doc/refD.html
      doc/refS.html

22.8.21
   Extend 'pool' tests
      test/src/db.l
      test/lib/db.l

22.8.20
   'b8+' aligns stack buffers to 8 bytes
      src/lib/llvm.l
      src/main.l
      src/io.l
      src/db.l
      src/flow.l
   Pad 'dbFile' and 'child' to multiples of 8
      src/dec.l
   Add file
      doc/viprc.sample
   Improve use cases
      doc/rc.sample

22.8.19
   'gPrintf' returns void
      src/dec.l
   Size check in gPrintf()
      src/lib.c
   'save' before 'loop'
      src/main.l
   '$TickU' and '$TickS' are obsolete
      src/glob.l

22.8.18
   Declare 'Tio' and 'Fsign' as "char" instead of "int"
      src/lib.c
   Make insensitive to endianness
      test/src/main.l

22.8.1
   Add note on destructuring bind of function parameters
      doc/ref.html

22.7.27
   Bug in 'extra' assuming positive pointers
      src/flow.l
   Display applied functions in backtraces
      lib/debug.l
      lib/app.l

22.7.20
   Bug in 'compare' for circular lists
      src/main.l
      test/src/subr.l

22.7.16
   Call 'blob+' in (clone> . +Entity)
      lib/db.l

22.7.15
   Improve 'hex' argument verification
      lib/misc.l

22.7.14
   Use 'skip' instead of 'line' in 'here'
      lib/misc.l
   Minor cosmetics
      lib/btree.l

22.7.13
   'overview' function
      lib/android.l
   Go to last instead of previous buffer in ":bd"
      lib/vip.l

22.7.12
   Remove "Building httpGate"
      doc/httpGate.html
   '' function
      lib/canvas.l

22.7.11
   Go to previous instead of next buffer in ":bd"
      lib/vip.l

22.7.9
   Correct earth mean radius to 6371 km
      lib/gis.l

22.7.8
   'map+', 'map+g' and 'map+q' functions
      lib/vip.l

22.7.3
   Default values in 'print>' methods
      lib/sq.l

22.7.2
   Uncomment 'shift' import
      src/lib/llvm.l
   Let 'beep' return 'NIL'
      lib.l
      lib/vip.l
      doc/refB.html

22.6.30
    Show blank screen in 'restart'
      lib/android.l

####### 22.6 #######
22.6.30
   Bug in realpath() handling
      lib/vip.l

22.6.26
   Corrections (Christos Gitsis)
      doc/ref.html
      doc/refA.html
   More fixes in local coroutine stacks
      src/flow.l

22.6.25
   realpath() directly if directory
      lib/vip.l

22.6.24
   Apply realpath() only to path of the file
      lib/vip.l
   More fixes in local coroutine stacks
      src/flow.l

22.6.23
   Set 'org' when resuming a coroutine in 'co'
      src/flow.l

22.6.22
   Silent exit if connect fails
      src/ssl.c

22.6.17
   Bugs in 'sort' with 'fun' argument
      src/subr.l

22.6.15
   Disable '*Run' in 'sync' calls
      lib/form.l

22.6.13
   Bug in printing symbols overshadowed in 'priv'
      src/io.l

22.6.10
   Don't lock remote symbols
      lib/vip.l

22.6.9
   Check empty name in '+SymField'
      lib/form.l

22.6.7
   Refined system clipboard copy
      lib/vip.l

22.6.6
   Missing "void *" in '*C-Defs'
      src/lib/llvm.l

22.6.3
   Disable form action for stale locks
      lib/form.l

22.5.31
   Remove 'visibilitychange' event handling
      lib/xhtml.l

22.5.30
   'h' function
      lib/debug.l
      doc/refH.html

22.5.29
   String arguments do no longer cause strdup(3) calls
      doc/native.html

22.5.26
   Add 'binutils'
      INSTALL
   Use 'output' instead of 'pipe'
      lib/misc.l
   Replace control characters with backslash sequences
      lib/misc.l
      lib/db.l
      lib/vip.l
      lib/term.l
      lib/http.l
      lib/xhtml.l
      lib/form.l
      lib/canvas.l
      lib/xm.l
      lib/tinymce.l
      test/src/io.l
      test/src/sym.l
      test/lib/misc.l
      doc/tut.html
      doc/refA.html
      doc/refP.html
      doc/form/refS.html
      doc/app.html
      misc/bigtest

22.5.25
   Bug in 'untrace'
      lib/debug.l
   Multi-line data in 'serverSend'
      lib/xhtml.l
   'input' and 'output' functions
      src/glob.l
      src/dec.l
      src/main.l
      src/gc.l
      src/io.l
      test/src/io.l
      doc/ref.html
      doc/refI.html
      doc/refO.html

22.5.18
   Fix 'raw' example
      doc/refR.html
   Clear stdin 'tty' flag in 'pipe' child
      src/io.l

22.5.15
   Replace "%" also if in command window
      lib/vip.l

22.5.13
   Optional "dup" file descriptor argument to 'fd'
      src/io.l
      doc/refF.html
   Use 'in' instead of 'pipe' for "ccrypt" call
      lib/vip.l

22.5.12
   Fix 'dbs' example
      doc/refD.html

22.5.11
   Use '*Uri' instead of '*Url' in 'post'
      lib/form.l

22.5.10
   Support also PUT, PATCH and DELETE
      src/httpGate.c

22.5.6
   Global '*Uri'
      lib/http.l
   Clean up '*Err'
      lib/app.l

22.5.5
   Call 'flush' in 'tty'
      src/dec.l
      src/main.l
      src/ht.l

22.5.3
   Use 'tty' in 'msg'
      lib.l
   Re-introduce 'visibilitychange' event handling
      lib/xhtml.l

22.5.1
   'fun' function
      src/glob.l
      src/apply.l
      test/src/apply.l
      doc/ref.html
      doc/refF.html

22.4.30
   Add "epub" mime type
      lib/http.l

22.4.26
   Outdated example for 'lisp'
      doc/refL.html

22.4.24
   Define PATH_MAX
      src/sysdefs.c
      lib/vip.l

22.4.22
   Preserve 'errno' across readline(3) calls
      src/dec.l
      src/io.l
      src/lib.c
   Word search without 'match' support
      lib/vip.l

22.4.20
   'noLint' declarations
      lib/xhtml.l
      lib/svg.l
      lib/canvas.l

22.4.17
   Don't maintain ErrFrames and CtlFrames in coroutines
   Fix file descriptor leak when stopping coroutines
      src/dec.l
      src/flow.l

22.4.11
   'trail' check not needed
      lib/app.l

22.4.9
   Collect also C-tags into @lib/map
      src/lib/llvm.l
      src/main.l
      src/pico.h
      src/lib.c

22.4.8
   Add "-o lib.bc"
   Add "clean2" target
      src/Makefile

22.4.6
   Optional rounding in 'lat', 'lon' and 'fmt'
      lib/gis.l

22.4.5
   Check zero charCode in hint key events
      lib/form.js

####### 22.3 #######
22.3.16
   Pre-set 'home' property in 'form'
   Conditionally unlock and enable in 'panel'
      lib/form.l

22.3.14
   Bug in 'ps'
      lib/svg.l
   Local and private declarations
      lib/xm.l
   Escape also backslashes in ''
      lib/gis.l

22.3.13
   Escape single quotes in '' text argument
      lib/gis.l
   Use 'get' instead of (cdr (asoq ..))
      lib/xm.l

22.3.8
   Revisit tcsetpgrp() calls
      src/dec.l
      src/flow.l
      lib/debug.l

22.3.4
   Plain searches without 'match' overhead
      lib/vip.l

22.2.28
   Issues with tcsetpgrp() calls
      src/io.l
      src/flow.l

22.2.26
   Transient and private namespaces in catch and coroutine frames
      src/glob.l
      src/dec.l
      src/main.l
      src/gc.l
      src/flow.l

22.2.24
   Refactor 'repl' loops
      src/io.l

22.2.23
   Don't exit top-level REPL
      src/main.l
      src/io.l

22.2.22
   Print error location in 'repl'
      lib/form.l
   Print error location in 'evCmd'
      lib/vip.l

22.2.21
   'height' function
   Handle '0' and 'T' directly in 'ps'
      lib/svg.l

22.2.19
   Handle NILs in (has> . +List)
      lib/db.l
   Increase stack size
      bin/vip

22.2.13
   'move!>' method for '+Entity'
      lib/too.l

22.2.11
   Comment for 'fill'
      src/subr.l

22.2.5
   Remove 'dbs+'
      lib/db.l
      doc/ref.html
      doc/refD.html
   Pass '*Uuid' and arguments to RPC calls
      lib/android.l

22.2.2
   Revisit (rel> . +Dep)
      lib/db.l

22.2.1
   Add 'nth' to "see also" of 'get'
      doc/refG.html

22.1.30
   Additional arguments to 'fish'
      src/apply.l
      doc/refF.html
      test/src/apply.l
      lib/too.l

22.1.28
   Optional third argument to 'fill'
      src/subr.l
      doc/refF.html
      test/src/subr.l

22.1.27
   'wrap' also converts string to list of strings
      lib/misc.l
      doc/refW.html
      test/lib/misc.l
   'badDep' function
      lib/too.l

22.1.26
   Bug in (rel> . +Dep)
      lib/db.l

22.1.21
   Optional database file for 'forall'
      lib/db.l
      doc/refF.html
   Inherit tags from superclasses
      lib/vip.l
   Refactor screen handling
      lib/term.l
      lib/vip.l

22.1.20
   'seq' instead of 'dbMap' in 'dangling'
   'displaced' function
      lib/too.l

22.1.18
   Stack check in 'apply'
      src/apply.l
   Discrete-Event Simulation: 'des', 'pause', 'event' and 'wake' functions
      lib/simul.l

22.1.15
   '-debug' and '-trace' functions
      lib/debug.l
      doc/ref.html
      doc/refD.html
      doc/refT.html

22.1.13
   Change "EMail" to "E-Mail"
      doc/form/refM.html

22.1.11
   Central Kurdish localization (Hunar Omar)
      loc/CKB.l
      loc/ckb

22.1.10
   Variable '*Port'
      bin/pty

22.1.8
   Handle SIGWINCH
      bin/pty
   Reset readline in 'setTerm'
      lib/term.l
   Display namespace in 'repl'
      lib/form.l

22.1.7
   'refObj' searches also values
      lib/too.l

22.1.6
   Don't reset 'Busy' in ping()
      lib/form.js

22.1.4
   Bug in 'name' for external symbols
      src/sym.l

####### 21.12 #######
22.1.3
   Bugs in (del> . +Entity) and (has> . +List)
      lib/db.l
      test/lib/db.l
   'assoc', 'rassoc', 'asoq' and 'rasoq' accept circular lists
      src/subr.l
      test/src/subr.l

21.12.30
   Enable file transfers (via 'pbPut' and 'pbGet' in PilBox)
      bin/pty

21.12.29
   Fix touch scrolling in chart tables
      lib/form.l
      lib/form.js
      lib/xhtml/table

21.12.27
   '-symbols' function
      lib.l
      doc/ref.html
      doc/refS.html

21.12.22
   OpenBSD patch (Frithjof Schulze)
      src/httpGate.c

21.12.20
   Don't put single "." into readline history

21.12.14
   Avoid 'resolveActivity' in 'startActivityForResult'
      lib/android.l

21.12.13
   Splice also atomic results in "~" read macros and 'fill'
      src/io.l
      src/subr.l
      test/src/subr.l
      doc/refF.html

21.12.12
   Bug in 'format' (llvm~fmtNum)
      src/big.l
   Overflow float/double to bignum
      src/dec.l
      src/main.l
      src/pico.h
      src/lib.c

21.12.10
   'native' and 'struct' not limited to C functions
      doc/refN.html
      doc/refS.html
   'Str' not used in 'getWord'
      lib/vip.l

21.12.8
   Add 'adr' to "see also" of 'native'
      doc/refN.html

21.12.5
   Global '*Keys'
   ":map" command
      lib/vip.l

21.12.4
   Lock, sync and commit external symbols
      lib/vip.l

21.11.30
   'R' may be modified in 'evCmd'
      lib/vip.l

21.11.29
   Extend 'command' with '*CmdMap'
   Continue direct editing only with "K" ("^]" always goes to source)
      lib/vip.l

21.11.28
   Remove '*Complete' filter
      lib/vip.l

21.11.26
   'all*' function
      lib.l
      doc/refA.html
   Refactor TAB-completion
      lib/vip.l

21.11.25
   Search namespaces in TAB-completion
      lib/vip.l

21.11.22
   Minor cosmetics
      lib.css
      lib/canvas.js
      lib/plio.js
      lib/gis.js
      loc/ar
      loc/ch
      loc/cn
      loc/de
      loc/hr
      loc/it
      loc/ja
      loc/tr

21.11.21
   Simplify style manipulations
      lib/form.l
      lib/form.js

21.11.18
   Bug in 'bagBag'
      lib/form.l

21.11.17
   Minor cosmetics
      lib/form.l
   Inherit 'Dbf' in 'forall' from superclasses
      lib/db.l

21.11.16
   Re-introduce the '====' function
      src/glob.l
      src/sym.l
      test/src/sym.l
      doc/ref_.html
      doc/diff
   and use it in 'locale'
      lib/misc.l
   Preserve transients in comma read macro
      src/io.l

21.11.15
   Use 'fName' in 'vf'
      lib/vip.l

21.11.12
   '+ObjVar' prefix class
      lib/form.l

21.11.11
   Missing semicolon (Mia)
      lib/form.js

21.11.9
   Increase escape delay from 80 to 120
      lib/vip.l

21.10.31
   Mention Ctrl-D to terminate 'bt', 'query' and '?'
      doc/ref.html
      doc/refB.html
      doc/refM.html
      doc/refQ.html
      doc/ref_.html

21.10.30
   Generalize cut in 'prove'
      src/subr.l

21.10.29
   rl_initialize() not necessary
      src/lib.c

21.10.28
   Display namespace in 'status'
      lib/vip.l
   Minor optimization in '*Prompt'
      lib/debug.l

21.10.27
   'vf' (vi/find) function
      lib/vip.l
   Default '*Tab' to 1
      lib/xhtml.l

21.10.25
   '*KeyMap', '*KeyMap-g' and '*KeyMap-q' globals (Erik Gustafson)
   More transients
      lib/vip.l

21.10.18
   Refactor (gui> . +User)
      lib/adm.l
      lib/user.l

21.10.15
   Mention Ctrl-D to terminate 'more'
      doc/refM.html

21.10.11
   "CSV" -> "Export CSV" in 'csv'
      lib/xhtml.l

21.10.9
   'pico~cells' function
      lib/vip/draw.l
   Minor cosmetics
      lib/vip.l
   Fix 'arrow' for small distances
      lib/vip/draw.l

21.10.2
   Remove '+JsField'
      lib/form.l
      doc/app.html
      doc/form/refJ.html
   Import 'permute' from 'pico' namespace
      lib/simul.l

21.9.29
   '+hintObj' prefix class for '+Obj' and '+ObjVal'
      lib/form.l

21.9.25
   'rand' argument checks
      src/big.l
      doc/refR.html

21.9.24
   Ignore SIGINT in 'ctty' parent process
      src/main.l
   Forward "^D"
      bin/pty

21.9.23
   Clear '*Err'
      bin/pty

21.9.20
   Initial '$StkBrk' and '$StkLimit'
      src/glob.l
      src/main.l

21.9.19
   ulimStk() system call
      src/dec.l
      src/pico.h
      src/lib.c

21.9.17
   Clear 'history' after argument evaluation
      src/main.l

21.9.16
   Insert "^M" before "^J" in 'mail' body
      lib/misc.l
   'refObj' function
      lib/too.l

21.9.13
   Insert "^M" before "^J" in 'mail' body
      lib/misc.l
   'prBase64' optional "^M" argument
      lib/misc.l
      doc/refP.html
   Explanations for reference syntax
      doc/ref.html

21.9.10
   "gg" uses *Count
      lib/vip.l

21.9.3
   'mis>' method for '+Swap'
      lib/db.l

21.9.1
   select() system calls are now poll()
      doc/refK.html
      doc/refL.html
      doc/refR.html
      doc/refS.html
      doc/refW.html

21.8.30
   Typo
      doc/refR.html

21.8.28
   Add note about 'native'
      doc/faq.html
   'rid' function
      test/src/sym.l

21.8.27
   'rid' function
      src/glob.l
      src/sym.l
      test/src/sym.l
      doc/ref.html
      doc/refC.html
      doc/refD.html
      doc/refF.html
      doc/refQ.html
      doc/refR.html

21.8.26
   Bug in 'place'
      src/subr.l
      test/src/subr.l

21.8.25
   Division by zero did not throw an error
      src/big.l
   Private declarations
      lib/xhtml.l

21.8.22
   Default alert text color black
      lib.css

21.8.20
   Wrong 'tty' checks for stdin/stdout
      src/main.l
      src/flow.l

21.8.19
   LLC and LINK variables
      src/Makefile

21.8.18
   Strip binaries
      src/Makefile
   'rasoq' function
      src/glob.l
      src/subr.l
      test/src/subr.l
      doc/ref.html
      doc/refA.html
      doc/refR.html

21.8.16
   Add 'packJson'
      lib/json.l

21.8.14
   Sort TAB-completion
      lib/vip.l
   Host option
      bin/pty

21.8.13
   Check (sys "SHELL") for default shell
      lib/vip.l

21.8.12
   Some Pilog variables private again
      lib/pilog.l

21.8.11
   Default shell "bash" -> "sh"
      lib/vip.l
   Shell prefix "$ " -> "!" in 'repl'
      lib/form.l

21.8.9
   'go', 'up', 'down', 'left' and 'right functions
   'block' function
      lib/vip/draw.l
   Preset terminal attributes in setRaw()
      src/lib.c

21.8.8
   Add files
      lib/term.l
      bin/pty

21.8.7
   Clean up terminal handling
      lib/vip.l

21.8.6
   Add TIOCSWINSZ
      src/sysdefs.c
   Set standard I/O to a PTY with (ctty)
      src/Makefile
      src/dec.l
      src/main.l
      doc/refC.html

21.8.3
   'tty' flag also in 'inFile'
      src/dec.l
      src/main.l
      src/io.l
      src/flow.l

21.7.27
   Direct 'run' in auto-load with "# VIP (...)"
      lib/vip.l

21.7.26
   Bug in reading non-ASCII characters in internal symbols
      src/io.l

21.7.25
   'cnt' argument to 'unify'
      src/subr.l
      lib/pilog.l
      doc/refU.html

21.7.24
   Signal handler in 'prove'
      src/subr.l

21.7.23
   Pilog variables not private
      lib/pilog.l
   Revisit Pilog variables in Lisp expressions
      src/subr.l

21.7.22
   Revisit private symbols in properties
      lib/vip.l

21.7.21
   Global '*Rule' cleared in 'repl'
      src/glob.l
      src/io.l
      doc/ref.html
      doc/refB.html
      doc/refC.html
      doc/refR.html
   Maintain source properties also in 'clause'
      lib/pilog.l
   Bind Pilog variables in Lisp expressions
      src/subr.l
      lib/pilog.l
      test/src/subr.l
      doc/ref.html
      doc/refM.html
      doc/refR.html
      doc/refT.html
   Intern private symbols also in properties
      lib/vip.l
   Bug in 'putSrc' for first property
      src/flow.l

21.7.18
   Minor cosmetics
      src/subr.l

21.7.16
   em120 and em150 styles
      lib.css

21.7.13
   'buf' function
      doc/ref.html
      doc/refB.html

21.7.10
   Revisit (put> . +Swap)
      lib/db.l
      test/lib/db.l

21.7.5
   Fix 'clone>' for '+Swap' in '+Bag'
      lib/db.l

21.7.4
   E/R unit tests
      lib/test.l
      test/src/sym.l
      test/src/db.l
      test/lib/db.l
   Clean up 'has>' methods
      lib/db.l
      lib/tinymce.l
   Revisit '+Bag' and '+Swap'
      lib/db.l

21.7.3
   Support methods as ":ta msg> +Cls"
      lib/vip.l
   Make 'bagBag' non-destructive
      lib/form.l

21.7.2
   'forall' function
      doc/ref.html
   Add file
      doc/rc.sample

21.7.1
   'forall' function
      lib/db.l
      doc/refF.html

####### 21.6 #######
21.6.30
   '+Swp' prefix class
      lib/form.l
   Lazy external symbol creation in '+Swap'
      lib/db.l
   'has>' check in (rel> . +Joint)
      lib/db.l
   Keep application namespaces for background tasks in '*Ns'
      lib/vip.l

21.6.29
   Keep application namespaces for background tasks in '*Ns'
      lib/vip.l
      bin/vip

21.6.24
   Minor addition
      doc/microTemplates

21.6.23
   Micro-templates for '' and ''
      doc/microTemplates

21.6.22
   Micro-templates for '
' and ''
      lib/xhtml.l
      lib/xhtml/table
      lib/xhtml/grid
   Add  and 
      lib/xhtml/tab

21.6.21
   Minor fix in reference for 'all'
      doc/refA.html

21.6.20
   Micro-templates 2.0
      lib/xhtml.l
      lib/xhtml/
      doc/microTemplates

21.6.19
   Wrong 'Attr' output in 'html'
      lib/xhtml.l
   'pack' not needed
      lib/vip.l
   General argument to 'any'
      src/io.l
      doc/refA.html

21.6.18
   Also 'flip'ped sort in 'sortButton'
      lib/form.l

21.6.17
   'sortButton' function
      lib/form.l

21.6.16
   Vip running in coroutine
   Suspend with "qz", resume with (v)
      lib/vip.l
      doc/refV.html

21.6.15
   Fix terminal after 'pipe', 'in' and 'out'
      src/io.l

21.6.14
   Minor fix indentation
      src/flow.l
   Restore private declarations
      lib/xhtml.l
   Missing '+Remote' methods
      lib/db.l

21.6.13
   Add '\e' to escape markups
      src/io.l
      doc/ref.html

21.6.11
   Optional 'put' and 'get' function arguments for '+Joint'
      lib/db.l

21.6.9
   Revert confirm row deletion (01may21)
      lib/form.l

21.6.4
   'ctty' 'NIL' argument is obsolete
      src/main.l
      doc/refC.html
   Minor renaming
      src/flow.l

21.6.2
   Push tag stack in "gf" command
      lib/vip.l
   Add A3 page sizes
      lib/svg.l
   Intern some globals for reload
      lib/form.l

21.6.1
   'class' clears old method and var definitions
   'var' uses 'def' instead of 'put'
      lib.l
      test/lib.l

21.5.29
   Set cooked terminal mode in 'repl'
      src/io.l

21.5.27
   Revisit TAB-completion
      lib/vip.l
   Use 'val' for '+Swap' relations in 'set>'
      lib/db.l

21.5.25
   Revisit TAB-completion from 'history'
      lib/vip.l
   Unary '+' is obsolete in '*Run' setup
      lib.l

21.5.24
   Nesting bug in 'cells'
      lib/vip/draw.l

21.5.23
   Maintain 'symbols' per buffer
      lib/vip.l

21.5.21
   TAB-complete from 'history' on ": "
   ":v" command
      lib/vip.l

21.5.20
   setCooked() only if necessary
      src/lib.c

21.5.19
   Add file
      lib/clang.l

21.5.18
   Fix 'struct'  example
      doc/refS.html

21.5.14
   '' vertical-aligns to top
      lib.css
   Optional submenu CSS class index
      lib/xhtml.l
      lib/xhtml/menu

21.5.12
   Add file
      doc/microTemplates
   Needs '*XhtmlField' in ''
      lib/xhtml.l

21.5.11
   Don't set IPV6_V6ONLY for OpenBSD
      lib/net.l

21.5.10
   64-bit check not needed
      lib/adm.l

21.5.6
   Missing '+Remote' methods
      lib/db.l
   Missing 'mail' handshake (Mike Pechkin)
      lib/misc.l

21.5.5
   Fix catch/throw between coroutines
      src/dec.l
      src/main.l
      src/flow.l
      doc/structures
      doc/ref.html

21.5.4
   I/O save/restore bug in 'co' / 'yield'
      src/main.l
      src/flow.l
   Minor cosmetics (collapse two 'let's)
      src/flow.l
   Fix docs and comments about coroutine tags
      src/main.l
      src/flow.l
      doc/ref.html
      doc/refC.html
      doc/refS.html
      doc/refY.html

21.5.3
   (co) returns tag of current coroutine
      src/flow.l
      doc/refC.html
   'shift' function
      src/glob.l
      src/sym.l
      doc/ref.html
      doc/refS.html
      doc/refP.html
      test/src/sym.l

21.5.1
   Confirm row deletion also if repeated
      lib/form.l

21.4.30
   Add file
      doc/app.html

21.4.29
   Call 'loadCoEnv' in 'unwind'
      src/main.l
      src/flow.l
   Remove coroutines from catch/throw environment
      src/glob.l

21.4.22
   Show thousands-separator in total counts in search dialogs
      lib/form.l

21.4.21
   File in first column of directory listings
      lib/vip.l

21.4.20
   Bug in 'till' reading UTF-8
      src/io.l

21.4.19
   Align SUBRs to 8 bytes
      src/lib/llvm.l

21.4.18
   's-expr' function, evaluate with "^E"
      lib/vip.l

21.4.17
   'stack' return value fix
      src/main.l
      doc/refS.html
   Infinite timeout for values greater than 24 days in '*Run', 'wait' and 'key'
   on non-Linux systems (using ppoll(2) on Linux)
      src/lib.c
   'stack' continued
      src/main.l

21.4.16
   Independent size of main stack segment
      src/glob.l
      src/main.l
      src/flow.l
      doc/refS.html
   'stack' returns unused spaces
      src/main.l
      doc/refS.html
   'llvm~cons2' function
      src/dec.l
      src/gc.l
   Coroutine structure 'prv'
      doc/structures
   Optional alignment for 'memcpy' and 'memset'
      src/lib/llvm.l
      src/main.l
      src/db.l
      src/flow.l

21.4.15
   Infinite timeout for values greater than 24 days in '*Run', 'wait' and 'key'
   (only on systems with sizeof(int) == 4)
      src/lib.c

21.4.14
   Skip remote replication if 'key' is empty
      src/ssl.c

21.4.13
   Bug in '
': Header text not evaluated
      lib/xhtml.l
   ContextCompat 'permit' function
      lib/android.l
   'Str' in 'repl' private
      lib/form.l

21.4.10
   Minor fix indentation
      lib/vip.l

21.4.9
   Extensions to 'NIL' punning
      doc/ref.html

21.4.8
   Support '-fun' command line arguments
      bin/vip

21.4.7
   'enum?' function
      src/glob.l
      src/sym.l
      doc/ref.html
      doc/refE.html
      doc/refL.html
      test/src/sym.l

21.4.4
   Wrong external declaration
      src/ht.l

21.4.3
   Bug in 'stem' (for -O2 or -O3)
      src/subr.l

21.4.1
   'enum' returns cell instead of value
      src/sym.l
      doc/refE.html
      test/src/sym.l
      doc/faq.html
   Bug in '*Term' signal handling
      src/main.l

21.3.31
   '+Remote' entity class
      lib/db.l
      lib/too.l

21.3.30
   Exit '*', '/*', '/' and '%' upon zero
      src/big.l

21.3.29
   Note about the default browser for 'doc' calls
      man/man1/picolisp.1
      doc/man.html

21.3.26
   'enum' with single argument returns association list
      src/sym.l
      doc/refE.html
      test/src/sym.l

21.3.25
   Return 'NIL' from 'enum' if key <= 0
      src/sym.l
   Unit tests for 'enum'
      test/src/sym.l
   '*Term' signal handling (Constantine Bitensky)
      src/glob.l
      src/main.l
      doc/ref.html
      doc/refT.html
      doc/refA.html
      doc/refH.html
      doc/refS.html
      doc/refW.html

21.3.24
   'enum' function
      src/sym.l

21.3.23
   'enum' function
      src/glob.l
      src/sym.l
      doc/ref.html
      doc/refE.html
      doc/refH.html
      doc/refI.html
   'rev' function bit count argument
      src/big.l
      doc/refR.html

21.3.21
   'rev' function
      src/glob.l
      src/big.l
      doc/ref.html
      doc/refR.html
      doc/refH.html
      doc/refI.html
      doc/ref_.html

21.3.17
   Still missing
      lib/xm.l
   Ukrainian and russian localization (Constantine Bitensky)
      loc/RU.l
      loc/uk
      loc/ru

21.3.10
   Renamed "UK.l" to "UA.l", restored "UK.l" and renamed to "GB.l"
   Renamed "gr" to "el" and "jp" to "ja"
      loc/UA.l
      loc/GB.l
      loc/uk
   Symbolic links
      UK.l -> GB.l
      gr -> el
      jp -> ja

21.3.8
   Missing file
      lib/xm.l

21.3.7
   Ukrainian localization (Constantine Bitensky)
      loc/UK.l
      loc/uk

21.3.5
   Subdirectory recursion buffer-local
   Recurse when no trailing "/"
      lib/vip.l

21.3.2
   '*Bye' cleared in children
      src/io.l
      lib.l
      lib/adm.l
      lib/app.l
      doc/diff

21.2.28
   Missing check for 'NIL'
      lib/vip.l

21.2.26
   Remove Access-Control-Allow-Origin header
      lib/http.l

21.2.20
   Prefix "@" with "./" in directory listings
   Recurse into subdirectories with ":E"
      lib/vip.l

21.2.16
   Case insensitive search with "~" prefix
   Increase escape delay to 80 ms
      lib/vip.l

21.2.12
   Rename file to "area", add "field"
      lib/xhtml.l
      lib/xhtml/area
      lib/xhtml/field

21.2.11
   Elaborate ''
      lib/xhtml.l
      lib/xhtml/textarea

21.2.9
   Ignore SIGHUP for non-config calls
      src/httpGate.c

21.2.8
   Start task in first 'heartbeat' call
      lib/heartbeat.l
   Touch events not needed
      lib/xhtml/tab

21.2.7
   Variable titles in menu
   Layout template line format
      lib/xhtml.l
      lib/xhtml/menu
      lib/xhtml/layout

21.2.5
   'plio' must preserve $Ptr and $End
      src/io.l
   Load @lib/too.l always in 'psh'
      lib/http.l

21.2.3
   Load @lib/sq.l in 'psh'
      lib/http.l

21.2.2
   Optional insert string in config keys
      src/httpGate.c
      doc/httpGate.html

21.2.1
   Typo ".pil" -> "./pil"
      doc/httpGate.html

21.1.28
   Typo "none" -> "nond"
      doc/tut.html

21.1.25
   Remove 'evCmd' from custom function keys
      lib/vip.l

21.1.23
   'fish' function "skip" return value
      src/apply.l
      doc/refF.html
      lib/vip.l

21.1.22
   em80, em90 and em100 styles
      lib.css

21.1.21
   Stack check in 'fish'
      src/apply.l

21.1.20
   Comment
      lib/tinymce.l

21.1.18
   Bug in 'pack' of external symbol names
      src/sym.l

21.1.17
   'pil' backport
      lib/compat.l

21.1.15
   Micro-templates
      lib/xhtml.l
      lib/xhtml/
   Bug in 'pass'
      src/apply.l
   Call 'bufString' instead of 'pathString' in 'token'
      src/io.l

21.1.14
   Bug in 'bit?'
      src/big.l

21.1.8
   Minor cosmetics
      src/subr.l
   Improved terminal reset
      src/lib.c

21.1.5
   Debian release

Dec20
   Pil21 initial version

####### 21.0 #######
pil21/doc/structures0000644000000000000000000001640514643153633011624 0ustar  # 09jul24 Software Lab. Alexander Burger

   ### Primary data types ###

   cnt   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxS010
   big   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxS100
   sym   xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx1000
   pair  xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx0000


         Bignum
         |
         V
      +-----+-----+
      | DIG |  |  |
      +-----+--+--+
               |
               V
            +-----+-----+
            | DIG |  |  |
            +-----+--+--+
                     |
                     V
                  +-----+-----+
                  | DIG | CNT |
                  +-----+-----+


      Pair
      |
      V
      +-----+-----+
      | CAR | CDR |
      +-----+-----+


            Symbol
            |
            V
      +-----+-----+                                +-----+-----+
      |  |  | VAL |                                |'cba'|'fed'|
      +--+--+-----+                                +-----+-----+
         | tail                                       ^
         |                                            |
         V                                            | name
         +-----+-----+     +-----+-----+     +-----+--+--+
         |  |  |  ---+---> | KEY |  ---+---> |  |  |  |  |
         +--+--+-----+     +-----+-----+     +--+--+-----+
            |                                   |
            V                                   V
            +-----+-----+                       +-----+-----+
            | VAL | KEY |                       | VAL | KEY |
            +-----+-----+                       +-----+-----+


      NIL:  /
            |
            V
      +-----+-----+-----+-----+
      |'LIN'|  /  |  /  |  /  |
      +-----+-----+-----+-----+


   Symbol tail
      Internal/Transient
         0010 Short name
         0100 Long name
         0000 Properties

      External
         1010 Short name
         1000 Properties

   Name final short
      Internals, Transients
         0000.xxxxxxx.xxxxxxx.xxxxxxx.xxxxxxx.xxxxxxx.xxxxxxx.xxxxxxx0010
           60      52      44      36      28      20      12       4

      Externals
         42 bit Object (4 Tera objects)
         16 bit File (64 K files)
          2 bit Status
            Loaded    01........
            Dirty     10........
            Deleted   11........

         1+2 Bytes: 1 file, 64K objects                  {177777}
         1+3 Bytes: 16 files, 1M objects               {O3777777}
         1+4 Bytes: 256 files, 16M objects           {OO77777777}
         1+5 Bytes: 256 files, 4G objects         {OO37777777777}
         1+6 Bytes: 65536 files, 4G objects     {OOOO37777777777}
         1+8 Bytes: 65536 files, 4T objects  {OOOO77777777777777}
         (2 + 10 + 8 + 12 + 8 + 20)
         xx.xxxxxxxxx.xxxxxxx.xxxxxxxxxxx.xxxxxxx.xxxxxxxxxxxxxxxxxxxE010
           obj       file    obj         file    obj
                     ^6      ^5      ^4      ^3      ^2


   ### Heap ###

      Heaps, Avail
      |
      |  +-----------------------+
      |  |                       |
      V  |                       V
      +--+--+-----+-----+-----+-----+-----+---     ---+-----+-----+-----+
      |  |  |     |           |  /  |     |    ...    |  |  |     |  |  |
      +-----+-----+-----+-----+-----+-----+---     ---+--+--+-----+--+--+
                                                         |           |
                                                         |           +-----> Heaps
                                                         |
                                                         +-----> Avail


   ### Stack ###

      Saved values:

         ^
         |
         +---- LINK
               val  <-- Link


      Bind frame:

                        ^
               Expr     |
               LINK ----+
                @
         +---> [@]
         |
         +---- LINK
               sym1
         +---> val1
         .
         .
         +---- LINK
               symN
               valN  <-- Bind


      VarArgs frame:

            [Bind frame]
         ^
         |
         +---- LINK
               arg1 <------------+
         +-------   <-- Next     |
         |                       |
         |     LINK -------------+
         | +-> arg2
         +-|->   ----------------+
           |                     |
           +-- LINK              |
               arg3 <-- Link     |
                /   <------------+


      Apply args:

         ^
         |
         +---- LINK
               fun  <---+  <-----+
               zero     |        |
         +---- cdr      |        |
         |     car  ----+  <-- E |
         |                       |
         |     LINK -------------+
         | +-> val1 <---+
         | |   zero     |
         | |   cdr1 ----|-----+
         +---> car1 ----+     |
           |                  |
           +-- LINK           |
         +---> valN  <-- Link |
         |     zero           |
         |      /             |
         +---- carN <---------+


      I/O frame:
                        ^
               put/get  |
               pid      |
               fd       |
               LINK ----+  <-- InFrames, OutFrames, ErrFrames, CtlFrames


      Catch frame:
                        ^
               [rst]    |
               [env]    |
               ...      |
               co       |
               fin      |
               tag      |
               LINK ----+  <-- Catch


      Coroutine:

               [rst]
               [env]
               ...
               [@]
               lim
               prg
               otg
               org
         +---- nxt
         |     tag   <----- Coroutines
         |
         |
         |     [rst]
         |     [env]
         |     ...
         |     [@]
         |     lim
         |     prg
         |     otg
         |     org
         |     nxt
         +---> tag


      IPC pipes:

                  +--------------------------+ Mic
                  |
                  |  +-----------------+ Tell         
                  |  |
                  |  +-----------------> Hear
          |  |
                  |  |
         Spkr <---+  |
                  |  |
                  |  |
                  |  +-----------------+ Tell
                  |  |
                  |  +-----------------> Hear         
                  |
                  +--------------------------+ Mic


   ### Database file ###

                  +-------------+-+-------------+-+----+
      Block 0:    |   Free       0|   Next       0| << |
                  +-------------+-+-------------+-+----+
                  0               BLK                  2*Blk+1


                  +-------------+-+
      Free:       |   Link       0|
                  +-------------+-+
                  0


                  +-------------+-+----
      ID-Block:   |   Link       1| Data
                  +-------------+-+----
                  0              BLK


                  +-------------+-+----
      EXT-Block:  |   Link       n| Data
                  +-------------+-+----
                  0              BLK


   ### Assumptions ###

   - 8 bit per byte
   - 64 bit per word
   - Pointer size is 64 bit
   - Stack grows downwards
   - sizeof(float) = 4 bytes
   - sizeof(double) = 8 bytes
pil21/doc/ref.html0000644000000000000000000031565714767045700011135 0ustar  





PicoLisp Reference



abu@software-lab.de



Perfection is attained

not when there is nothing left to add

but when there is nothing left to take away.

(Antoine de Saint-Exupéry)




The PicoLisp Reference



(c) Software Lab. Alexander Burger


This document describes the concepts, data types, and kernel functions of the
PicoLisp system.


This is not a Lisp tutorial. For an introduction to Lisp, a
traditional Lisp book like "Lisp" by Winston/Horn (Addison-Wesley 1981) is
recommended. Note, however, that there are significant differences between
PicoLisp and Maclisp (and even greater differences to Common Lisp).


Please take a look at the PicoLisp Tutorial for an
explanation of some aspects of PicoLisp, and scan through the list of Frequently Asked Questions (FAQ).








Introduction



PicoLisp is the result of a language design study, trying to answer the
question "What is a minimal but useful architecture for a virtual machine?".
Because opinions differ about what is meant by "minimal" and "useful", there are
many answers to that question, and people might consider other solutions more
"minimal" or more "useful". But from a practical point of view, PicoLisp has
proven to be a valuable answer to that question.


First of all, PicoLisp is a virtual machine architecture, and then a
programming language. It was designed in a "bottom up" way, and "bottom up" is
also the most natural way to understand and to use it: Form Follows
Function.


PicoLisp has been used in several commercial and research programming
projects since 1988. Its internal structures are simple enough, allowing an
experienced programmer always to fully understand what's going on under the
hood, and its language features, efficiency and extensibility make it suitable
for almost any practical programming task.


In a nutshell, emphasis was put on four design objectives. The PicoLisp
system should be





Simple


The internal data structure should be as simple as possible. Only one single
data structure is used to build all higher level constructs.




Unlimited


There are no limits imposed upon the language due to limitations of the
virtual machine architecture. That is, there is no upper bound in symbol name
length, number digit counts, stack depth, or data structure and buffer sizes,
except for the total memory size of the host machine.




Dynamic


Behavior should be as dynamic as possible ("run"-time vs. "compile"-time).
All decisions are delayed until runtime where possible. This involves matters
like memory management, dynamic symbol binding, and late method binding.




Practical


PicoLisp is not just a toy of theoretical value. It is in use since 1988 in
actual application development, research and production.










The PicoLisp Machine



An important point in the PicoLisp philosophy is the knowledge about the
architecture and data structures of the internal machinery. The high-level
constructs of the programming language directly map to that machinery, making
the whole system both understandable and predictable.


This is similar to assembly language programming, where the programmer has
complete control over the machine.





The Cell



The PicoLisp virtual machine is both simpler and more powerful than most
current (hardware) processors. At the lowest level, it is constructed from a
single data structure called "cell":


         +-----+-----+
         | CAR | CDR |
         +-----+-----+




A cell is a pair of 64-bit machine words, which traditionally are called CAR
and CDR in the Lisp terminology. These words can represent either a numeric
value (scalar) or the address of another cell (pointer). All higher level data
structures are built out of cells.


The type information of higher level data is contained in the pointers to
these data. Assuming the implementation on a byte-addressed physical machine,
and the pointer size being 8 bytes, each cell has a size of 16 bytes. Therefore,
the pointer to a cell must point to a 16-byte boundary (a number which is a
multiple of 16), and its bit-representation will look like:


      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx0000




(the 'x' means "don't care"). For the individual data types, the
pointer is adjusted to point to other parts of a cell, in effect setting some of
the lower four bits to non-zero values. These bits are then used by the
interpreter to determine the data type.


In any case, bit(0) - the least significant of these bits - is reserved as a
mark bit for garbage collection.


Initially, all cells in the memory are unused (free), and linked together to
form a "free list". To create higher level data types at runtime, cells are
taken from that free list, and returned by the garbage collector when they are
no longer needed. All memory management is done via that free list; there are no
additional buffers, string spaces or special memory areas, with two exceptions:


    

  • A certain fixed area of memory is set aside to contain the executable code
and global variables of the interpreter itself, and


  • a standard push down stack for return addresses and temporary storage. Both
are not directly accessible by the programmer.








Data Types



On the virtual machine level, PicoLisp supports


    

  • three base data types: Numbers, Symbols and Cons Pairs (Lists),

  • the three scope variations of symbols: Internal, Transient and External, and

  • the special symbol NIL.




They are all built from the single cell data structure, and all runtime data
cannot consist of any other types than these three.


The following diagram shows the complete data type hierarchy, consisting of
the three base types and the symbol variations:


                       cell
                        |
            +-----------+-----------+
            |           |           |
         Number       Symbol       Pair
                        |
                        |
   +--------+-----------+-----------+
   |        |           |           |
  NIL   Internal    Transient    External







Numbers



A number can represent a signed integral value of arbitrary size. Internally,
numeric values of up to 60 bits are stored in "short" numbers,


      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxS010



i.e. the value is directly represented in the pointer, and doesn't take any heap
space.


Numbers larger than that are "big" numbers, stored in heap cells. The CARs of
one or more cells hold the number's "digits" (64 bits each), with the least
significant digit first, while the CDRs point to the remaining digits.


         Bignum
         |
         V
      +-----+-----+
      | DIG |  |  |
      +-----+--+--+
               |
               V
            +-----+-----+
            | DIG |  |  |
            +-----+--+--+
                     |
                     V
                  +-----+-----+
                  | DIG | CNT |
                  +-----+-----+



The CDR of the final cell holds the remaining bits in a short number.


The pointer to a big number points into the middle of the CAR, with an offset
of 4 from the cell's start address, and the sign bit in bit(3):


      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxS100




Thus, a number is recognized by the interpreter when either bit(1) is
non-zero (a short number) or bit(2) is non-zero (a big number).





Symbols



A symbol is more complex than a number. Each symbol has a value, and
optionally a name and an arbitrary number of properties. The CDR of a symbol
cell is also called VAL, and the CAR points to the symbol's tail. As a minimum,
a symbol consists of a single cell, and has no name or properties:


            Symbol
            |
            V
      +-----+-----+
      | '0' | VAL |
      +-----+-----+




That is, the symbol's tail is empty (ZERO, as indicated by
'0').


The pointer to a symbol points to the CDR of the cell, with an offset of 8
bytes from the cell's start address. Therefore, the bit pattern of a symbol will
be:


      xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx1000




Thus, a symbol is recognized by the interpreter when bit(3) is non-zero. (It
should also be understood that both bit(2) and bit(1) must be zero, thus
avoiding confusion with the number types.)


A property is a key-value pair, represented by a cons pair in the symbol's
tail. This is called a "property list". The property list may be terminated by a
number (short or big) representing the symbol's name. In the following example,
a symbol with the name "abcdefghijklmno" has three properties: A
KEY/VAL pair, a cell with only a KEY, and another KEY/VAL pair.


            Symbol
            |
            V
      +-----+-----+                                +----------+---------+
      |  |  | VAL |                                |'hgfedcba'|'onmlkji'|
      +--+--+-----+                                +----------+---------+
         | tail                                       ^
         |                                            |
         V                                            | name
         +-----+-----+     +-----+-----+     +-----+--+--+
         |  |  |  ---+---> | KEY |  ---+---> |  |  |  |  |
         +--+--+-----+     +-----+-----+     +--+--+-----+
            |                                   |
            V                                   V
            +-----+-----+                       +-----+-----+
            | VAL | KEY |                       | VAL | KEY |
            +-----+-----+                       +-----+-----+




Each property in a symbol's tail is either a symbol (like the single KEY
above, then it represents the boolean value T) or a cons pair with
the property key in its CDR and the property value in its CAR. In both cases,
the key should be a symbol, because searches in the property list are performed
using pointer comparisons.


The name of a symbol is stored as a number at the end of the tail. It
contains the characters of the name in UTF-8 encoding, using between one and
seven bytes in a short number, or eight bytes in a bignum cell. The first byte
of the first character, for example, is stored in the lowest 8 bits of the
number.


All symbols have the above structure, but depending on scope and
accessibility there are actually four types of symbols: NIL, internal, transient and external symbols.





NIL



NIL is a special symbol which exists exactly once in the whole
system. It is used


    

  • as an end-of-list marker

  • to represent the empty list

  • to represent the boolean value "false"

  • to represent a string of length zero

  • to represent the absolute minimum

  • to represent end of file

  • to represent standard in/out

  • to represent the value "Not a Number"

  • as the root of all class hierarchies

  • as volatile property key

  • as "no value"




For that, NIL has a special structure:


      NIL:  /
            |
            V
      +-----+-----+-----+-----+
      |'LIN'|  /  |  /  |  /  |
      +-----+-----+-----+-----+




The reason for that structure is NIL's dual nature both as a
symbol and as a list:


    

  • As a symbol, it should give NIL for its VAL, and be without
properties


  • For the empty list, NIL should give NIL both for
its CAR and for its CDR





These requirements are fulfilled by the above structure.





Internal Symbols



Internal symbols are all those "normal" symbols, as they are used for
function definitions and variable names. They are "interned" into an index
structure, so that it is possible to find an internal symbol by searching for
its name.


There cannot be two different symbols with the same name in the same
namespace.


Initially, a new internal symbol's VAL is NIL.





Transient Symbols



Transient symbols are only interned into an index structure for a certain
time (e.g. while reading the current source file), and are released after that.
That means, a transient symbol cannot be accessed then by its name, and there
may be several transient symbols in the system having the same name.


Transient symbols are used


    

  • as text strings


  • as identifiers with a limited access scope (like, for example,
static identifiers in the C language family)


  • as anonymous, dynamically created objects (without a name)





Initially, a new transient symbol's VAL is that symbol itself.


A transient symbol without a name can be created with the box or new functions.





External Symbols



External symbols reside in a database file (or other resources, see *Ext), and are loaded into memory - and written
back to the file - dynamically as needed, and transparently to the programmer.
They are kept in memory ("cached") as long as they are accessible ("referred
to") from other parts of the program, or when they were modified but not yet
written to the database file (by commit).


The interpreter recognizes external symbols internally by an additional tag
bit in the tail structure.


There cannot be two different external symbols with the same name. External
symbols are maintained in index structures while they are loaded into memory,
and have their external location (disk file and block offset) directly coded
into their names (more details here).


Initially, a new external symbol's VAL is NIL, unless otherwise
specified at creation time.





Lists



A list is a sequence of one or more cells (cons pairs), holding numbers,
symbols, or cons pairs.


      |
      V
      +-----+-----+
      | any |  |  |
      +-----+--+--+
               |
               V
               +-----+-----+
               | any |  |  |
               +-----+--+--+
                        |
                        V
                        ...




Lists are used in PicoLisp to implement composite data structures like
arrays, trees, stacks or queues.


In contrast to lists, numbers and symbols are collectively called "Atoms".


Typically, the CDR of each cell in a list points to the following cell,
except for the last cell which points to NIL. If, however, the CDR of
the last cell points to an atom, that cell is called a "dotted pair" (because of
its I/O syntax with a dot '.' between the two values).





Memory Management



The PicoLisp interpreter has complete knowledge of all data in the system,
due to the type information associated with every pointer. Therefore, an
efficient garbage collector mechanism can easily be implemented. PicoLisp
employs a simple but fast mark-and-sweep garbage collector.


As the collection process is very fast (in the order of milliseconds per
megabyte), it was not necessary to develop more complicated, time-consuming and
error-prone garbage collection algorithms (e.g. incremental collection). A
compacting garbage collector is also not necessary, because the single cell data
type cannot cause heap fragmentation.





Programming Environment



Lisp was chosen as the programming language, because of its clear and simple
structure.


In some previous versions, a Forth-like syntax was also implemented on top of
a similar virtual machine (Lifo). Though that language was more flexible and
expressive, the traditional Lisp syntax proved easier to handle, and the virtual
machine can be kept considerably simpler.

PicoLisp inherits the major advantages of classical Lisp systems like


    

  • Dynamic data types and structures

  • Formal equivalence of code and data

  • Functional programming style

  • An interactive environment




In the following, some concepts and peculiarities of the PicoLisp language
and environment are described.





Installation



PicoLisp supports two installation strategies: Local and Global.


Normally, if you didn't build PicoLisp yourself but installed it with your
operating system's package manager, you will have a global installation. This
allows system-wide access to the executable and library/documentation files.


To get a local installation, you can directly download the PicoLisp tarball,
and follow the instructions in the INSTALL file.


A local installation will not interfere in any way with the world outside its
directory. There is no need to touch any system locations, and you don't have to
be root to install it. Many different versions - or local modifications - of
PicoLisp can co-exist on a single machine.


Note that you are still free to have local installations along with a global
installation, and invoke them explicitly as desired.


Most examples in the following apply to a global installation.





Invocation



When PicoLisp is invoked from the command line, an arbitrary number of
arguments may follow the command name.


By default, each argument is the name of a file to be executed by the
interpreter. If, however, the argument's first character is a hyphen
'-', then the rest of that argument is taken as a Lisp function
call (without the surrounding parentheses), and a hyphen by itself as an
argument stops evaluation of the rest of the command line (it may be processed
later using the argv and opt functions). This whole mechanism corresponds
to calling (load T).


A special case is if the last argument is a single '+'. This
will switch on debug mode (the *Dbg
global variable) and discard the '+'. In that case, a file
"~/.pil/rc" (if it exists) will be loaded, which can contain arbitrary statements
and definitions (e.g. to initialize the readline(3) history).


As a convention, PicoLisp source files have the extension ".l".


Note that the PicoLisp executable itself does not expect or accept any
command line flags or options (except the '+', see above). They are
reserved for application programs.


The simplest and shortest invocation of PicoLisp does nothing, and exits
immediately by calling bye:


$ picolisp -bye
$




In interactive mode, the PicoLisp interpreter (see load) will also exit when Ctrl-D
is entered:


$ picolisp
:           # Typed Ctrl-D
$




To start up the standard PicoLisp environment, several files should be
loaded. The most commonly used things are in "lib.l" and in a bunch of other
files, which are in turn loaded by "ext.l". Thus, a typical call would be:


$ picolisp lib.l ext.l




The recommended way, however, is to call the "pil" shell script, which
includes "lib.l" and "ext.l". Given that your current project is loaded by some
file "myProject.l" and your startup function is main, your
invocation would look like:


$ pil myProject.l -main




For interactive development it is recommended to enable debugging mode, to
get readline(3) line history, single-stepping, tracing and other
debugging utilities.


$ pil myProject.l -main +




This is - in a local installation - equivalent to


$ ./pil myProject.l -main +




In any case, the directory part of the first file name supplied (normally,
the path to "lib.l" as called by 'pil') is remembered internally as the
PicoLisp Home Directory. This path is later automatically substituted for
any leading "@" character in file name arguments to I/O functions
(see path).





Input/Output



In Lisp, each internal data structure has a well-defined external
representation in human-readable format. All kinds of data can be written to a
file, and restored later to their original form by reading that file.


For all input functions besides wr,
rd and echo the input is assumed to be valid UTF-8,
consisting only of characters allowed in picolisp symbol names.


In normal operation, the PicoLisp interpreter continually executes an
infinite "read-eval-print loop". It reads one expression at a time, evaluates
it, and prints the result to the console. Any input into the system, like data
structures and function definitions, is done in a consistent way no matter
whether it is entered at the console or read from a file.


Comments can be embedded in the input stream with the hash #
character. Everything up to the end of that line will be ignored by the reader.


: (* 1 2 3)  # This is a comment
-> 6




A comment spanning several lines (a block comment) may be enclosed between
#{ and }#. Block comments may be nested.



Here is the I/O syntax for the individual PicoLisp data types (numbers,
symbols and lists) and for read-macros:





Numbers



A number consists of an arbitrary number of digits ('0' through
'9'), optionally preceded by a sign character ('+' or
'-'). Legal number input is:


: 7
-> 7
: -12345678901245678901234567890
-> -12345678901245678901234567890




Fixpoint numbers can be input by embedding a decimal point '.',
and setting the global variable *Scl
appropriately:


: *Scl
-> 0

: 123.45
-> 123
: 456.78
-> 457

: (setq *Scl 3)
-> 3
: 123.45
-> 123450
: 456.78
-> 456780




Thus, fixpoint input simply scales the number to an integer value
corresponding to the number of digits in *Scl.


Formatted output of scaled fixpoint values can be done with the format and round functions:


: (format 1234567890 2)
-> "12345678.90"
: (format 1234567890 2 "." ",")
-> "12,345,678.90"







Symbols



The reader is able to recognize the individual symbol types from their
syntactic form. A symbol name should - of course - not look like a legal number
(see above).


In general, symbol names are case-sensitive. car is not the same
as CAR.





NIL



Besides the standard form, NIL is also recognized as
(), [] or "".


: NIL
-> NIL
: ()
-> NIL
: ""
-> NIL




Output will always appear as NIL.





Internal Symbols



Internal symbol names can consist of any printable (non-whitespace)
character, except for the following meta characters:


   "  '  (  )  ,  [  ]  `  { } ~




It is possible, though, to include these special characters into symbol names
by escaping them with a backslash '\'.


The dot '.' has a dual nature. It is a meta character when
standing alone, denoting a dotted pair, but can otherwise
be used in symbol names.


As a rule, anything not recognized by the reader as another data type will be
returned as an internal symbol.





Transient Symbols



A transient symbol is anything surrounded by double quotes '"'.
With that, it looks like - and can be used as - a string constant in other
languages. However, it is a real symbol, and may be assigned a value or a
function definition, and properties.


Initially, a transient symbol's value is that symbol itself, so that it does
not need to be quoted for evaluation:


: "This is a string"
-> "This is a string"




However, care must be taken when assigning a value to a transient symbol.
This may cause unexpected behavior:


: (setq "This is a string" 12345)
-> 12345
: "This is a string"
-> 12345




The name of a transient symbol can contain any character except the
null-byte. Control characters can be written with a preceding hat
'^' character. A hat or a double quote character can be escaped
with a backslash '\', and a backslash itself has to be escaped with
another backslash.


: "We^Ird\\Str\"ing"
-> "We^Ird\\Str\"ing"
: (chop @)
-> ("W" "e" "^I" "r" "d" "\\" "S" "t" "r" "\"" "i" "n" "g")




The combination of a backslash followed by 'b', 'e', 'n', 'r' or 't' is
replaced with backspace ("^H"), escape ("^["), newline ("^J"), return ("^M") or
TAB ("^I"), respectively.


: "abc\tdef\r"
-> "abc^Idef^M"




A decimal number between two backslashes can be used to specify any unicode
character directly.


: "äöü\8364\xyz"
-> "äöü€xyz"




A backslash in a transient symbol name at the end of a line discards the
newline, and continues the name in the next line. In that case, all leading
spaces and tabs in that line are discarded, to allow proper source code
indentation.


: "abc\
   def"
-> "abcdef"
: "x \
   y \
   z"
-> "x y z"




The index for transient symbols is local when loading a source file. With that mechanism, it
is possible to create symbols with a local access scope, not accessible from
other parts of the program.


A special case of transient symbols are anonymous symbols. These are
symbols without name (see box, box? or new). They print as a dollar sign
($) followed by a decimal digit string (actually their machine
address).





External Symbols



External symbol names are surrounded by braces ('{' and
'}'). The characters of the symbol's name itself identify the
physical location of the external object. This is the number of the database
file minus 1 in hax notation (i.e.
hexadecimal/alpha notation, where '@' is zero, 'A' is
1 and 'O' is 15 (from "alpha" to "omega")), immediately followed
(without a hyphen) the starting block in octal ('0' through
'7').


The database file is omitted for the first (default) file.





Lists



Lists are surrounded by parentheses ('(' and ')').


(A) is a list consisting of a single cell, with the symbol
A in its CAR, and NIL in its CDR.


(A B C) is a list consisting of three cells, with the symbols
A, B and C respectively in their CAR, and
NIL in the last cell's CDR.


(A . B) is a "dotted pair", a list
consisting of a single cell, with the symbol A in its CAR, and
B in its CDR.


PicoLisp has built-in support for reading and printing simple circular lists.
If the dot in a dotted-pair notation is immediately followed by a closing
parenthesis, it indicates that the CDR of the last cell points back to the
beginning of that list.


: (let L '(a b c) (conc L L))
-> (a b c .)
: (cdr '(a b c .))
-> (b c a .)
: (cddddr '(a b c .))
-> (b c a .)




A similar result can be achieved with the function circ. Such lists must be used with care,
because many functions won't terminate or will crash when given such a list.





Read-Macros



Read-macros in PicoLisp are special forms that are recognized by the reader,
and modify its behavior. Note that they take effect immediately while reading an expression, and are not seen by the
eval in the main loop.


The most prominent read-macro in Lisp is the single quote character
"'", which expands to a call of the quote function. Note that the single quote
character is also printed instead of the full function name.


: '(a b c)
-> (a b c)
: '(quote . a)
-> 'a
: (cons 'quote 'a)   # (quote . a)
-> 'a
: (list 'quote 'a)   # (quote a)
-> '(a)




A comma (,) will cause the reader to collect the following data
item into an idx tree in the global
variable *Uni, and to return a
previously inserted equal item if present. This makes it possible to create a
unique list of references to data which do normally not follow the rules of
pointer equality. If the value of *Uni is T, the
comma read macro mechanism is disabled.


A single backquote character "`" will cause the reader to
evaluate the following expression, and return the result.


: '(a `(+ 1 2 3) z)
-> (a 6 z)




A tilde character ~ inside a list will cause the reader to
evaluate the following expression, and (destructively) splice the result into
the list.


: '(a b c ~(list 'd 'e 'f) g h i)
-> (a b c d e f g h i)




When a tilde character is used to separate two symbol names (without
surrounding whitespace), the first is taken as a namespace to look up the
second.


: 'libA~foo  # Look up 'foo' in namespace 'libA'
-> libA~foo  # "foo" is not interned in the current namespace




Reading libA~foo is equivalent to switching the current
namespace search order to libA only (with symbols), reading the symbol
foo, and then switching back to the original search order.


%~foo temporarily switches the search order to the
CDR of the current namespace list.


Brackets ('[' and ']') can be used as super
parentheses. A closing bracket will match the innermost opening bracket, or all
currently open parentheses.


: '(a (b (c (d]
-> (a (b (c (d))))
: '(a (b [c (d]))
-> (a (b (c (d))))




Finally, reading the sequence '{}' will result in a new
anonymous symbol with value NIL, equivalent to a call to box without arguments.


: '({} {} {})
-> ($177066763035351 $177066763035353 $177066763035355)
: (mapcar val @)
-> (NIL NIL NIL)







Namespaces



When the reader encounters an atom that is not a number, it looks for
it in the current namespace search order. If a symbol with that name is
found, it is used; otherwise, a new symbol is created and interned in
the current namespace.


In general, namespaces in PicoLisp have nothing to do with the values
or definitions of symbols, but only with their scope (visibility).
Several symbols with the same name may exist in different namespaces,
and a single symbol may exist in one or many (or none at all)
namespaces.


At interpreter startup, only the internal pico namespace exists, along with the
three special built-in namespaces for transient, external,
and private symbols.


For internal symbols, it may not always be clear which namespace(s)
they belong to. Depending on the search order, the same name in a given
code segment might refer to different physical symbols. To avoid
ambiguity, it is recommended to follow these namespace policies:





Invariant namespace order


Across different parts of a program and all loaded libraries the
search order may be changed as needed, but the position of each
namespace relative to other namespaces should stay the same. That is,
namespace A should not overshadow namespace B in one context and be
overshadowed by B in another context.




Scope declaration before first usage


Calls to symbols,
private, local or import should precede any appearance
(not just definition!) of all involved symbols, because merely reading a
symbol may already intern it in the wrong namespace. 









Evaluation



PicoLisp tries to evaluate any expression encountered in the read-eval-print
loop. Basically, it does so by applying the following three rules:


    

  • A number evaluates to itself.


  • A symbol evaluates to its value (VAL).


  • A list is evaluated as a function call, with the CAR as the function and the
CDR the arguments to that function. These arguments are in turn evaluated
according to these three rules.





: 1234
-> 1234        # Number evaluates to itself
: *Pid
-> 22972       # Symbol evaluates to its VAL
: (+ 1 2 3)
-> 6           # List is evaluated as a function call




For the third rule, however, things get a bit more involved. First - as a
special case - if the CAR of the list is a number, the whole list is returned as
it is:


: (1 2 3 4 5 6)
-> (1 2 3 4 5 6)




This is not really a function call, but just a convenience to avoid having to
quote simple data lists. The interpreter needs to check it anyway, and returning
the list (instead of throwing an error) is a lot faster than calling the
quote function.


Otherwise, if the CAR is a symbol or a list, PicoLisp tries to obtain an
executable function from that, by either using the symbol's value, or by
evaluating the list.


What is an executable function? Or, said in another way, what can be applied
to a list of arguments, to result in a function call? A legal function in
PicoLisp is




either


a number. When a number is used as a function, it is simply taken as
a pointer to executable code that will be called with the list of (unevaluated)
arguments as its single parameter. It is up to that code to evaluate the
arguments, or not. Some functions do not evaluate their arguments (e.g.
quote) or evaluate only some of their arguments (e.g.
setq).




or


a lambda expression. A lambda expression is a list, whose CAR is
either a symbol or a list of symbols, and whose CDR is a list of expressions.
Note: In contrast to other Lisp implementations, the symbol LAMBDA itself does
not exist in PicoLisp but is implied from context.







A few examples should help to understand the practical consequences of these
rules. In the most common case, the CAR will be a symbol defined as a function,
like the * in:


: (* 1 2 3)    # Call the function '*'
-> 6




Inspecting the VAL of * gives


: *            # Get the VAL of the symbol '*'
-> 67318096




The VAL of * is a number. In fact, it is the numeric
representation of a function pointer, i.e. a pointer to executable code. This
is the case for all built-in functions of PicoLisp.


Other functions in turn are written as Lisp expressions:


: (de foo (X Y)            # Define the function 'foo'
   (* (+ X Y) (+ X Y)) )
-> foo
: (foo 2 3)                # Call the function 'foo'
-> 25
: foo                      # Get the VAL of the symbol 'foo'
-> ((X Y) (* (+ X Y) (+ X Y)))




The VAL of foo is a list. It is the list that was assigned to
foo with the de function. It would be perfectly legal
to use setq instead of de:


: (setq foo '((X Y) (* (+ X Y) (+ X Y))))
-> ((X Y) (* (+ X Y) (+ X Y)))
: (foo 2 3)
-> 25




If the VAL of foo were another symbol, that symbol's VAL would
be used instead to search for an executable function.


As we said above, if the CAR of the evaluated expression is not a symbol but
a list, that list is evaluated to obtain an executable function.


: ((intern (pack "c" "a" "r")) (1 2 3))
-> 1




Here, the intern function returns the symbol car
whose VAL is used then. It is also legal, though quite dangerous, to use the code-pointer directly:


: *
-> 67318096
: ((* 2 33659048) 1 2 3)
-> 6
: ((quote . 67318096) 1 2 3)
-> 6
: ((quote . 1234) (1 2 3))
Segmentation fault




When an executable function is defined in Lisp itself, we call it a lambda expression. A lambda expression always has a
list of executable expressions as its CDR. The CAR, however, must be a either a
list of symbols, or a single symbol, and it controls the evaluation of the
arguments to the executable function according to the following rules:





When the CAR is a list of symbols


For each of these symbols an argument is evaluated, then the symbols are
bound simultaneously to the results. The body of the lambda expression is
executed, then the VAL's of the symbols are restored to their original values.
This is the most common case, a fixed number of arguments is passed to the
function. 
As a special case, a single-level list of symbols may be passed
instead of a single parameter here, resulting in a restricted form of
destructuring bind.




Otherwise, when the CAR is the symbol @


All arguments are evaluated and the results kept internally in a list. The
body of the lambda expression is executed, and the evaluated arguments can be
accessed sequentially with the args,
next, arg and rest functions. This allows to define functions
with a variable number of evaluated arguments.




Otherwise, when the CAR is a single symbol


The symbol is bound to the whole unevaluated argument list. The body of the
lambda expression is executed, then the symbol is restored to its original
value. This allows to define functions with unevaluated arguments. Any kind of
interpretation and evaluation of the argument list can be done inside the
expression body.







In all cases, the return value is the result of the last expression in the
body.


: (de foo (X Y Z)                   # CAR is a list of symbols
   (list X Y Z) )                   # Return a list of all arguments
-> foo
: (foo (+ 1 2) (+ 3 4) (+ 5 6))
-> (3 7 11)                         # all arguments are evaluated




: (de foo @                         # CAR is the symbol '@'
   (list (next) (next) (next)) )    # Return the first three arguments
-> foo
: (foo (+ 1 2) (+ 3 4) (+ 5 6))
-> (3 7 11)                         # all arguments are evaluated




: (de foo X                         # CAR is a single symbol
   X )                              # Return the argument
-> foo
: (foo (+ 1 2) (+ 3 4) (+ 5 6))
-> ((+ 1 2) (+ 3 4) (+ 5 6))        # the whole unevaluated list is returned




Note that these forms can also be combined. For example, to evaluate only the
first two arguments, bind the results to X and Y, and
bind all other arguments (unevaluated) to Z:


: (de foo (X Y . Z)                 # CAR is a list with a dotted-pair tail
   (list X Y Z) )                   # Return a list of all arguments
-> foo
: (foo (+ 1 2) (+ 3 4) (+ 5 6))
-> (3 7 ((+ 5 6)))                  # Only the first two arguments are evaluated




Or, a single argument followed by a variable number of arguments:


: (de foo (X . @)                   # CAR is a dotted-pair with '@'
   (println X)                      # print the first evaluated argument
   (while (args)                    # while there are more arguments
      (println (next)) ) )          # print the next one
-> foo
: (foo (+ 1 2) (+ 3 4) (+ 5 6))
3                                   # X
7                                   # next argument
11                                  # and the last argument
-> 11




In general, if more than the expected number of arguments is supplied to a
function, these extra arguments will be ignored. Missing arguments default to
NIL.





Shared Libraries



Analogous to built-in functions (which are written in PilSrc (based on LLVM))
in the interpreter kernel), PicoLisp functions may also be defined in shared
object files (called "DLLs" on some systems). The coding style, register usage,
argument passing etc. follow the same rules as for normal built-in functions.


Note that this has nothing to do with external (e.g. third-party) library
functions called with native.


When the interpreter encounters a symbol supposed to be called as a function,
without a function definition, but with a name of the form
"lib:sym", then - instead of throwing an "undefined"-error - it
tries to locate a shared object file with the name lib.so and a
function sym, and stores a pointer to this code in the symbol's
value. From that point, this symbol lib:sym keeps that function
definition, and is undistinguishable from built-in functions. Future calls to
this function do not require another library search.


A consequence of this lookup mechanism, however, is the fact that such
symbols cannot be used directly in a function-passing context (i.e.
"apply" them) like


(apply + (1 2 3))
(mapcar inc (1 2 3))




These calls work because + and inc already have a
(function) value at this point. Applying a shared library function like


(apply ext:Base64 (1 2 3))




works only if ext:Base64 was either called before (and
thus automatically received a function definition), or was fetched explicitly
with (getd 'ext:Base64).


Therefore, it is recommended to always apply such functions by passing the
symbol itself and not just the value:


(apply 'ext:Base64 (1 2 3))







Coroutines



Coroutines are independent execution contexts. They may have multiple entry
and exit points, and preserve their environment (stack, symbol bindings,
namespaces, catch/throw and I/O frames) between invocations.


A coroutine is identified by a tag. This tag can be passed to other
functions, and (re)invoked as needed. In this regard coroutines are similar to
"continuations" in other languages.


Tags may be of any type (pointer equality is used for comparison), but
symbolic tags are more efficient for large numbers of coroutines. They cache a
pointer to the internal data structure in a property with key zero (which is
inaccessible with the put and get functions).


A coroutine is created by calling co.
Its prg body will be executed, and unless yield is called at some point, the coroutine
will "fall off" at the end and disappear.


The initial value of This is bound
and preserved in the coroutine environment.


When yield is called, control is
either transferred back to the caller, or to some other - explicitly specified,
and already running - coroutine.


A coroutine is stopped and disposed when


    

  • execution falls off the end


  • some other (co)routine calls co with
that tag but without a prg body


  • a throw into another (co)routine
environment is executed


  • an error occurred, and error handling was entered





Reentrant co calls are not allowed: A
coroutine cannot call or stop itself directly or indirectly.


Before using many coroutines, make sure you have sufficient stack space, e.g.
by calling


$ ulimit -s unlimited




Without that, the stack limit in Linux is typically 8 MiB.





Interrupt



During the evaluation of an expression, the PicoLisp interpreter can be
interrupted at any time by hitting Ctrl-C. It will then enter the
breakpoint routine, as if ! were called.


Hitting ENTER at that point will continue evaluation, while
Ctrl-D or (quit) will
abort evaluation and return the interpreter to the top level. See also debug, e, ^ and
*Dbg


Other interrupts may be handled by alarm, sigio, *Hup, *Winch, *Sig[12], *TStp[12] and *Term.





Error Handling



When a runtime error occurs, execution is stopped and an error handler is
entered.


The error handler resets the I/O channels to the console, and displays the
location (if possible) and the reason of the error, followed by an error
message. That message is also stored in the global *Msg, and the location of the error in ^. If the VAL of the global *Err is non-NIL it is executed as
a prg body. If the standard input is from a terminal, a
read-eval-print loop (with a question mark "?" as prompt) is
entered (the loop is exited when an empty line is input). Then all pending
finally expressions are executed,
all variable bindings restored, and all files closed. If the standard input is
not from a terminal, the interpreter terminates. Otherwise it is reset to its
top-level state.


: (de foo (A B) (badFoo A B))       # 'foo' calls an undefined symbol
-> foo
: (foo 3 4)                         # Call 'foo'
!? (badFoo A B)                     # Error handler entered
badFoo -- Undefined
? A                                 # Inspect 'A'
-> 3
? B                                 # Inspect 'B'
-> 4
?                                   # Empty line: Exit
:




Errors can be caught with catch,
if a list of substrings of possible error messages is supplied for the first
argument. In such a case, the matching substring (or the whole error message if
the substring is NIL) is returned.


An arbitrary error can be thrown explicitly with quit.





@ Result



In certain situations, the result of the last evaluation is stored in the VAL
of the symbol @. This can be very convenient, because it often
makes the assignment to temporary variables unnecessary.


This happens in two - only superficially similar - situations:





load


In read-eval loops, the last three results which were printed at the console
are available in @@@, @@ and @, in that
order (i.e the latest result is in @).


: (+ 1 2 3)
-> 6
: (/ 128 4)
-> 32
: (- @ @@)        # Subtract the last two results
-> 26






Flow functions


Flow functions store the non-nil results of controlling expressions, and
logic functions their non-nil results, in @.


: (while (read) (println 'got: @))
abc            # User input
got: abc       # print result
123            # User input
got: 123       # print result
NIL
-> 123

: (setq L (1 2 3 4 5 1 2 3 4 5))
-> (1 2 3 4 5 1 2 3 4 5)
: (and (member 3 L) (member 3 (cdr @)) (set @ 999))
-> 999
: L
-> (1 2 3 4 5 1 2 999 4 5)




Functions with controlling expressions are
   case,
   casq,
   prog1,
   prog2,
and the bodies of *Run tasks.


Functions with conditional expressions are
   and,
   cond,
   do,
   for,
   if,
   ifn,
   if2,
   if@@,
   loop,
   nand,
   nond,
   nor,
   not,
   or,
   state,
   unless,
   until,
   when and
   while.







@ is generally local to functions and methods, its value is
automatically saved upon function entry and restored at exit.





Comparing



In PicoLisp, it is legal to compare data items of arbitrary type. Any two
items are either





Identical


They are the same memory object (pointer equality). For example, two
internal symbols with the same name are identical. And short numbers (up to 60
bits plus sign) are also equivalent to "pointer"-equal.




Equal


They are equal in every respect (structure equality), but need not to be
identical. Examples are numbers with the same value, transient symbols with the
same name or lists with equal elements.




Or they have a well-defined ordinal relationship


Numbers are comparable by their numeric value, strings by their name, and
lists recursively by their elements (if the CAR's are equal, their CDR's are
compared). For differing types, the following rule applies: Numbers are less
than symbols, and symbols are less than lists. As special cases,
NIL is always less than anything else, and T is always
greater than anything else.







To demonstrate this, sort a list of
mixed data types:


: (sort '("abc" T (d e f) NIL 123 DEF))
-> (NIL 123 DEF "abc" (d e f) T)




See also max, min, rank, <, =, >
etc.





OO Concepts



PicoLisp comes with built-in object oriented extensions. There seems to be a
common agreement upon three criteria for object orientation:




Encapsulation


Code and data are encapsulated into objects, giving them both a
behavior and a state. Objects communicate by sending and receiving
messages.




Inheritance


Objects are organized into classes. The behavior of an object is
inherited from its class(es) and superclass(es).




Polymorphism


Objects of different classes may behave differently in response to the same
message. For that, classes may define different methods for each message.







PicoLisp implements both objects and classes with symbols. Object-local data
are stored in the symbol's property list, while the code (methods) and links to
the superclasses are stored in the symbol's VAL (encapsulation).


In fact, there is no formal difference between objects and classes (except
that objects usually are anonymous symbols containing mostly local data, while
classes are named internal symbols with an emphasis on method definitions). At
any time, a class may be assigned its own local data (class variables), and any
object can receive individual method definitions in addition to (or overriding)
those inherited from its (super)classes.


PicoLisp supports multiple inheritance. The VAL of each object is a (possibly
empty) association list of message symbols and method bodies, concatenated with
a list of classes. When a message is sent to an object, it is searched in the
object's own method list, and then (with a left-to-right depth-first search) in
the tree of its classes and superclasses. The first method found is executed and
the search stops. The search may be explicitly continued with the extra and super functions.


Thus, which method is actually executed when a message is sent to an object
depends on the classes that the object is currently linked to (polymorphism). As
the method search is fully dynamic (late binding), an object's type (i.e. its
classes and method definitions) can be changed even at runtime!


While a method body is being executed, the global variable This is set to the current object, allowing
the use of the short-cut property functions =:, :
and ::.





Database



On the lowest level, a PicoLisp database is just a collection of external symbols. They reside in a database file, and are
dynamically swapped in and out of memory. Only one database can be open at a
time (pool).


In addition, further external symbols can be specified to originate from
arbitrary sources via the *Ext
mechanism.


Whenever an external symbol's value or property list is accessed, it will be
automatically fetched into memory, and can then be used like any other symbol.
Modifications will be written to disk only when commit is called. Alternatively, all
modifications since the last call to commit can be discarded by
calling rollback.


Note that a property with the key NIL is a volatile
property, which is held only in memory and not written to disk on
commit, and discarded by rollback. Volatile properties
can be used by applications for any kind of temporary data.





Transactions



In the typical case there will be multiple processes operating on the same
database. These processes should be all children of the same parent process,
which takes care of synchronizing read/write operations and heap contents. Then
a database transaction is normally initiated by calling (dbSync), and closed by calling (commit 'upd). Short transactions, involving
only a single DB operation, are available in functions like new! and methods like put!> (by convention with an
exclamation mark), which implicitly call (dbSync) and (commit
'upd) themselves.


A transaction proceeds through five phases:


    

  1. dbSync waits to get a lock on the root object *DB. Other processes continue reading and
writing meanwhile.


  2. dbSync calls sync to synchronize with changes from other
processes. We hold the shared lock, but other processes may continue reading.


  3. We make modifications to the internal state of external symbols with
put>, set>, lose> etc. We -
and also other processes - can still read the DB.


  4. We call (commit 'upd).
commit obtains an exclusive lock (no more read operations by other
processes), writes an optional transaction log, and then all modified symbols.
As upd is passed to 'commit', other
processes synchronize with these changes.


  5. Finally, all locks are released by 'commit'.








Entities / Relations



The symbols in a database can be used to store arbitrary information
structures. In typical use, some symbols represent nodes of search trees, by
holding keys, values, and links to subtrees in their VAL's. Such a search tree
in the database is called index.


For the most part, other symbols in the database are objects derived from the
+Entity class.


Entities depend on objects of the +relation class hierarchy.
Relation-objects manage the property values of entities, they define the
application database model and are responsible for the integrity of mutual
object references and index trees.


Relations are stored as properties in the entity classes, their methods are
invoked as daemons whenever property values in an entity are changed. When
defining an +Entity class, relations are defined - in addition to
the method definitions of a normal class - with the rel function. Predefined relation classes
include


    

  • Scalar relations like
   
    
   
    +Symbol
    
   
    Symbolic data
    
   
    +String
    
   
    Strings (just a general case of symbols)
    
   
    +Number
    
   
    Integers and fixpoint numbers
    
   
    +Date
    
   
    Calendar date values, represented by a number
    
   
    +Time
    
   
    Time-of-the-day values, represented by a number
    
   
    +Blob
    
   
    "Binary large objects" stored in separate files
    
   
    +Bool
    
   
    T or NIL
    
   
    

  • Object-to-object relations
   
    
   
    +Link
    
   
    A reference to some other entity
    
   
    +Hook
    
   
    A reference to an entity holding object-local index trees
    
   
    +Joint
    
   
    A bidirectional reference to some other entity
    
   
    

  • Container prefix classes like
   
    
   
    +List
    
   
    A list of any of the other primitive or object relation types
    
   
    +Bag
    
   
    A list containing a mixture of any of the other types
    
   
    

  • Index prefix classes
   
    
   
    +Ref
    
   
    An index with other primitives or entities as key
    
   
    +Key
    
   
    A unique index with other primitives or entities as key
    
   
    +Idx
    
   
    A full-text index, typically for strings
    
   
    +Fold
    
   
    A folded text index
    
   
    +IdxFold
    
   
    Folded substring index
    
   
    +Sn
    
   
    Tolerant index, using a modified Soundex-Algorithm
    
   
    

  • And a catch-all class
   
    
   
    +Any
    
   
    Not specified, may be any of the above relations
    
   
    







Pilog (PicoLisp Prolog)



A declarative language is built on top of PicoLisp, that has the semantics of
Prolog, but uses the syntax of Lisp.


For an explanation of Prolog's declarative programming style, an introduction
like "Programming in Prolog" by Clocksin/Mellish (Springer-Verlag 1981) is
recommended.


Facts and rules can be declared with the be function. For example, a Prolog fact
'likes(john,mary).' is written in Pilog as:


(be likes (John Mary))




and a rule 'likes(john,X) :- likes(X,wine), likes(X,food).' is
in Pilog:


(be likes (John @X) (likes @X wine) (likes @X food))




As in Prolog, the difference between facts and rules is that the latter ones
have conditions, and usually contain variables.


A variable in Pilog is any symbol starting with an at-mark character
("@"), i.e. a pat?
symbol. The symbol @ itself can be used as an anonymous variable:
It will match during unification, but will not be bound to the matched values.


The cut operator of Prolog (usually written as an exclamation mark
(!)) is the symbol T in Pilog.


An interactive query can be done with the ? function:


(? (likes John @X))




This will print all solutions, waiting for user input after each line. If
Ctrl-D or a non-empty line is typed, it will terminate.


Pilog can be called from Lisp and vice versa:


    


  • The interface from Lisp is via the functions goal (prepare a query from Lisp data) and
prove (return an association list of
successful bindings), and the application level functions pilog and solve.


  • When the CAR of a Pilog clause is the symbol ^, then the CDDR
is executed as a Lisp prg body and the result unified with the
CADR.


  • Within such a Lisp expression in a Pilog clause, the current bindings of
Pilog variables are directly accessible in the corresponding Lisp symbol
bindings or can be accessed with the -> function (the latter is only necessary
to access non-top-level Pilog environments).








Naming Conventions



It was necessary to introduce - and adhere to - a set of conventions for
PicoLisp symbol names. Because all (internal) symbols have a global scope, and
each symbol can only have either a value or function definition, it would
otherwise be very easy to introduce name conflicts. Besides this, source code
readability is increased when the scope of a symbol is indicated by its name.


These conventions are not hard-coded into the language, but should be so into
the head of the programmer. Here are the most commonly used ones:


    

  • Global variables start with an asterisk "*"

  • Global constants may be written all-uppercase

  • Functions and other global symbols start with a lower case letter

  • Locally bound symbols start with an upper case letter

  • Local functions start with an underscore "_"

  • Classes start with a plus-sign "+", where the first letter
   
      
   
    • is in lower case for abstract classes
   
    • and in upper case for normal classes
   
    

  • Methods end with a right arrow ">"

  • Class variables may be indicated by an upper case letter




For example, a local variable could easily overshadow a function definition:


: (de max-speed (car)
   (.. (get car 'speeds) ..) )
-> max-speed




Inside the body of max-speed (and all other functions called
during that execution) the kernel function car is redefined to some
other value, and will surely crash if something like (car Lst) is
executed. Instead, it is safe to write:


: (de max-speed (Car)            # 'Car' with upper case first letter
   (.. (get Car 'speeds) ..) )
-> max-speed




Note that there are also some strict naming rules (as opposed to the
voluntary conventions) that are required by the corresponding kernel
functionalities, like:


    

  • Transient symbols are enclosed in double quotes (see Transient Symbols)

  • External symbols are enclosed in braces (see External
Symbols)

  • Pattern-Wildcards start with an at-mark "@" (see match and fill)

  • Symbols referring to a shared library contain a colon "lib:sym"




With that, the last of the above conventions (local functions start with an
underscore) is not really necessary, because true local scope can be enforced
with transient symbols.


The symbols T and NIL are global constants, so care
should be taken not to bind them to some other value by mistake:


(de foo (R S T)
   ...




However, lint will issue a warning
in such a case.





Breaking Traditions



PicoLisp does not try very hard to be compatible with traditional Lisp
systems. If you are used to some other Lisp dialects, you may notice the
following differences:





Case Sensitivity


PicoLisp distinguishes between upper case and lower case characters in
symbol names. Thus, CAR and car are different symbols,
which was not the case in traditional Lisp systems.




QUOTE


In traditional Lisp, the QUOTE function returns its
first unevaluated argument. In PicoLisp, on the other hand,
quote returns all (unevaluated) argument(s).




LAMBDA


The LAMBDA function, in some way at the heart of traditional
Lisp, is completely missing (and quote is used instead).




PROG


The PROG function of traditional Lisp, with its GOTO and ENTER
functionality, is also missing. PicoLisp's prog function is just a
simple sequencer (as PROGN in some Lisps).




Function/Value


In PicoLisp, a symbol cannot have a value and a function definition
at the same time. Though this is a disadvantage at first sight, it allows a
completely uniform handling of functional data.










Function Reference



This section provides a reference manual for the kernel functions, and some
extensions. See the thematically grouped list of indexes below.


Though PicoLisp is a dynamically typed language (resolved at runtime, as
opposed to statically (compile-time) typed languages), many functions can only
accept and/or return a certain set of data types. For each function, the
expected argument types and return values are described with the following
abbreviations:


The primary data types:


    

  • num - Number

  • sym - Symbol

  • lst - List




Other (derived) data types


    

  • any - Anything: Any data type

  • flg - Flag: Boolean value (NIL or non-NIL)

  • cnt - A count or a small number

  • dat - Date: Days, starting first of March of the year 0 A.D.

  • tim - Time: Seconds since midnight

  • obj - Object/Class: A symbol with methods and/or classes

  • var - Variable: Either a symbol or a cons pair

  • exe - Executable: An executable expression (eval)

  • prg - Prog-Body: A list of executable expressions (run)

  • fun - Function: Either a number (code-pointer), a symbol (message) or a list (lambda)

  • msg - Message: A symbol sent to an object (to invoke a method)

  • cls - Class: A symbol defined as an object's class

  • typ - Type: A list of cls symbols

  • pat - Pattern: A symbol whose name starts with an at-mark "@"

  • pid - Process ID: A number, the ID of a Unix process

  • fd - File descriptor: The number of an open file

  • tree - Database index tree specification

  • hook - Database hook object




Arguments evaluated by the function in the "normal" way are quoted (prefixed
with the single quote character "'"). Other arguments are either
not evaluated, or may be evaluated depending on the context.


For example, the function setq
evaluates every second argument (giving any kind of value), while it does
not evaluate the others (vars, here typically symbols). This
could be specified as:


   (setq var1 'any1 var2 'any2 ..) -> any




A dotted pair notation in the argument list like (... 'any .
prg) indicates an unevaluated list of further arguments.


Arguments in brackets '[' and ']' are optional.



A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T
U
V
W
X
Y
Z
Other





Symbol Functions



   new
   sym
   str
   char
   name
   nsp
   sp?
   pat?
   fun?
   all
   symbols
   -symbols
   private
   local
   export
   import
   all*
   intern
   extern
   qsym
   loc
   box?
   str?
   ext?
   touch
   zap
   length
   size
   format
   chop
   pack
   glue
   pad
   align
   center
   text
   wrap
   pre?
   sub?
   low?
   upp?
   lowc
   uppc
   fold
   val
   getd
   set
   setq
   def
   de
   dm
   recur
   undef
   redef
   daemon
   patch
   swap
   xchg
   on
   off
   onOff
   zero
   one
   default
   expr
   subr
   let
   let?
   use
   buf
   accu
   push
   push1
   push1q
   pop
   ++
   shift
   cut
   del
   queue
   fifo
   rid
   enum
   enum?
   idx
   lup
   cache
   locale
   dirname
   basename





Property Access



   put
   get
   prop
   ;
   =:
   :
   ::
   putl
   getl
   wipe
   meta





Predicates



   atom
   pair
   circ?
   lst?
   num?
   sym?
   flg?
   sp?
   pat?
   fun?
   box?
   str?
   ext?
   bool
   not
   ==
   n==
   =
   <>
   =0
   =1
   =T
   n0
   nT
   <
   <=
   >
   >=
   match
   full





Arithmetics



   +
   -
   *
   /
   %
   */
   **
   inc
   dec
   >>
   rev
   lt0
   le0
   ge0
   gt0
   abs
   bit?
   &
   |
   x|
   sqrt
   seed
   hash
   rand
   max
   min
   length
   size
   accu
   format
   pad
   money
   round
   bin
   oct
   hex
   hax





List Processing



   car
   cdr
   caar
   cadr
   cdar
   cddr
   caaar
   caadr
   cadar
   caddr
   cdaar
   cdadr
   cddar
   cdddr
   caaaar
   caaadr
   caadar
   caaddr
   cadaar
   cadadr
   caddar
   cadddr
   cdaaar
   cdaadr
   cdadar
   cdaddr
   cddaar
   cddadr
   cdddar
   cddddr
   nth
   con
   cons
   conc
   circ
   rot
   list
   need
   range
   full
   make
   made
   chain
   link
   yoke
   copy
   mix
   append
   delete
   delq
   replace
   insert
   remove
   place
   strip
   split
   reverse
   flip
   trim
   clip
   head
   tail
   stem
   fin
   last
   member
   memq
   mmeq
   sect
   diff
   index
   offset
   prior
   assoc
   rassoc
   asoq
   rasoq
   flood
   rank
   sort
   uniq
   group
   length
   size
   bytes
   val
   set
   xchg
   push
   push1
   push1q
   pop
   ++
   shift
   cut
   queue
   fifo
   idx
   balance
   depth
   get
   fill
   apply





Control Flow



   load
   args
   next
   arg
   rest
   pass
   quote
   as
   lit
   eval
   run
   macro
   curry
   def
   de
   dm
   recur
   recurse
   undef
   box
   new
   type
   isa
   method
   meth
   send
   try
   super
   extra
   with
   bind
   job
   let
   let?
   use
   and
   or
   nand
   nor
   xor
   bool
   not
   nil
   t
   prog
   prog1
   prog2
   if
   ifn
   if2
   if@@
   when
   unless
   cond
   nond
   case
   casq
   state
   while
   until
   loop
   do
   at
   for
   tco
   tc
   catch
   throw
   finally
   co
   yield
   !
   e
   $
   call
   ipid
   opid
   kill
   quit
   task
   fork
   detach
   pipe
   later
   timeout
   tasks
   abort
   bye





Mapping



   apply
   pass
   fun
   maps
   map
   mapc
   maplist
   mapcar
   mapcon
   mapcan
   filter
   extract
   seek
   find
   pick
   fully
   cnt
   sum
   maxi
   mini
   fish
   by





Input/Output



   path
   in
   out
   err
   ctl
   input
   output
   fd
   tty
   prompt
   ipid
   opid
   pipe
   any
   sym
   str
   load
   hear
   tell
   key
   poll
   peek
   char
   skip
   eol
   eof
   from
   till
   line
   format
   scl
   read
   print
   println
   printsp
   prin
   prinl
   msg
   space
   beep
   tab
   flush
   rewind
   ext
   rd
   pr
   wr
   wait
   sync
   echo
   info
   file
   dir
   open
   close
   port
   listen
   accept
   host
   connect
   udp
   script
   once
   finish
   rc
   acquire
   release
   tmp
   pretty
   pp
   show
   view
   here
   prEval
   mail





Object Orientation



   *Class
   class
   dm
   rel
   var
   var:
   new
   type
   isa
   method
   meth
   send
   try
   object
   extend
   super
   extra
   with
   This
   can
   dep





Database



   pool
   pool2
   journal
   id
   blk
   seq
   lieu
   lock
   commit
   rollback
   mark
   free
   dbck
   tree
   genKey
   genStrKey
   useKey
   +relation
   +Any
   +Bag
   +Bool
   +Number
   +Date
   +Time
   +Symbol
   +String
   +Link
   +Joint
   +Blob
   +Hook
   +Hook2
   +index
   +Key
   +Ref
   +Ref2
   +Idx
   +Sn
   +Fold
   +IdxFold
   +Aux
   +UB
   +Dep
   +List
   +Need
   +Mis
   +Alt
   +Swap
   +Entity
   blob
   dbSync
   new!
   set!
   put!
   inc!
   blob!
   upd
   dbs
   db:
   db
   aux
   collect
   search
   forall
   rel
   request
   request!
   obj
   create
   root
   fetch
   store
   count
   leaf
   minKey
   maxKey
   init
   step
   scan
   iter
   ubIter
   prune
   zapTree
   chkTree
   db/3
   db/4
   db/5
   val/3
   lst/3
   map/3
   isa/2
   same/3
   bool/3
   range/3
   head/3
   fold/3
   part/3
   tolr/3
   select/3
   remote/2
   revolve/2





Pilog



   prove
   ->
   unify
   be
   clause
   repeat
   asserta
   assertz
   retract
   rules
   goal
   fail
   pilog
   solve
   query
   ?
   repeat/0
   fail/0
   true/0
   not/1
   call/1
   or/2
   nil/1
   equal/2
   different/2
   append/3
   member/2
   delete/3
   permute/2
   uniq/2
   asserta/1
   assertz/1
   retract/1
   clause/2
   show/1
   for/2
   for/3
   for/4
   db/3
   db/4
   db/5
   val/3
   lst/3
   map/3
   isa/2
   same/3
   bool/3
   range/3
   head/3
   fold/3
   part/3
   tolr/3
   select/3
   remote/2





Debugging



   pretty
   pp
   show
   loc
   *Dbg
   help
   docs
   doc
   more
   less
   what
   who
   can
   dep
   debug
   -debug
   d
   unbug
   u
   v
   vi
   trace
   -trace
   untrace
   traceAll
   proc
   hd
   bench
   bt
   lint
   lintAll
   select





System Functions



   cmd
   argv
   opt
   version
   gc
   tty
   prompt
   raw
   alarm
   sigio
   kids
   protect
   heap
   stack
   adr
   byte
   env
   trail
   up
   sys
   date
   time
   usec
   rt
   stamp
   dat$
   $dat
   datSym
   datStr
   strDat
   expDat
   day
   week
   ultimo
   tim$
   $tim
   telStr
   expTel
   locale
   allowed
   allow
   pwd
   cd
   chdir
   ctty
   info
   dir
   dirname
   basename
   errno
   native
   %@
   struct
   lisp
   exec
   call
   kill
   quit
   task
   fork
   pipe
   timeout
   mail
   assert
   test
   bye





Globals



   NIL
   pico
   *CPU
   *OS
   *DB
   T
   *Solo
   *PPid
   *Pid
   @
   @@
   @@@
   This
   *Prompt
   *Dbg
   *Zap
   *Scl
   *Rule
   *Class
   *Dbs
   *Run
   *Hup
   *Sig1
   *Sig2
   *TStp1
   *TStp2
   *Term
   ^
   *Err
   *Msg
   *Uni
   *Adr
   *Allow
   *Fork
   *Bye











Download



The PicoLisp system can be downloaded from the PicoLisp Download page.





pil21/doc/refA.html0000644000000000000000000005404014516411376011216 0ustar  





A





A






*Adr


A global variable holding the IP address of last recently accepted client.
See also listen and accept.


: *Adr
-> "127.0.0.1"




(adr 'var) -> num


(adr 'num) -> var


Converts, in the first form, a variable var (a symbol or a cons
pair) into num (actually an encoded pointer). This pointer can be
passed to native or struct. The second form converts a pointer
back into the original var. Note that this original
var may be garbage collected if it is not referred from other data,
giving unpredictable results. See also byte.


: (setq X (box 7))
-> $370237372176
: (adr X)
-> 533244889064
: (adr @)
-> $370237372176
: (val @)
-> 7
: (struct (adr X) 'N)
-> 114
$: (struct (adr X) T)
-> 7




*Allow


A global variable holding allowed access patterns. If its value is
non-NIL, it should contain a list where the CAR is an idx tree of allowed items, and the CDR a list of
prefix strings. See also allow,
allowed and pre?.


: (allowed ("app/")  # Initialize
   "!start" "!stop" "lib.css" "!psh" )
-> NIL
: (allow "!myFoo")  # additional item
-> "!myFoo"
: (allow "myDir/" T)  # additional prefix
-> "myDir/"

: *Allow
-> (("!start" ("!psh" ("!myFoo")) "!stop" NIL "lib.css") "app/" "myDir/")

: (idx *Allow)  # items
-> ("!myFoo" "!psh" "!start" "!stop" "lib.css")
: (cdr *Allow)  # prefixes
-> ("app/" "myDir/")




+Alt


Prefix class specifying an alternative class for a +relation. This allows indexes or other
side effects to be maintained in a class different from the current one. See
also Database.


(class +EuOrd +Ord)                    # EU-specific order subclass
(rel nr (+Alt +Key +Number) +XyOrd)    # Maintain the key in the +XyOrd index




+Any


Class for unspecified relations, a subclass of +relation. Objects of that class accept
and maintain any type of Lisp data. Used often when there is no other suitable
relation class available. See also Database.


In the following example +Any is used simply for the reason that
there is no direct way to specify dotted pairs:


(rel loc (+Any))  # Locale, e.g. ("DE" . "de")




+Aux


Prefix class maintaining auxiliary keys for +relations, in addition to +Ref or +Idx indexes. Expects a list of auxiliary
attributes of the same object, and combines all keys in that order into a single
index key. See also +UB, aux and Database.


(rel nr (+Ref +Number))                # Normal, non-unique index
(rel nm (+Aux +Ref +String) (nr txt))  # Combined name/number/text index
(rel txt (+Aux +Sn +Idx +String) (nr)) # Text/number plus tolerant text index




(abort 'cnt . prg) -> any


Aborts the execution of prg if it takes longer than
cnt seconds, and returns NIL. Otherwise, the result of
prg is returned. alarm
is used internally, so care must be taken not to interfer with other calls to
alarm.


: (abort 20 (in Sock (rd)))  # Wait maximally 20 seconds for socket data




(abs 'num) -> num


Returns the absolute value of the num argument.


: (abs -7)
-> 7
: (abs 7)
-> 7




(accept 'cnt) -> cnt | NIL


Accepts a connection on descriptor cnt (as received by port), and returns the new socket descriptor
cnt. The global variable *Adr is set to the IP address
of the client. See also listen,
connect and *Adr.


: (setq *Socket
   (accept (port 6789)) )  # Accept connection at port 6789
-> 4




(accu 'var 'any 'num)


Accumulates num into a sum, using the key any in
an association list stored in var. See also assoc.


: (off Sum)
-> NIL
: (accu 'Sum 'a 1)
-> (a . 1)
: (accu 'Sum 'a 5)
-> 6
: (accu 'Sum 22 100)
-> (22 . 100)
: Sum
-> ((22 . 100) (a . 6))




(acquire 'sym) -> flg


Tries to acquire the mutex represented by the file sym, by
obtaining an exclusive lock on that file with ctl, and then trying to write the PID of the
current process into that file. It fails if the file already holds the PID of
some other existing process. See also release, *Pid and rc.


: (acquire "sema1")
-> 28255




(alarm 'cnt . prg) -> cnt


Sets an alarm timer scheduling prg to be executed after
cnt seconds, and returns the number of seconds remaining until any
previously scheduled alarm was due to be delivered. Calling (alarm
0) will cancel an alarm. See also abort, sigio, *Hup, *Winch, *Sig[12], *TStp[12] and *Term.


: (prinl (tim$ (time) T)) (alarm 10 (prinl (tim$ (time) T)))
16:36:14
-> 0
: 16:36:24

: (alarm 10 (bye 0))
-> 0
$




(align 'cnt 'any) -> sym


(align 'lst 'any ..) -> sym


Returns a transient symbol with all any arguments packed in an aligned format. In the first form,
any will be left-aligned if cnt is negative, otherwise
right-aligned. In the second form, all any arguments are packed
according to the numbers in lst. See also tab, center and wrap.


: (align 4 "a")
-> "   a"
: (align -4 12)
-> "12  "
: (align (4 4 4) "a" 12 "b")
-> "   a  12   b"




(all ['T | '0 | 'sym]) -> lst


Returns a new list of all internal symbols
in the current namespace search order (if called without arguments, or with
NIL), all current transient
symbols (if the argument is T), all external symbols (if the argument is zero), or all
symbols of the given namespace sym. See also symbols and all*.


: (all)  # All internal symbols
-> (inc> leaf nil inc! accept ...

# Find all symbols starting with an underscore character
: (filter '((X) (= "_" (car (chop X)))) (all))
-> (_put _nacs _oct _lintq _lst _map _iter _dbg2 _getLine _led ...




(all* 'any ['flg]) -> lst


Returns a sorted list of all (possibly namespaced) symbols and path names
starting with the characters in any. If flg is
T, only symbols, and if it is 0, only path names are
returned. Typically used in TAB-completion routines. See also all, symbols and intern.


: (all* "map")
-> ("map" "map/3" "mapc" "mapcan" "mapcar" "mapcon" "maplist" "maps")
: (all* "llvm~BLK")
-> ("llvm~BLK" "llvm~BLKMASK" "llvm~BLKSIZE" "llvm~BLKTAG")




(allow 'sym ['flg]) -> sym


Maintains an index structure of allowed access patterns in the global
variable *Allow. If the value of
*Allow is non-NIL, sym is added to the
idx tree in the CAR of
*Allow (if flg is NIL), or to the list of
prefix strings (if flg is non-NIL). See also allowed.


: *Allow
-> (("!start" ("!psh") "!stop" NIL "lib.css") "app/")
: (allow "!myFoo")  # additionally allowed item
-> "!myFoo"
: (allow "myDir/" T)  # additionally allowed prefix
-> "myDir/"




(allowed lst [sym ..])


Creates an index structure of allowed access patterns in the global variable
*Allow. lst should
consist of prefix strings (to be checked at runtime with pre?), and the sym arguments
should specify the initially allowed items. See also allow.


: (allowed ("app/")  # allowed prefixes
   "!start" "!stop" "lib.css" "!psh" )  # allowed items
-> NIL




(and 'any ..) -> any


Logical AND. The expressions any are evaluated from left to
right. If NIL is encountered, NIL is returned
immediately. Else the result of the last expression is returned. See also
nand, or and when.


: (and (= 3 3) (read))
abc  # User input
-> abc
: (and (= 3 4) (read))
-> NIL




(any 'any) -> any


Parses any from the argument. This is the reverse operation of
sym. See also str, (any 'sym) is equivalent to
(car (str 'sym)).


: (any "(a b # Comment\nc d)")
-> (a b c d)
: (any "\"A String\"")
-> "A String"




(append 'lst ..) -> lst


Appends all argument lists. See also conc, insert, delete and remove.


: (append '(a b c) (1 2 3))
-> (a b c 1 2 3)
: (append (1) (2) (3) 4)
-> (1 2 3 . 4)




append/3


Pilog predicate that succeeds if appending the
first two list arguments is equal to the third argument. See also append and member/2.


: (? (append @X @Y (a b c)))
 @X=NIL @Y=(a b c)
 @X=(a) @Y=(b c)
 @X=(a b) @Y=(c)
 @X=(a b c) @Y=NIL
-> NIL




(apply 'fun 'lst ['any ..]) -> any


Applies fun to lst. If additional any
arguments are given, they are applied as leading elements of lst.
(apply 'fun 'lst 'any1 'any2) is equivalent to (apply 'fun
(cons 'any1 'any2 'lst)).


: (apply + (1 2 3))
-> 6
: (apply * (5 6) 3 4)
-> 360
: (apply '((X Y Z) (* X (+ Y Z))) (3 4 5))
-> 27
: (apply println (3 4) 1 2)
1 2 3 4
-> 4




(arg 'cnt) -> any


Can only be used inside functions with a variable number of arguments (with
@). Returns the cnt'th remaining argument. See also
next, args, rest and pass.


: (de foo @
   (println (arg 1) (arg 2))
   (println (next))
   (println (arg 1) (arg 2)) )
-> foo
: (foo 'a 'b 'c)
a b
a
b c
-> c




(args) -> flg


Can only be used inside functions with a variable number of arguments (with
@). Returns T when there are more arguments to be
fetched from the internal list. See also next, arg, rest and pass.


: (de foo @ (println (args)))       # Test for arguments
-> foo
: (foo)                             # No arguments
NIL
-> NIL
: (foo NIL)                         # One argument
T
-> T
: (foo 123)                         # One argument
T
-> T




(argv [var ..] [. sym]) -> lst|sym


If called without arguments, argv returns a list of strings
containing all remaining command line arguments. Otherwise, the
var/sym arguments are subsequently bound to the command line
arguments. A hyphen "-" can be used to inhibit the automatic
loading further arguments. See also cmd, Invocation and
opt.


$ pil -"println 'OK" - abc 123 +
OK
: (argv)
-> ("abc" "123")
: (argv A B)
-> "123"
: A
-> "abc"
: B
-> "123"
: (argv . Lst)
-> ("abc" "123")
: Lst
-> ("abc" "123")




(as 'any1 . any2) -> any2 | NIL


Returns any2 unevaluated when any1 evaluates to
non-NIL. Otherwise NIL is returned. (as Flg A B
C) is equivalent to (and Flg '(A B C)). as is
typically used in read-macros to conditionally
exclude sub-expressions. See also quote.


: (as (= 3 3) A B C)
-> (A B C)

(de foo ()
   (doSomething)
   ~(as (someConditio)
      (doThis)
      (doThat) )
   (doMore) )




(asoq 'any 'lst) -> lst


Searches an association list. Returns the first element from
lst with any as its CAR, or NIL if no
match is found. == is used for
comparison (pointer equality). See also assoc, rasoq, get, push1q, delq, memq, mmeq and Comparing.


: (asoq 'a '((999 1 2 3) (b . 7) ("ok" "Hello")))
-> NIL
: (asoq 'b '((999 1 2 3) (b . 7) ("ok" "Hello")))
-> (b . 7)




(assert exe ..) -> prg | NIL


When in debug mode (*Dbg is
non-NIL), assert returns a prg list which
tests all exe conditions, and issues an error via quit if one of the results evaluates to
NIL. Otherwise, NIL is returned. Used typically in
combination with the ~ tilde read-macro to insert the test code only when
in debug mode. See also test.


# Start in debug mode
$ pil +
: (de foo (N)
   ~(assert (>= 90 N 10))
   (bar N) )
-> foo
: (pp 'foo)                      # Pretty-print 'foo'
(de foo (N)
   (unless (>= 90 N 10)          # Assertion code exists
      (quit "'assert' failed" '(>= 90 N 10)) )
   (bar N) )
-> foo
: (foo 7)                        # Try it
(>= 90 N 10) -- Assertion failed
?

# Start in non-debug mode
$ pil
: (de foo (N)
   ~(assert (>= 90 N 10))
   (bar N) )
-> foo
: (pp 'foo)                      # Pretty-print 'foo'
(de foo (N)
   (bar N) )                     # Assertion code does not exist
-> foo




(asserta 'lst) -> lst


Inserts a new Pilog fact or rule before all
other rules. See also be, clause, assertz and retract.


: (be a (2))            # Define two facts
-> a
: (be a (3))
-> a

: (asserta '(a (1)))    # Insert new fact in front
-> ((1))

: (? (a @N))            # Query
 @N=1
 @N=2
 @N=3
-> NIL




asserta/1


Pilog predicate that inserts a new fact or rule
before all other rules. See also asserta, assertz/1 and retract/1.


: (? (asserta (a (2))))
-> T
: (? (asserta (a (1))))
-> T
: (rules 'a)
1 (be a (1))
2 (be a (2))
-> a




(assertz 'lst) -> lst


Appends a new Pilog fact or rule behind all
other rules. See also be, clause, asserta and retract.


: (be a (1))            # Define two facts
-> a
: (be a (2))
-> a

: (assertz '(a (3)))    # Append new fact at the end
-> ((3))

: (? (a @N))            # Query
 @N=1
 @N=2
 @N=3
-> NIL




assertz/1


Pilog predicate that appends a new fact or rule
behind all other rules. See also assertz, asserta/1 and retract/1.


: (? (assertz (a (1))))
-> T
: (? (assertz (a (2))))
-> T
: (rules 'a)
1 (be a (1))
2 (be a (2))
-> a




(assoc 'any 'lst) -> lst


Searches an association list. Returns the first element from
lst with its CAR equal to any, or NIL if
no match is found. See also asoq and
rassoc.


: (assoc "b" '((999 1 2 3) ("b" . 7) ("ok" "Hello")))
-> ("b" . 7)
: (assoc 999 '((999 1 2 3) ("b" . 7) ("ok" "Hello")))
-> (999 1 2 3)
: (assoc 'u '((999 1 2 3) ("b" . 7) ("ok" "Hello")))
-> NIL




(at '(cnt1 . cnt2|NIL) . prg) -> any


Increments cnt1 (destructively), and returns NIL
when it is less than cnt2. Both cnt1 and
cnt2 should be positive. Otherwise, cnt1 is reset to
zero and prg is executed. Returns the result of prg.
If cnt2 is NIL, nothing is done, and NIL
is returned immediately.


: (do 11 (prin ".") (at (0 . 3) (prin "!")))
...!...!...!..-> NIL




(atom 'any) -> flg


Returns T when the argument any is an atom (a
number or a symbol). See also num?,
sym? and pair.


: (atom 123)
-> T
: (atom 'a)
-> T
: (atom NIL)
-> T
: (atom (123))
-> NIL




(aux 'sym 'cls ['hook] 'any ..) -> sym


Returns a database object of class cls, where the value for
sym corresponds to any and the following arguments.
sym, cls and hook should specify a
tree for cls or one of
its superclasses, for a relation with auxiliary keys. For multi-key accesses,
aux is similar to - but faster than - db, because it
can use a single tree access. See also db, collect, fetch, init, step and +Aux.


(class +PS +Entity)
(rel par (+Dep +Joint) (sup) ps (+Part))        # Part
(rel sup (+Aux +Ref +Link) (par) NIL (+Supp))   # Supplier
...
   (aux 'sup '+PS                               # Access PS object
      (db 'nr '+Supp 1234)
      (db 'nr '+Part 5678) )








pil21/doc/refB.html0000644000000000000000000004063614533312771011223 0ustar  





B





B






*Blob


A global variable holding the pathname of the database blob directory. See
also blob.


: *Blob
-> "blob/app/"




*Bye


A global variable holding a (possibly empty) prg body, to be
executed just before the termination of the PicoLisp interpreter. See also
bye, finish and tmp.


: (push1 '*Bye '(call "rm" "myfile.tmp"))  # Remove a temporary file
-> (call 'rm "myfile.tmp")




+Bag


Class for a list of arbitrary relations, a subclass of +relation. Objects of that class maintain
a list of heterogeneous relations. Typically used in combination with the
+List prefix class, to maintain small
two-dimensional tables within objects. See also Database.


(rel pos (+List +Bag)         # Positions
   ((+Ref +Link) NIL (+Item))    # Item
   ((+Number) 2)                 # Price
   ((+Number))                   # Quantity
   ((+String))                   # Memo text
   ((+Number) 2) )               # Total amount




+Blob


Class for blob relations, a subclass of +relation. Objects of that class maintain
blobs, as stubs in database objects pointing to actual files for arbitrary
(often binary) data. The files themselves reside below the path specified by the
*Blob variable. See also Database.


(rel jpg (+Blob))  # Picture




+Bool


Class for boolean relations, a subclass of +relation. Objects of that class expect
either T or NIL as value (though, as always, only
non-NIL will be physically stored in objects). See also Database.


(rel ok (+Ref +Bool))  # Indexed flag




(balance 'var 'lst ['flg])


Builds a balanced binary idx tree
in var, from the sorted list in lst. Normally, if
arbitary - or, in the worst case, ordered - data are inserted with
idx, the tree will not be balanced. But if lst is
properly sorted, its contents will be inserted in an optimally balanced way. If
flg is non-NIL, the index tree will be augmented
instead of being overwritten. See also Comparing and sort.


# Normal idx insert
: (off I)
-> NIL
: (for X (1 4 2 5 3 6 7 9 8) (idx 'I X T))
-> NIL
: (depth I)
-> (7 . 4)

# Balanced insert
: (balance 'I (sort (1 4 2 5 3 6 7 9 8)))
-> NIL
: (depth I)
-> 4

# Augment
: (balance 'I (sort (10 40 20 50 30 60 70 90 80)) T)
-> NIL
: (idx 'I)
-> (1 2 3 4 5 6 7 8 9 10 20 30 40 50 60 70 80 90)




(basename 'any) -> sym


Returns the filename part of a path name any. See also dirname and path.


: (basename "a/b/c/d")
-> "d"




(be sym . any) -> sym


Declares a Pilog fact or rule for the
sym argument, by concatenating the any argument to the
T property of sym. Groups of declarations are
collected for a given sym. When sym changes, i.e. when
it differs from the one in the previous declaration, the current group is
considered to be complete and a new group is started. Later be
declarations for a previously completed symbol will reset its rules, to allow
repeated reloading of source files.
See also *Rule, clause, asserta, assertz, retract, rules, goal and prove.


: (be likes (John Mary))
-> likes
: (be likes (John @X) (likes @X wine) (likes @X food))
-> likes

: (get 'likes T)
-> (((John Mary)) ((John @X) (likes @X wine) (likes @X food)))

: (rules 'likes)
1 (be likes (John Mary))
2 (be likes (John @X) (likes @X wine) (likes @X food))
-> likes

: (? (likes John @X))
 @X=Mary
-> NIL




(beep) -> NIL


Send the bell character to the console. See also space, prin and char.


: (beep)
-> NIL




(bench . prg) -> any


(Debug mode only) Benchmarks prg, by printing the time it took
to execute, and returns the result. See also usec.


: (bench (wait 2000))
1.996 sec
-> NIL




(bin 'num ['num]) -> sym


(bin 'sym) -> num


Converts a number num to a binary string, or a binary string
sym to a number. In the first case, if the second argument is
given, the result is separated by spaces into groups of such many digits. See
also oct, hex, hax and format.


: (bin 73)
-> "1001001"
: (bin "1001001")
-> 73
: (bin 1234567 4)
-> "1 0010 1101 0110 1000 0111"




(bind 'sym|lst . prg) -> any


Binds value(s) to symbol(s). The first argument must evaluate to a symbol,
or a list of symbols or symbol-value pairs. The values of these symbols are
saved (and the symbols bound to the values in the case of pairs),
prg is executed, then the symbols are restored to their original
values. During execution of prg, the values of the symbols can be
temporarily modified. The return value is the result of prg. See
also let, job and use.


: (setq X 123)                               # X is 123
-> 123
: (bind 'X (setq X "Hello") (println X))  # Set X to "Hello", print it
"Hello"
-> "Hello"
: (bind '((X . 3) (Y . 4)) (println X Y) (* X Y))
3 4
-> 12
: X
-> 123                                       # X is restored to 123




(bit? 'num ..) -> num | NIL


Returns the first num argument when all bits which are 1 in the
first argument are also 1 in all following arguments, otherwise
NIL. When one of those arguments evaluates to NIL, it
is returned immediately. See also &,
| and x|.


: (bit? 7 15 255)
-> 7
: (bit? 1 3)
-> 1
: (bit? 1 2)
-> NIL




(blk 'fd 'cnt 'siz ['fd2]) -> lst


(blk 'fd 0) -> (cnt . siz)


Reads raw object data from the cnt'th block in the file open on
descriptor fd. Returns a cons pair of the value and property list
of that database object, or NIL for an invalid block. If
cnt is zero, a cons pair of the total number of blocks in the file
and the file's block size scale factor is returned. Otherwise, siz
should be the block size scale factor. If fd2 is given, a read
(shared) lock is set on that file during the read operation. See also pool, pool2, id, ctl
and qsym.


: (show '{4})
{4} (+Role)
   usr ({15} {13} {11})
   perm (Customer Item Order Report ..)
   nm "Accounting"
-> {4}
: (open "db/app/@")
-> 15
: (blk 15 4 3 15)
-> ((+Role) (({15} {13} {11}) . usr) ((Customer Item Order Report Delete) . perm) ("Accounting" . nm))




(blob 'obj 'sym) -> sym


Returns the blob file name for var in obj. See
also *Blob, blob! and pack.


: (show (db 'nr '+Item 1))
{B1} (+Item)
   jpg
   pr 29900
   inv 100
   sup {C1}
   nm "Main Part"
   nr 1
-> {B1}
: (blob '{B1} 'jpg)
-> "blob/app/3/-/1.jpg"




(blob! 'obj 'sym 'file)


Stores the contents of file in a blob. See also put!>.


(blob! *ID 'jpg "picture.jpg")




(bool 'any) -> flg


Returns T when the argument any is
non-NIL. This function is only needed when T is
strictly required for a "true" condition (Usually, any non-NIL
value is considered to be "true"). See also flg?.


: (and 3 4)
-> 4
: (bool (and 3 4))
-> T




bool/3


Pilog predicate that succeeds if the first
argument has the same truth value as the result of applying the get algorithm to the following arguments.
Typically used as filter predicate in select/3 database queries. See also
bool, isa/2, same/3, range/3, head/3, fold/3, part/3 and tolr/3.


: (? @OK T           # Find orders where the 'ok' flag is set
   (db nr +Ord @Ord)
   (bool @OK @Ord ok) )
 @OK=T @Ord={B7}
-> NIL




(box 'any) -> sym


Creates and returns a new anonymous symbol. The initial value is set to the
any argument. See also new
and box?.


: (show (box '(A B C)))
$134425627 (A B C)
-> $134425627




(box? 'any) -> sym | NIL


Returns the argument any when it is an anonymous symbol,
otherwise NIL. See also box, str? and ext?.


: (box? (new))
-> $134563468
: (box? 123)
-> NIL
: (box? 'a)
-> NIL
: (box? NIL)
-> NIL




(bt ['flg]) -> flg


(Debug mode only) Formatted stack backtrace printing (see trail) for the current point of program
execution. For each bind frame, the function call (reduced with less) is pretty-printed, followed by indented
variable-value-pairs. If flg is NIL, bt
then waits for a key, and terminates when ESC is pressed (like more). See also up and env.


: (de f (A B)
   (let F 7
      (g (inc A) (dec B)) ) )
-> f
: (de g (C D)
   (let G 8
      (/ C D) ) )
-> g

: (f 2 1)
!? (/ C D)
Div/0
? (bt)
(g (inc A) (dec B))
   C 3
   D 0
   G 8
(f 2 1)
   A 2
   B 1
   F 7
-> NIL
?




(buf sym 'cnt . prg) -> any


Creates a temporary local memory buffer on the stack, and binds
sym to the pointer during the execution of prg. The
current value of sym is saved and restored appropriately. The
return value is the result of prg. See also let, native, struct and %@.


(buf Buf BUFSIZ
   (%@ "read" 'I Fd Buf BUFSIZ)
   (%@ "write" 'I Fd2 Buf BUFSIZ) )



This is functionally equivalent to (but more efficient than)


(let Buf (%@ "malloc" 'P BUFSIZ)
   (%@ "read" 'I Fd Buf BUFSIZ)
   (%@ "write" 'I Fd2 Buf BUFSIZ)
   (%@ "free" NIL Buf) )




(by 'fun1 'fun2 'lst ..) -> lst


Applies fun1 to each element of lst. When
additional lst arguments are given, their elements are also passed
to fun1. Each result of fun1 is CONSed with its
corresponding argument from the original lst, and collected into a
list which is passed to fun2. For the list returned from
fun2, the CAR elements returned by fun1 are
(destructively) removed from each element ("decorate-apply-undecorate" idiom).


: (let (A 1 B 2 C 3) (by val sort '(C A B)))
-> (A B C)
: (by '((N) (bit? 1 N)) group (3 11 6 2 9 5 4 10 12 7 8 1))
-> ((3 11 9 5 7 1) (6 2 4 10 12 8))




(bye ['cnt])


Executes all pending finally
expressions, closes all open files, executes the VAL of the global
variable *Bye (should be a
prg), flushes standard output, and then exits the PicoLisp
interpreter. The process return value is cnt, or 0 if the argument
is missing or NIL.


: (setq *Bye '((println 'OK) (println 'bye)))
-> ((println 'OK) (println 'bye))
: (bye)
OK
bye
$




(byte 'num ['cnt]) -> cnt


Returns - if the second argument is not given - a byte value (0 .. 255) from
the memory location pointed to by num. Otherwise cnt
is stored in the memory location and returned. See also adr.


: (hex (byte (>> -4 (adr (1)))))
-> "12"                             # Short number '1'
: (hex (byte (>> -4 (adr (2)))))
-> "22"                             # Short number '2'

: (setq P (native "@" "malloc" 'N 8))  # Set pointer to a new buffer
-> 25084048
: (byte P (char "A"))                  # Store byte 'A'
-> 65
: (byte (inc P) (char "B"))            # Store byte 'B'
-> 66
: (byte (+ P 2) (char "C"))            # Store byte 'C'
-> 67
: (byte (+ P 3) 0)                     # Store null byte
-> 0
: (native "@" "strdup" 'S P)           # Read bytes as string
-> "ABC"
: (native "@" "free" 'N P)             # Free buffer
-> 0




(bytes 'any) -> cnt


Returns the number of bytes any would occupy in encoded binary
format (as generated by pr). See also
size and length.


: (bytes "abc")
-> 4
: (bytes "äbc")
-> 5
: (bytes 127)
-> 2
: (bytes 128)
-> 3
: (bytes (101 (102) 103))
-> 10
: (bytes (101 102 103 .))
-> 9








pil21/doc/refC.html0000644000000000000000000007475214750640131011225 0ustar  





C





C






*CPU


A global variable holding the target CPU (architecture). Typical values are
"aarch64", "x86-64" etc. See also *OS and version.


: *CPU
-> "x86-64"




*Class


A global variable holding the current class. See also OO Concepts, class, extend, dm and var and rel.


: (class +Test)
-> +Test
: *Class
-> +Test




(cache 'var 'any [. prg]) -> any


Speeds up some calculations by maintaining a tree of previously calculated
results in an idx structure
("memoization") in var. A hash of the argument any is used
internally to build the index key. If no prg is given, the internal
var holding a previously stored value is returned (note that
var may have a name which is not human-readable).


: (de fibonacci (N)
   (cache '(NIL) N
      (if (>= 2 N)
         1
         (+ (fibonacci (dec N)) (fibonacci (- N 2))) ) ) )
-> fibonacci

: (fibonacci 22)
-> 17711

: (fibonacci 10000)
-> 3364476487643178326662161200510754331030 ...  # (2090 digits)




: (off C)
-> NIL
: (cache 'C 1234 (* 3 4))
-> 12
: (inc (cache 'C 1234))
-> 13
: (val (cache 'C 1234))
-> 13




(call 'any ..) -> flg


Calls an external system command. The any arguments specify the
command and its arguments. Returns T if the command was executed
successfully. The (system dependent) exit status code of the child process is
stored in the global variable @@. See
also exec.


: (when (call 'test "-r" "file.l")  # Test if file exists and is readable
   (load "file.l")  # Load it
   (call 'rm "file.l") )  # Remove it

: (cons (call "sh" "-c" "kill -SEGV $$") @@ (hex @@))
-> (NIL 11 . "B")




call/1


Pilog predicate that succeeds if the argument
term can be proven.


: (be mapcar (@ NIL NIL))
-> mapcar
: (be mapcar (@P (@X . @L) (@Y . @M))
   (call @P @X @Y)                        # Call the given predicate
   (mapcar @P @L @M) )
-> mapcar
: (? (mapcar permute ((a b c) (d e f)) @X))
 @X=((a b c) (d e f))
 @X=((a b c) (d f e))
 @X=((a b c) (e d f))
 ...
 @X=((a c b) (d e f))
 @X=((a c b) (d f e))
 @X=((a c b) (e d f))
 ...




(can 'msg) -> lst


(Debug mode only) Returns a list of all classes that accept the message
msg. See also OO Concepts, class, has, dep, what and who.


: (can 'zap>)
-> ((zap> . +relation) (zap> . +Blob) (zap> . +Entity))
: (more @ pp)
(dm (zap> . +relation) (Obj Val))

(dm (zap> . +Blob) (Obj Val)
   (and
      Val
      (call 'rm "-f" (blob Obj (: var))) ) )

(dm (zap> . +Entity) NIL
   (for X (getl This)
      (let V (or (atom X) (pop 'X))
         (and (meta This X) (zap> @ This V)) ) ) )

-> NIL




(car 'var) -> any


List access: Returns the value of var if it is a symbol, or the
first element if it is a list. See also cdr and c..r.


: (car (1 2 3 4 5 6))
-> 1

































(c[ad]*ar 'var) -> any


(c[ad]*dr 'lst) -> any


List access shortcuts. Combinations of the car and cdr functions, with up to four letters 'a' and
'd'.


: (cdar '((1 . 2) . 3))
-> 2




(case 'any (any1 . prg1) (any2 . prg2) ..) -> any


Multi-way branch: any is evaluated and compared to the CAR
elements anyN of each clause. If one of them is a list,
any is in turn compared to all elements of that list.
T is a catch-all for any value. If a comparison succeeds,
prgN is executed, and the result returned. Otherwise
NIL is returned. See also casq and state .


: (case (char 66) ("A" (+ 1 2 3)) (("B" "C") "Bambi") ("D" (* 1 2 3)))
-> "Bambi"
: (case 'b (a 1) ("b" 2) (b 3) (c 4))
-> 2




(casq 'any (any1 . prg1) (any2 . prg2) ..) -> any


Multi-way branch: any is evaluated and compared to the CAR
elements anyN of each clause. == is used for comparison (pointer equality). If
one of them is a list, any is in turn compared to all elements of
that list. T is a catch-all for any value. If a comparison
succeeds, prgN is executed, and the result returned. Otherwise
NIL is returned. See also case and state.


: (casq 'b (a 1) ("b" 2) (b 3) (c 4))
-> 3
: (casq 'b (a 1) ("b" 2) ((a b c) 3) (c 4))
-> 3




(catch 'any . prg) -> any


Sets up the environment for a non-local jump which may be caused by throw or by a runtime error. If
any is an atom, it is used by throw as a jump label
(with T being a catch-all for any label), and a throw
called during the execution of prg will immediately return the
thrown value. Otherwise, any should be a list of strings, to catch
any error whose message contains one of these strings, and
catch will immediately return the matching string. If
neither throw nor an error occurred, the result of
prg is returned. The global variable @@ is set to T if a
throw or error occurred, otherwise NIL. See
also finally, quit, if@@ and Error Handling.


: (catch 'OK (println 1) (throw 'OK 999) (println 2))
1
-> 999
: (catch '("No such file") (in "doesntExist" (foo)))
-> "No such file"




Pattern for catching and logging errors:


(if@@
   (catch '(NIL)
      (...) )
   (nil (msg *Msg))  # If an error was thrown, log it and return NIL
   @ ) ) )  # else return the value returned from catch




(cd 'any) -> sym


Changes the current directory to any. The old directory is
returned on success, otherwise NIL. See also chdir, dir and pwd.


: (when (cd "lib")
   (println (length (dir)))
   (cd @) )
99




(cdr 'lst) -> any


List access: Returns all but the first element of lst. See also
car and c..r.


: (cdr (1 2 3 4 5 6))
-> (2 3 4 5 6)




(center 'cnt|lst 'any ..) -> sym


Returns a transient symbol with all any arguments packed in a centered format. Trailing blanks
are omitted. See also align, tab and wrap.


: (center 4 12)
-> " 12"
: (center 4 "a")
-> " a"
: (center 7 "a")
-> "   a"
: (center (3 3 3) "a" "b" "c")
-> " a  b  c"




(chain 'any ..) -> any


Concatenates (destructively) one or several new list elements
any to the end of the list in the current make environment. This operation is efficient
also for long lists, because a pointer to the last element of the result list is
maintained. chain returns the last linked argument. See also
link, yoke and made.


: (make (chain (list 1 2 3) NIL (cons 4)) (chain (list 5 6)))
-> (1 2 3 4 5 6)




(char) -> sym


(char 'cnt) -> sym


(char T) -> sym


(char 'sym) -> cnt


When called without arguments, the next character from the current input
stream is returned as a single-character transient symbol, or NIL
upon end of file. When called with a number cnt, a character with
the corresponding unicode value is returned. As a special case, T
is accepted to produce a byte value greater than any first byte in a UTF-8
character (used as a top value in comparisons). Otherwise, when called with a
symbol sym, the numeric unicode value of the first character of the
name of that symbol is returned. See also peek, skip, key, line, till and eof.


: (char)                   # Read character from console
A                          # (typed 'A' and a space/return)
-> "A"
: (char 100)               # Convert unicode to symbol
-> "d"
: (char "d")               # Convert symbol to unicode
-> 100

: (char T)                 # Special case
-> # (not printable)

: (char 0)
-> NIL
: (char NIL)
-> 0




(chdir 'any . prg) -> any


Changes the current directory to any with cd during the execution of prg. Then
the previous directory will be restored and the result of prg
returned. See also dir and pwd.


: (pwd)
-> "/usr/abu/pico"
: (chdir "src" (pwd))
-> "/usr/abu/pico/src"
: (pwd)
-> "/usr/abu/pico"




(chkTree 'sym ['fun]) -> num


Checks a database tree node (and recursively all sub-nodes) for consistency.
Returns the total number of nodes checked. Optionally, fun is
called with the key and value of each node, and should return NIL
for failure. See also tree and
root.


: (show *DB '+Item)
{40} 6
   nr (6 . {H1})
   pr (6 . {H3})
   sup (6 . {H2})
   nm (67 . {I3})
-> {40}
: (chkTree '{H1})   # Check that node
-> 6




(chop 'any) -> lst


Returns any as a list of single-character strings. If
any is NIL or a symbol with no name, NIL
is returned. A list argument is returned unchanged.


: (chop 'car)
-> ("c" "a" "r")
: (chop "Hello")
-> ("H" "e" "l" "l" "o")




(circ 'any ..) -> lst


Produces a circular list of all any arguments by consing them to a list and then connecting the
CDR of the last cell to the first cell. See also circ? and list.


: (circ 'a 'b 'c)
-> (a b c .)




(circ? 'any) -> any


Returns the circular list tail if any is a circular list, else
NIL. See also circ.


: (circ? 'a)
-> NIL
: (circ? (1 2 3))
-> NIL
: (circ? (1 . (2 3 .)))
-> (2 3 .)




(class sym . typ) -> obj


Defines sym as a class with the superclass(es)
typ. As a side effect, the global variable *Class is set to obj. See also
extend, dm, var,
rel, type, isa and object.


: (class +A +B +C +D)
-> +A
: +A
-> (+B +C +D)
: (dm foo> (X) (bar X))
-> foo>
: +A
-> ((foo> (X) (bar X)) +B +C +D)




(clause '(sym . any)) -> sym


Declares a Pilog fact or rule for the
sym argument, by concatenating the any argument to the
T property of sym. See also *Rule and be.


: (clause '(likes (John Mary)))
-> likes
: (clause '(likes (John @X) (likes @X wine) (likes @X food)))
-> likes
: (? (likes @X @Y))
 @X=John @Y=Mary
-> NIL




clause/2


Pilog predicate that succeeds if the first
argument is a predicate which has the second argument defined as a clause.


: (? (clause append ((NIL @X @X))))
-> T

: (? (clause append @C))
 @C=((NIL @X @X))
 @C=(((@A . @X) @Y (@A . @Z)) (append @X @Y @Z))
-> NIL




(clip 'lst) -> lst


Returns a copy of lst with all whitespace characters or
NIL elements removed from both sides. See also trim.


: (clip '(NIL 1 NIL 2 NIL))
-> (1 NIL 2)
: (clip '(" " a " " b " "))
-> (a " " b)




(close 'cnt) -> cnt | NIL


Closes a file descriptor cnt, and returns it when successful.
Should not be called inside an out body
for that descriptor. See also open,
poll,
listen and connect.


: (close 2)                            # Close standard error
-> 2




(cmd ['any]) -> sym


When called without an argument, the name of the command that invoked the
picolisp interpreter is returned. Otherwise, the command name is set to
any. Setting the name may not work on some operating systems. Note
that the new name must not be longer than the original one. See also argv, file and Invocation.


$ pil +
: (cmd)
-> "/usr/bin/picolisp"
: (cmd "!/bin/picolust")
-> "!/bin/picolust"
: (cmd)
-> "!/bin/picolust"




(cnt 'fun 'lst ..) -> cnt


Applies fun to each element of lst. When
additional lst arguments are given, their elements are also passed
to fun. Returns the count of non-NIL values returned
from fun.


: (cnt cdr '((1 . T) (2) (3 4) (5)))
-> 2




(collect 'sym 'cls ['hook] ['any|beg ['end [sym|cnt ..]]])


Returns a list of all database objects of class cls, where the
values for the sym arguments correspond to the any
arguments, or where the values for the sym arguments are in the
range beg .. end. sym, cls
and hook should specify a tree for cls or one of its
superclasses. If additional sym|cnt arguments are given, the final
values for the result list are obtained by applying the get algorithm. See also db, aux,
fetch, init, step and and search.


: (collect 'nr '+Item)
-> ({B1} {B2} {B3} {B4} {B5} {B6} {B8})
: (collect 'nr '+Item 3 6 'nr)
-> (3 4 5 6)
: (collect 'nr '+Item 3 6 'nm)
-> ("Auxiliary Construction" "Enhancement Additive" "Metal Fittings" "Gadget Appliance")
: (collect 'nm '+Item "Main Part")
-> ({B1})




(commit ['any] [exe1] [exe2]) -> T


Closes a transaction, by writing all new or modified external symbols to,
and removing all deleted external symbols from the database. When
any is given, it is implicitly sent (with all modified objects) via
the tell mechanism to all family
members. If exe1 or exe2 are given, they are executed
as pre- or post-expressions while the database is locked and protected. See also rollback.


: (pool "db")
-> T
: (put '{1} 'str "Hello")
-> "Hello"
: (commit)
-> T




(complete 'any) -> T | lst


Global variable holding a (possibly empty) function, which will be
called when TAB is pressed in readline(3) to complete the
text before the current input point. If it is NIL,
readline's default filename generator function is used. Otherwise, it
should be a function which returns the next match (if any
is NIL), some default value (if any is
T, meaning there is no partial word to be completed), or
initializes the generator with the given text and returns the first
result.


: (pp 'complete)
(de complete (S)
   (when S
      (setq "*Cmpl"
         (if (=T S) (list "   ") (flip (all* S))) ) )
   (pop '"*Cmpl") )
-> complete




(con 'lst 'any) -> any


Connects any to the first cell of lst, by
(destructively) storing any in the CDR of lst. See
also set and conc.


: (setq C (1 . a))
-> (1 . a)
: (con C '(b c d))
-> (b c d)
: C
-> (1 b c d)




(conc 'lst ..) -> lst


Concatenates all argument lists (destructively). See also append and con.


: (setq  A (1 2 3)  B '(a b c))
-> (a b c)
: (conc A B)                        # Concatenate lists in 'A' and 'B'
-> (1 2 3 a b c)
: A
-> (1 2 3 a b c)                    # Side effect: List in 'A' is modified!




(cond ('any1 . prg1) ('any2 . prg2) ..) -> any


Multi-way conditional: If any of the anyN conditions evaluates
to non-NIL, prgN is executed and the result returned.
Otherwise (all conditions evaluate to NIL), NIL is
returned. See also nond, if, and,
if2 and when.


: (cond
   ((= 3 4) (println 1))
   ((= 3 3) (println 2))
   (T (println 3)) )
2
-> 2




(connect 'any1 'any2) -> cnt | NIL


Tries to establish a TCP/IP connection to a server listening at host
any1, port any2. any1 may be either a
hostname or a standard internet address in numbers-and-dots/colons notation
(IPv4/IPv6). any2 may be either a port number or a service name.
Returns a socket descriptor cnt, or NIL if the
connection cannot be established. See also listen and udp.


: (connect "localhost" 4444)
-> 3
: (connect "some.host.org" "http")
-> 4




(cons 'any ['any ..]) -> lst


Constructs a new list cell with the first argument in the CAR and the second
argument in the CDR. If more than two arguments are given, a corresponding chain
of cells is built. (cons 'a 'b 'c 'd) is equivalent to (cons
'a (cons 'b (cons 'c 'd))). See also list.


: (cons 1 2)
-> (1 . 2)
: (cons 'a '(b c d))
-> (a b c d)
: (cons '(a b) '(c d))
-> ((a b) c d)
: (cons 'a 'b 'c 'd)
-> (a b c . d)




(copy 'any) -> any


Copies the argument any. For lists, the top level cells are
copied, while atoms are returned unchanged.


: (=T (copy T))               # Atoms are not copied
-> T
: (setq L (1 2 3))
-> (1 2 3)
: (== L L)
-> T
: (== L (copy L))             # The copy is not identical to the original
-> NIL
: (= L (copy L))              # But the copy is equal to the original
-> T




(co ['any [. prg]]) -> any


Starts, resumes or stops a coroutine with
the tag given by any. If called without arguments, the tag of the
currently running coroutine is returned. If prg is not given, a
coroutine with that tag will be stopped. Otherwise, if a coroutine running with
that tag is found (pointer equality is used for comparison), its execution is
resumed. Else a new coroutine with that tag is initialized and started.
prg will be executed until it either terminates normally, or until
yield is called. In the latter case
co returns, or transfers control to some other, already running,
coroutine. A coroutine cannot call or stop itself directly or indirectly. See
also stack, catch and throw.


: (de pythag (N)   # A generator function
   (if (=T N)
      (co 'rt)  # Stop
      (co 'rt
         (for X N
            (for Y (range X N)
               (for Z (range Y N)
                  (when (= (+ (* X X) (* Y Y)) (* Z Z))
                     (yield (list X Y Z)) ) ) ) ) ) ) )

: (pythag 20)
-> (3 4 5)
: (pythag 20)
-> (5 12 13)
: (pythag 20)
-> (6 8 10)





(count 'tree) -> num


Returns the number of nodes in a database tree. See also tree and root.


: (count (tree 'nr '+Item))
-> 7




(create 'typ 'sym 'lst . prg)


Creates or updates database objects of the type
typ with the properties in sym and lst.
It handles large amounts of data, by sorting and traversing each database index
separately. prg is executed repeatedly - and should return a list
of values for the properties in sym and lst - until it
returns NIL. If the fin of
the list is NIL, a new object of type typ is created,
otherwise it should be an existing object to be updated. If sym is
non-NIL, the first column of the input data is assigned to the
sym property and should already be sorted. The rest of the input
data is assigned to the properties in lst. create
allocates heap memory, and builds temporary files which increase disk
requirements while it runs. No explicit lock should be established on the database, and
no other processes should operate on this database while it runs. When creating
more than a few hundred million index entries per file, it might be necessary to
increase the number of open files with e.g. ulimit -n 10000. See
also dbs, new, commit and prune.


# Minimal E/R model
(class +Cls +Entity)          # Class
(rel key (+Key +Number))      # with a unique numeric key,
(rel num (+Ref +Number))      # an indexed number,
(rel str (+Ref +String))      # and an indexed string

(dbs
   (0 +Cls)
   (4 (+Cls key))             # Each index in a different file
   (4 (+Cls num))
   (4 (+Cls str)) )

# Generating random data
(create '(+Cls) 'key '(num str)
   (co 'go                 # Use a coroutine as generator
      (for Key 100000000   # Key is sorted in input
         (yield            # Return keys, numbers and single-char strings
            (list Key (rand) (char (rand 97 122))) ) ) ) )

# Reading from a file in PLIO format
(create '(+Cls) 'key '(num str)
   (rd) )

# Reading from a TAB-separated CSV file
(create '(+Cls) 'key '(num str)
   (when (split (line) "\t")
      (list
         (format (car @))
         (format (cadr @))
         (pack (caddr @)) ) ) )

# Direct, naive approach (without using 'create')
# Don't try this at home! Takes forever due to disk trashing
(prune 0)
(gc 400 200)
(for Key 100000000
   (new `(db: +Cls) '(+Cls)
      'key Key
      'num (rand)
      'str (char (rand 97 122)) )
   (at (0 . 10000) (commit) (prune 7)) )
(commit)
(prune)
(gc 0)




(ctl 'sym . prg) -> any


Waits until a write (exclusive) lock (or a read (shared) lock if the first
character of sym is "+") can be set on the file
sym, then executes prg and releases the lock. If the
file does not exist, it will be created. When sym is
NIL, a shared lock is tried on the current innermost I/O channel,
and when it is T, an exclusive lock is tried instead. See also
in, out, err and pipe.


$ echo 9 >count                           # Write '9' to file "count"
$ pil +
: (ctl ".ctl"                             # Exclusive control, using ".ctl"
   (in "count"
      (let Cnt (read)                     # Read '9'
         (out "count"
            (println (dec Cnt)) ) ) ) )   # Write '8'
-> 8
:
$ cat count                               # Check "count"
8




(ctty 'pid) -> pid


(ctty 'any) -> any | NIL


Unless called with a short number, ctty changes the current TTY
device to any (or just sets standard I/O to a PTY if
any is NIL). Otherwise, the local console is prepared
for serving the PicoLisp process with the process ID pid. See also
raw.


: (ctty "/dev/tty")
-> "/dev/tty"




(curry lst . fun) -> fun


Builds a new function from the list of symbols or symbol-value pairs
lst and the functional expression fun. Each member in
lst that is a pat? symbol
is substituted inside fun by its value. All other symbols in
lst are collected into a job environment. curry is a general
higher-order function, not limited to strict currying (which generates only
single-argument functions).


: (de multiplier (@X)
   (curry (@X) (N) (* @X N)) )
-> multiplier
: (multiplier 7)
-> ((N) (* 7 N))
: ((multiplier 7) 3)
-> 21

: (def 'fiboCounter
   (curry ((N1 . 0) (N2 . 1)) (Cnt)
      (do Cnt
         (println
            (prog1
               (+ N1 N2)
               (setq N1 N2  N2 @) ) ) ) ) )
-> fiboCounter
: (pp 'fiboCounter)
(de fiboCounter (Cnt)
   (job '((N2 . 1) (N1 . 0))
      (do Cnt
         (println
            (prog1 (+ N1 N2) (setq N1 N2 N2 @)) ) ) ) )
-> fiboCounter
: (fiboCounter 5)
1
2
3
5
8
-> 8
: (fiboCounter 5)
13
21
34
55
89
-> 89




(cut 'cnt 'var) -> lst


Pops the first cnt elements (CAR) from the stack in
var. See also pop,
rid and del.


: (setq S '(1 2 3 4 5 6 7 8))
-> (1 2 3 4 5 6 7 8)
: (cut 3 'S)
-> (1 2 3)
: S
-> (4 5 6 7 8)








pil21/doc/refD.html0000644000000000000000000007330714641676070011233 0ustar  





D





D






*DB


A global variable holding the external symbol {1} (the database root) while a database is open, otherwise
NIL. All external symbols in a database can be reached from that
root. Except during debugging, any explicit literal access to symbols in the
database should be avoided, because otherwise a memory leak might occur (The
garbage collector temporarily sets *DB to NIL and
restores its value after collection, thus disposing of all external symbols not
currently used in the program).


: (show *DB)
{1} NIL
   +City {P}
   +Person {3}
-> {1}
: (show '{P})
{P} NIL
   nm (566 . {AhDx})
-> {P}
: (show '{3})
{3} NIL
   tel (681376 . {Agyl})
   nm (1461322 . {2gu7})
-> {3}




*Dbg


A boolean variable indicating "debug mode". It can be conveniently switched
on with a trailing + command line argument (see Invocation). When non-NIL, the $ (tracing) and ! (breakpoint) functions are enabled, and the
current line number and file name will be stored in symbol properties by
de, def, dm
and symbols. See also debug, trace and lint.


: (de foo (A B) (* A B))
-> foo
: (trace 'foo)
-> foo
: (foo 3 4)
 foo : 3 4
 foo = 12
-> 12
: (let *Dbg NIL (foo 3 4))
-> 12




*Dbs


A global variable holding a list of numbers (block size scale factors, as
needed by pool). It is typically set
by dbs.


: *Dbs
-> (1 2 1 0 2 3 3 3)




+Date


Class for calender dates (as calculated by date), a subclass of +Number. See also Database.


(rel dat (+Ref +Date))  # Indexed date




+Dep


+Joint prefix class for maintaining
dependencies between +relations.
Expects a list of (symbolic) attributes that depend on this relation. Whenever
this relations is cleared (receives a value of NIL), the dependent
relations will also be cleared, triggering all required side-effects. See also
Database.


In the following example, the index entry for the item pointing to the
position (and, therefore, to the order) is cleared in case the order is deleted,
or this position is deleted from the order:


(class +Pos +Entity)                # Position class
(rel ord (+Dep +Joint)              # Order of that position
   (itm)                               # 'itm' specifies the dependency
   pos (+Ord) )                        # Arguments to '+Joint'
(rel itm (+Ref +Link) NIL (+Item))  # Item depends on the order




(d) -> T


(Debug mode only) Inserts !
breakpoints into all subexpressions of the current breakpoint. Typically used
when single-stepping a function or method with debug. See also u and unbug.


! (d)                            # Debug subexpression(s) at breakpoint
-> T




(daemon 'sym . prg) -> fun


(daemon '(sym . cls) . prg) -> fun


(daemon '(sym sym2 [. cls]) . prg) -> fun


Inserts prg in the beginning of the function (first form), the
method body of sym in cls (second form) or in the
class obtained by getting
sym2 from *Class (or
cls if given) (third form). Built-in functions (SUBRs) are
automatically converted to Lisp expressions. See also trace, expr, patch and redef.


: (de hello () (prinl "Hello world!"))
-> hello

: (daemon 'hello (prinl "# This is the hello world program"))
-> (NIL (prinl "# This is the hello world program") (prinl "Hello world!"))
: (hello)
# This is the hello world program
Hello world!
-> "Hello world!"

: (daemon '* (msg 'Multiplying))
-> (@ (msg 'Multiplying) (pass $134532148))
: *
-> (@ (msg 'Multiplying) (pass $134532148))
: (* 1 2 3)
Multiplying
-> 6




(dat$ 'dat ['sym]) -> sym


Formats a date dat in
ISO format, with an optional delimiter character sym. See also
$dat, tim$, datStr and datSym.


: (dat$ (date))
-> "20070601"
: (dat$ (date) "-")
-> "2007-06-01"




(datStr 'dat ['flg]) -> sym


Formats a date according to the
current locale. If flg
is non-NIL, the year will be formatted modulo 100. See also
dat$, datSym, strDat, expDat, expTel and day.


: (datStr (date))
-> "2007-06-01"
: (locale "DE" "de")
-> NIL
: (datStr (date))
-> "01.06.2007"
: (datStr (date) T)
-> "01.06.07"




(datSym 'dat) -> sym


Formats a date dat in
symbolic format (DDmmmYY). See also dat$ and datStr.


: (datSym (date))
-> "01jun07"




(date ['T]) -> dat


(date 'dat) -> (y m d)


(date 'y 'm 'd) -> dat | NIL


(date '(y m d)) -> dat | NIL


Calculates a (gregorian) calendar date. It is represented as a day number,
starting first of March of the year 0 AD. When called without arguments, the
current date is returned. When called with a T argument, the
current Coordinated Universal Time (UTC) is returned. When called with a single
number dat, it is taken as a date and a list with the corresponding
year, month and day is returned. When called with three numbers (or a list of
three numbers) for the year, month and day, the corresponding date is returned
(or NIL if they do not represent a legal date). See also time, stamp, $dat, dat$, datSym, datStr, strDat, expDat, day, week and ultimo.


: (date)                         # Today
-> 730589
: (date 2000 6 12)               # 12-06-2000
-> 730589
: (date 2000 22 5)               # Illegal date
-> NIL
: (date (date))                  # Today's year, month and day
-> (2000 6 12)
: (- (date) (date 2000 1 1))     # Number of days since first of January
-> 163




(day 'dat ['lst]) -> sym


Returns the name of the day for a given date dat, in the language of the
current locale. If lst
is given, it should be a list of alternative weekday names. See also week, datStr and strDat.


: (day (date))
-> "Friday"
: (locale "DE" "de")
-> NIL
: (day (date))
-> "Freitag"
: (day (date) '("Mo" "Tu" "We" "Th" "Fr" "Sa" "Su"))
-> "Fr"




(db 'sym 'cls ['hook] 'any ['sym 'any ..]) -> sym | NIL


Returns a database object of class cls, where the values for
the sym arguments correspond to the any arguments. If
a matching object cannot be found, NIL is returned.
sym, cls and hook should specify a
tree for cls or one of
its superclasses. See also aux,
collect, request, fetch, init and step.


: (db 'nr '+Item 1)
-> {B1}
: (db 'nm '+Item "Main Part")
-> {B1}




db/3


db/4


db/5


Pilog database predicate that returns objects
matching the given key-value (and optional hook) relation. The relation should
be of type +index. For the key
pattern applies:


    

  • a symbol (string) returns all entries which start with that string

  • other atoms (numbers, external symbols) match as they are

  • cons pairs constitute a range, returning objects
   
      
   
    • in increasing order if the CDR is greater than the CAR
   
    • in decreasing order otherwise
   
    

  • other lists are matched for +Aux
key combinations




The optional hook can be supplied as the third argument. See also select/3 and remote/2.


: (? (db nr +Item @Item))              # No value given
 @Item={B1}
 @Item={B2}
 @Item={B3}
 @Item={B4}
 @Item={B5}
 @Item={B6}
-> NIL

: (? (db nr +Item 2 @Item))            # Get item no. 2
 @Item={B2}
-> NIL

: (? (db nm +Item Spare @Item) (show @Item))  # Search for "Spare.."
{B2} (+Item)
   pr 1250
   inv 100
   sup {C2}
   nm "Spare Part"
   nr 2
 @Item={B2}
-> NIL




(db: cls ..) -> num


Returns the database file number for objects of the type given by the
cls argument(s). Needed, for example, for the creation of new objects. See also dbs.


: (db: +Item)
-> 3




(dbSync 'obj) -> flg


Starts a database transaction, by trying to obtain a lock on the database root object *DB (or obj if given), and then
calling sync to synchronize with
possible changes from other processes. When all desired modifications to
external symbols are done, (commit
'upd) should be called. See also Database.


(let? Obj (rd)             # Get object?
   (dbSync)                # Yes: Start transaction
   (put> Obj 'nm (rd))     # Update
   (put> Obj 'nr (rd))
   (put> Obj 'val (rd))
   (commit 'upd) )         # Close transaction




(dbck ['cnt] 'flg) -> any


Performs a low-level integrity check of the current (or cnt'th)
database file, and returns NIL (or the number of blocks and symbols
if flg is non-NIL) if everything seems correct.
Otherwise, a string indicating an error is returned. As a side effect, possibly
unused blocks (as there might be when a rollback is done before committing newly allocated (new) external symbols) are appended to the free
list.


: (pool "db")
-> T
: (dbck)
-> NIL




(dbs . lst)


Initializes the global variable *Dbs. Each element in lst has a
number in its CAR (the block size scale factor of a database file, to be stored
in *Dbs). The CDR elements are either classes (so that objects of
that class are later stored in the corresponding file), or lists with a class in
the CARs and a list of relations in the CDRs (so that index trees for these
relations go into that file). See also pool.


(dbs
   (3 +Role +User +Sal (+User pw))              # 512 Prevalent objects
   (0 +Pos)                                     # A:64 Tiny objects
   (1 +Item +Ord)                               # B:128 Small objects
   (2 +CuSu)                                    # C:256 Normal objects
   (2 (+Role nm) (+User nm) (+Sal nm))          # D:256 Small indexes
   (4 (+CuSu nr plz tel mob))                   # E:1024 Normal indexes
   (4 (+CuSu nm))                               # F:1024
   (4 (+CuSu ort))                              # G:1024
   (4 (+Item nr sup pr))                        # H:1024
   (4 (+Item nm))                               # I:1024
   (4 (+Ord nr dat cus))                        # J:1024
   (4 (+Pos itm)) )                             # K:1024

: *Dbs
-> (3 0 1 2 2 4 4 4 4 4 4 4)
: (get '+Item 'Dbf)
-> (3 . 128)
: (get '+Item 'nr 'dbf)
-> (9 . 1024)




(de sym . any) -> sym


Assigns a definition to the sym argument, by setting its
VAL to the any argument. If the symbol has already
another value, a "redefined" message is issued. When the value of the global
variable *Dbg is non-NIL, the current
line number and file name (if any) are stored in the *Dbg property
of sym. de is the standard way to define a function.
See also def, dm and undef.


: (de foo (X Y) (* X (+ X Y)))  # Define a function
-> foo
: (foo 3 4)
-> 21

: (de *Var . 123)  # Define a variable value
: *Var
-> 123




(debug 'sym)


(debug 'sym 'cls)


(debug '(sym . cls))


(Debug mode only) Inserts a !
breakpoint function call at the beginning and all top-level expressions of the
function or method body of sym, to allow a stepwise execution.
Typing (d) at a breakpoint will also
debug the current subexpression, and (e)
will evaluate the current subexpression. The current subexpression is stored in
the global variable ^. See also
unbug, *Dbg, trace and lint.


: (de tst (N)                    # Define tst
   (println (+ 3 N)) )
-> tst
: (debug 'tst)                   # Set breakpoints
-> T
: (pp 'tst)
(de tst (N)
   (! println (+ 3 N)) )         # Breakpoint '!'
-> tst
: (tst 7)                        # Execute
(println (+ 3 N))                # Stopped at beginning of 'tst'
! (d)                            # Debug subexpression
-> T
!                                # Continue
(+ 3 N)                          # Stopped in subexpression
! N                              # Inspect variable 'N'
-> 7
!                                # Continue
10                               # Output of print statement
-> 10                            # Done
: (unbug 'tst)
-> T
: (pp 'tst)                      # Restore to original
(de tst (N)
   (println (+ 3 N)) )
-> tst




(-debug)


(Debug mode only) Command line frontend to debug. See also -trace.


$ ./pil --debug tst +




(dec 'num) -> num


(dec 'var ['num]) -> num


The first form returns the value of num decremented by 1. The
second form decrements the VAL of var by 1, or by
num. If the first argument is NIL, it is returned
immediately. (dec Num) is equivalent to (- Num 1) and
(dec 'Var) is equivalent to (set 'Var (- Var 1)). See
also inc and -.


: (dec -1)
-> -2
: (dec 7)
-> 6
: (setq N 7)
-> 7
: (dec 'N)
-> 6
: (dec 'N 3)
-> 3




(def 'sym 'any) -> sym


(def 'sym1 'sym2|cnt 'any) -> sym1


The first form assigns a definition to the first sym argument,
by setting its VAL's to any. The second form defines a
property value any for the first argument's sym2 key
(or the symbol value for zero). If any of these values existed and was changed
in the process, a "redefined" message is issued. When the value of the global
variable *Dbg is non-NIL, the current
line number and file name (if any) are stored in the *Dbg property
of sym. See also de and
dm.


: (def 'b '((X Y) (* X (+ X Y))))
-> b
: (def 'b 999)
# b redefined
-> b




(default var 'any ..) -> any


Stores new values any in the var arguments only if
their current values are NIL. Otherwise, their values are left
unchanged. In any case, the last var's value is returned.
default is used typically in functions to initialize optional
arguments.


: (de foo (A B)               # Function with two optional arguments
   (default  A 1  B 2)        # The default values are 1 and 2
   (list A B) )
-> foo
: (foo 333 444)               # Called with two arguments
-> (333 444)
: (foo 333)                   # Called with one arguments
-> (333 2)
: (foo)                       # Called without arguments
-> (1 2)




(del 'any 'var ['flg]) -> lst


Deletes any from the list in the value of var, and
returns the remaining list. If flg is NIL and
any is contained more than once in the value of var,
only the first occurrence is deleted. (del 'any 'var) is equivalent
to (set 'var (delete 'any var)). See also delete, rid, cut and pop.


: (setq S '((a b c) (d e f)))
-> ((a b c) (d e f))
: (del '(d e f) 'S)
-> ((a b c))
: (del 'b S)
-> (a c)




(delete 'any 'lst ['flg]) -> lst


Deletes any from lst. If flg is
NIL and any is contained more than once in
lst, only the first occurrence is deleted. See also delq, del, remove and insert.


: (delete 2 (1 2 3))
-> (1 3)
: (delete (3 4) '((1 2) (3 4) (5 6) (3 4)))
-> ((1 2) (5 6) (3 4))




delete/3


Pilog predicate that succeeds if deleting the
first argument from the list in the second argument is equal to the third
argument. See also delete and
member/2.


: (? (delete b (a b c) @X))
 @X=(a c)
-> NIL




(delq 'any 'lst ['flg]) -> lst


Deletes any from lst. If flg is
NIL and any is contained more than once in
lst, only the first occurrence is deleted. == is used for comparison (pointer equality). See
also delete, asoq, push1q, memq, mmeq and Comparing.


: (delq 'b '(a b c))
-> (a c)
: (delq (2) (1 (2) 3))
-> (1 (2) 3)




(dep 'cls) -> cls


(Debug mode only) Displays the "dependencies" of cls, i.e. the
tree of superclasses and the tree of subclasses. See also OO Concepts, methods, class, what, who, has and and can.


: (dep '+Number)           # Dependencies of '+Number'
   +relation               # Single superclass is '+relation'
+Number
   +Date                   # Subclasses are '+Date' and '+Time'
   +Time
-> +Number




(depth 'lst) -> (cnt1 . cnt2)


Returns the maximal (cnt1) and the average (cnt2)
"depth" of a tree structure as maintained by idx. The total number of nodes is stored in the
global variable @@. See also length and size.


: (off X)                                    # Clear variable
-> NIL
: (for N (1 2 3 4 5 6 7) (idx 'X N T))       # Build a degenerated tree
-> NIL
: X
-> (1 NIL 2 NIL 3 NIL 4 NIL 5 NIL 6 NIL 7)   # Only right branches
: (depth X)
-> (7 . 4)                                   # Depth is 7, average 4

: (balance 'X (1 2 3 4 5 6 7))               # Build a balanced tree
-> NIL
: (depth X)
-> (3 . 2)                                   # Depth is 3, average 2




(detach) -> pid | NIL


Detach the current process from its PicoLisp parent, and return the parent's
process ID. This causes the parent to "forget" this child process (freeing
resources like buffers and pipes), effectively disabling family IPC via tell. See also fork and kids.


: (unless (fork)
   (detach)
   (runAlone)
   (bye) )




(diff 'lst1 'lst2) -> lst


Returns the difference of list arguments, all elements of lst1
which are not in lst2. See also sect.


: (diff (1 2 3 4 5) (2 4))
-> (1 3 5)
: (diff (1 2 3) (1 2 3))
-> NIL




different/2


Pilog predicate that succeeds if the two
arguments are different. See also equal/2.


: (? (different 3 4))
-> T




(dir ['any] ['flg]) -> lst


Returns a list of all filenames in the directory any. Names
starting with a dot '.' are ignored, unless flg is
non-NIL. See also cd and
info.


: (filter '((F) (tail '(. c) (chop F))) (dir "@src/"))
-> ("main.c" "subr.c" "gc.c" "io.c" "big.c" "sym.c" "tab.c" "flow.c" ..




(dirname 'any) -> sym


Returns the directory part of a path name any. See also
basename and path.


: (dirname "a/b/c/d")
-> "a/b/c/"




(dm sym . fun|cls2) -> sym


(dm (sym . cls) . fun|cls2) -> sym


(dm (sym sym2 [. cls]) . fun|cls2) -> sym


Defines a method for the message sym in the current class,
implicitly given by the value of the global variable *Class, or - in the second form - for the
explicitly given class cls. In the third form, the class object is
obtained by getting sym2
from *Class (or cls if
given). If the method for that class existed and was changed in the process, a
"redefined" message is issued. If - instead of a method fun - a
symbol specifying another class cls2 is given, the method from that
class is used (explicit inheritance). When the value of the global variable *Dbg is non-NIL, the current line number
and file name (if any) are stored in the *Dbg property of
sym. See also OO Concepts, de, undef, class, rel, var, method, send and try.


: (dm start> ()
   (super)
   (mapc 'start> (: fields))
   (mapc 'start> (: arrays)) )

: (dm foo> . +OtherClass)  # Explicitly inherit 'foo>' from '+OtherClass'




(do 'flg|num ['any | (NIL 'any . prg) | (T 'any . prg) ..]) -> any


Counted loop with multiple conditional exits: The body is executed at most
num times (or never (if the first argument is NIL), or
an infinite number of times (if the first argument is T)). If a
clause has NIL or T as its CAR, the clause's second
element is evaluated as a condition and - if the result is NIL or
non-NIL, respectively - the prg is executed and the
result returned. Otherwise (if count drops to zero), the result of the last
expression is returned. See also loop
and for.


: (do 4 (printsp 'OK))
OK OK OK OK -> OK
: (do 4 (printsp 'OK) (T (= 3 3) (printsp 'done)))
OK done -> done




(doc ['sym1] ['sym2])


(Debug mode only) Opens a browser, and tries to display the reference
documentation for sym1. sym2 may be the name of a
browser. If not given, the value of the environment variable
BROWSER, or the w3m browser is tried. If
sym1 is NIL, the PicoLisp
Reference manual is opened. See also Function
Reference, docs and vi.


: (doc '+)  # Function reference
-> NIL
: (doc '+relation)  # Class reference
-> NIL
: (doc)  # Reference manual
-> NIL
:  (doc 'vi "firefox")  # Use alternative browser
-> NIL




(docs 'any)


(Debug mode only) Parses all files with names of the form "ref@.html" in the
directory any, to set the doc property for later calls
to doc.


: (docs "@doc/")
-> NIL




(download 'host 'src 'dst) -> any


Tries to download the file src from host with
"@bin/ssl", and stores it in dst. Returns non-NIL if
successful. See also ssl.


: (download "de.wikipedia.org" "static/images/wikimedia-button.png" "button.png")
-> 0
: (info "button.png")
-> (2426 736804 . 35589)








pil21/doc/refE.html0000644000000000000000000004675114736305505011234 0ustar  





E





E






*Err


A global variable holding a (possibly empty) prg body, which
will be executed during error processing. See also Error Handling, *Msg and ^.


: (de *Err (prinl "Fatal error!"))
-> *Err
: (/ 3 0)
!? (/ 3 0)
Div/0
Fatal error!
?




*Ext


A global variable holding a sorted list of cons pairs. The CAR of each pair
specifies an external symbol offset (suitable for ext), and the CDR should be a function taking a
single external symbol as an argument. This function should return a list, with
the value for that symbol in its CAR, and the property list (in the format used
by getl and putl) in its CDR. The symbol will be set to
this value and property list upon access. Typically this function will access
the corresponding symbol in a remote database process. See also qsym and external symbols.


### On the local machine ###
: (setq *Ext  # Define extension functions
   (mapcar
      '((@Host @Ext)
         (cons @Ext
            (curry (@Host @Ext (Sock)) (Obj)
               (when (or Sock (setq Sock (connect @Host 4040)))
                  (ext @Ext
                     (out Sock (pr (cons 'qsym Obj)))
                     (prog1
                        (in Sock (rd))
                        (unless @
                           (close Sock)
                           (off Sock) ) ) ) ) ) ) )
      '("10.10.12.1" "10.10.12.2" "10.10.12.3" "10.10.12.4")
      (20 40 60 80) ) )

### On the remote machines ###
(de go ()
   ...
   (task (port 4040)                      # Set up background query server
      (let? Sock (accept @)               # Accept a connection
         (unless (fork)                   # In child process
            (in Sock
               (while (rd)                # Handle requests
                  (sync)
                  (tell)
                  (out Sock
                     (pr (eval @)) ) ) )
            (bye) )                       # Exit child process
         (close Sock) ) )
   ...





+Entity


Base class of all database objects. See also +relation and Database.


Messages to entity objects include


zap> ()              # Clean up relational structures, for removal from the DB
url> (Tab)           # Call the GUI on that object (in optional Tab)
gui> ()              # Generate object-specific GUI fragment
upd> (X Old)         # Callback method when object is created/modified/deleted
has> (Var Val)       # Check if value is present
rel?> (Var Val)      # Check if relations for value are correctly maintained
put> (Var Val)       # Put a new value
put!> (Var Val)      # Put a new value, single transaction
del> (Var Val)       # Delete value (also partial)
del!> (Var Val)      # Delete value (also partial), single transaction
inc> (Var Val)       # Increment numeric value
inc!> (Var Val)      # Increment numeric value, single transaction
dec> (Var Val)       # Decrement numeric value
dec!> (Var Val)      # Decrement numeric value, single transaction
mis> (Var Val)       # Return error message if value or type mismatch
lose1> (Var)         # Delete relational structures for a single attribute
lose> (Lst)          # Delete relational structures (excluding 'Lst')
lose!> ()            # Delete relational structures, single transaction
keep1> (Var)         # Restore relational structures for single attribute
keep> (Lst)          # Restore relational structures (excluding 'Lst')
keep?> (Lst)         # Test for restauration (excluding 'Lst')
keep!> ()            # Restore relational structures, single transaction
set> (Val)           # Set the value (type, i.e. class list)
set!> (Val)          # Set the value, single transaction
clone> ()            # Object copy
clone!> ()           # Object copy, single transaction




(e . prg) -> any


Used in a breakpoint. Evaluates prg in the execution
environment, or the currently executed expression if prg is not
given. See also debug, !, ^ and
*Dbg.


: (! + 3 4)
(+ 3 4)
! (e)
-> 7




(echo ['cnt ['cnt]] | ['sym ..]) -> sym


Reads the current input channel, and writes to the current output channel.
If cnt is given, only that many bytes are actually echoed. In case
of two cnt arguments, the first one specifies the number of bytes
to skip in the input stream. Otherwise, if one or more sym
arguments are given, the echo process stops as soon as one of the symbol's names
is encountered in the input stream. In this case the name will be read and
returned, but not written. Returns non-NIL if the operation was
successfully completed. See also from.


: (in "x.l" (echo))  # Display file on console
 ..

: (out "x2.l" (in "x.l" (echo)))  # Copy file "x.l" to "x2.l"




(enum 'var 'cnt ['cnt ..]) -> lst


(enum 'var) -> lst


Enumerates cells by maintaining a binary tree in var. The keys
are implicit from the enumerated cnts, and the resulting tree is
balanced (independent from the insertion order). In the first form, the
corresponding cell is returned. If it does not exist yet, it is (destructively)
inserted into the tree. If more than one cnt argument is given, the
returned cell is subsequently taken as the next tree to be processed. The second
form returns an unsorted association list of all key-value pairs in the tree.
enum can be used to emulate (possibly sparse) arrays. See also
enum?, idx and hash.


: (for (I . S) '(a b c d e f g h i j k l m n o)
   (set (enum 'E I) S) )
-> o
: E
-> (a (b (d (h) l) f (j) n) c (e (i) m) g (k) o)
: (view E T)
         o
      g
         k
   c
         m
      e
         i
a
         n
      f
         j
   b
         l
      d
         h
-> NIL
: (enum 'E 6)
-> (f (j) n)
: (val (enum 'E 6))
-> f
: (val (enum 'E 1))
-> a
: (val (enum 'E 12))
-> l
: (enum 'E)
-> ((8 . h) (4 . d) (12 . l) (2 . b) (10 . j) (6 . f) (14 . n) (1 . a) (9 . i) (5 . e) (13 . m) (3 . c) (11 . k) (7 . g) (15 . o))

: (let A NIL  # 2-dimensional array
   (for I 4
      (for J 4
         (set (enum 'A I J) (pack I "-" J)) ) )
   (for I 4
      (for J 4
         (prin " " (val (enum 'A I J))) )
      (prinl) ) )
 1-1 1-2 1-3 1-4
 2-1 2-2 2-3 2-4
 3-1 3-2 3-3 3-4
 4-1 4-2 4-3 4-4
-> NIL




(enum? 'lst 'cnt ['cnt ..]) -> lst | NIL


Tests a binary enum tree for the
keys in the cnt arguments. Returns the corresponding cell, or
NIL if not found. The tree is not modified. See also lup.


: (enum? E 7)
-> (g (k) o)
: (enum? E 16)
-> NIL




(env ['lst] | ['sym 'val] ..) -> lst


Return a list of symbol-value pairs of all dynamically bound symbols if
called without arguments, or of the symbols or symbol-value pairs in
lst, or the explicitly given sym-val
arguments. See also bind, job, trail and up.


: (env)
-> NIL
: (let (A 1 B 2) (env))
-> ((A . 1) (B . 2))
: (let (A 1 B 2) (env '(A B)))
-> ((B . 2) (A . 1))
: (let (A 1 B 2) (env 'X 7 '(A B (C . 3)) 'Y 8))
-> ((Y . 8) (C . 3) (B . 2) (A . 1) (X . 7))




(eof ['flg]) -> flg


Returns the end-of-file status of the current input channel. If
flg is non-NIL, the channel's status is forced to
end-of-file, so that the next call to eof will return
T, and calls to char,
peek, line, from, till, read or skip will return NIL. Note that
eof cannot be used with the binary rd function. See also eol.


: (in "file" (until (eof) (println (line T))))
...




(eol) -> flg


Returns the end-of-line status of the current input channel.
See also eof.


: (make (until (prog (link (read)) (eol))))  # Read line into a list
a b c (d e f) 123
-> (a b c (d e f) 123)




equal/2


Pilog predicate that succeeds if the two
arguments are equal. See also =, different/2 and member/2.


: (? (equal 3 4))
-> NIL
: (? (equal @N 7))
 @N=7
-> NIL




(err 'sym . prg) -> any


Redirects the standard error stream to sym during the execution
of prg. The current standard error stream will be saved and
restored appropriately. If the argument is NIL, the current output
stream will be used. Otherwise, sym is taken as a file name (opened
in "append" mode if the first character is "+"), where standard error is to be
written to. See also in, out and ctl.


: (err "/dev/null"             # Suppress error messages
   (call 'ls 'noSuchFile) )
-> NIL




(errno) -> cnt


Returns the value of the standard I/O 'errno' variable. See also native.


: (in "foo")                           # Produce an error
!? (in "foo")
"foo" -- Open error: No such file or directory
? (errno)
-> 2                                   # Returned 'ENOENT'




(eval 'any ['cnt]) -> any


Evaluates any. Note that because of the standard argument
evaluation, any is actually evaluated twice. If an offset
cnt is given, the value of @ in the cnt'th call environment
is used during the second evaluation. cnt should be greater than
zero. See also run and up.


: (eval (list '+ 1 2 3))
-> 6
: (setq X 'Y  Y 7)
-> 7
: X
-> Y
: Y
-> 7
: (eval X)
-> 7




(exec 'any ..)


Executes an external system command. The any arguments specify
the command and its arguments. Does not return to the caller; the current
process is replaced with a new process image. See also fork and call.


: (pipe (exec 'echo 123 "abc")  # Equivalent to (in '(echo 123 "abc") ..)
   (list (read) (read)) )
-> (123 abc)

(unless (fork)
   (exec "@bin/ssl"  # Start replication process
      "10.11.12.13" 443
      "app/!replica" "key/app" "fifo/app" "db/app/blob/" 20 ) )




(expDat 'sym) -> dat


Expands a date string according to
the current locale (delimiter, and
order of year, month and day). Accepts abbreviated input, without delimiter and
with only the day, or the day and month, or the day, month and year of current
century. A single dot "." expands to "today", and a signed number to a date such
many days in the past or future. See also datStr, day, expTel.


: (date)
-> 733133
: (date (date))
-> (2007 5 31)
: (expDat "31")
-> 733133
: (expDat "315")
-> 733133
: (expDat "3105")
-> 733133
: (expDat "31057")
-> 733133
: (expDat "310507")
-> 733133
: (expDat "2007-05-31")
-> 733133
: (expDat "7-5-31")
-> 733133

: (locale "DE" "de")
-> NIL
: (expDat "31.5")
-> 733133
: (expDat "31.5.7")
-> 733133




(expTel 'sym) -> sym


Expands a telephone number string. Multiple spaces or hyphens are coalesced.
A leading + or 00 is removed, a leading national trunk
prefix is replaced with the current country code. Otherwise, NIL is
returned. See also telStr, expDat and locale.


: (expTel "+49 1234 5678-0")
-> "49 1234 5678-0"
: (expTel "0049 1234 5678-0")
-> "49 1234 5678-0"
: (expTel "01234 5678-0")
-> NIL
: (locale "DE" "de")
-> NIL
: (expTel "01234 5678-0")
-> "49 1234 5678-0"




(export ['sym]) sym|lst


Intern symbols explicitly in the second namespace in the current search order, or
in the given namespace if sym is given.
(export) expects a single symbol or a list of symbols
immediately following in the current input stream. See also pico, symbols, private, local, import and intern.


: (symbols 'myLib 'pico)
-> (pico)
myLib: (export) (foo bar)  # Intern 'foo' and 'bar' in 'pico'




(expr 'sym) -> fun


Converts a built-in function (SUBR) to a Lisp-function. Useful only for
normal functions (i.e. functions that evaluate all arguments). See also subr.


: car
-> 67313448
: (expr 'car)
-> (@ (pass $385260187))
: (car (1 2 3))
-> 1




(ext 'cnt . prg) -> any


During the execution of prg, all external symbols processed by rd, pr,
plio,
blk or udp are modified by an offset cnt
suitable for mapping via the *Ext
mechanism. All external symbol's file numbers are decremented by
cnt during output, and incremented by cnt during
input.


: (out 'a (ext 5 (pr '({A2} ({C4} . a) ({B7} . b)))))
-> ({A2} ({C4} . a) ({B7} . b))

: (in 'a (rd))
-> ({OOOL2} ({OOON4} . a) ({OOOM7} . b))

: (in 'a (ext 5 (rd)))
-> ({A2} ({C4} . a) ({B7} . b))




(ext? 'any ['flg]) -> sym | NIL


Returns the argument any when it is an external symbol,
otherwise NIL. If flg is non-NIL, also
physical existence is checked. See also sym?, box?, str?, extern and lieu.


: (ext? *DB)
-> {1}
: (ext? 'abc)
-> NIL
: (ext? "abc")
-> NIL
: (ext? 123)
-> NIL




(extend cls) -> cls


Extends the class cls, by storing it in the global variable
*Class. As a consequence, all
following method, relation and class variable definitions are applied to that
class. See also OO Concepts, class, dm, var,
rel, type and isa.





(extern 'sym) -> sym | NIL


Creates or finds an external symbol. If a symbol with the name
sym is already extern, it is returned. Otherwise, a new external
symbol is returned. NIL is returned if sym does not
exist in the database. See also intern and ext?.


: (extern "A1b")
-> {A1b}
: (extern "{A1b}")
-> {A1b}




(extra ['any ..]) -> any


Can only be used inside methods. Sends the current message to the current
object This, this time starting the search for a method at the
remaining branches of the inheritance tree of the class where the current method
was found. See also OO Concepts, super, method, meth, send and try.


(dm key> (C)            # 'key>' method of the '+Uppc' class
   (uppc (extra C)) )   # Convert 'key>' of extra classes to upper case




(extract 'fun 'lst ..) -> lst


Applies fun to each element of lst. When
additional lst arguments are given, their elements are also passed
to fun. Returns a list of all non-NIL values returned
by fun. (extract 'fun 'lst) is equivalent to
(mapcar 'fun (filter 'fun 'lst)) or, for non-NIL results, to
(mapcan '((X) (and (fun X) (cons @))) 'lst). See also filter, find, pick and mapcan.


: (setq A NIL  B 1  C NIL  D 2  E NIL  F 3)
-> 3
: (filter val '(A B C D E F))
-> (B D F)
: (extract val '(A B C D E F))
-> (1 2 3)








pil21/doc/refF.html0000644000000000000000000005521414516411700011216 0ustar  





F





F






*Fork


A global variable holding a (possibly empty) prg body, to be
executed after a call to fork in the
child process.


: (push '*Fork '(off *Tmp))   # Clear '*Tmp' in child process
-> (off *Tmp)




+Fold


Prefix class for maintaining folded indexes to +String relations. Typically used in
combination with the +Ref or +Idx prefix classes. See also +IdxFold and Database.


(rel nm (+Fold +Idx +String))   # Item Description
...
(rel tel (+Fold +Ref +String))  # Phone number




(fail) -> lst


Constructs an empty Pilog query, i.e. a query
that will always fail. See also goal.


(dm clr> ()                # Clear query chart in search dialogs
   (query> This (fail)) )




fail/0


Pilog predicate that always fails. See also
true/0.


: (? (fail))
-> NIL




(fd ['cnt]) -> cnt


Return the current file descriptor, typically of the closest in or out channel. If a second file descriptor
cnt is given, the current file descriptor is copied to it using a
dup2() system call. See also ipid and opid.


: (in "@lib.l" (fd))
-> 3




(fetch 'tree 'any) -> any


Fetches a value for the key any from a database tree. See also
tree and store.


: (fetch (tree 'nr '+Item) 2)
-> {B2}




(fifo 'var ['any ..]) -> any


Implements a first-in-first-out structure using a circular list. When called
with any arguments, they will be concatenated to end of the
structure. Otherwise, the first element is removed from the structure and
returned. See also queue, push, pop, rid, rot and circ.


: (fifo 'X 1)
-> 1
: (fifo 'X 2 3)
-> 3
: X
-> (3 1 2 .)
: (fifo 'X)
-> 1
: (fifo 'X)
-> 2
: X
-> (3 .)




(file) -> (sym1 sym2 . num) | NIL


Returns for the current input channel the path name sym1, the
file name sym2, and the current line number num. If
the current input channel is not a file, NIL is returned. See also
info, in and load.


: (load (pack (car (file)) "localFile.l"))  # Load a file in same directory




(fill 'any ['sym|lst]) -> any


(fill 'any ['cnt|sym] 'any2) -> any


Non-destructively fills a pattern any, by substituting
sym, or all symbols in lst, or - if no second argument
is given - each pattern symbol in any (see pat?), with its current value. @
itself is not considered a pattern symbol here. In any case, expressions
following the symbol ^ are evaluated and the results
(destructively) spliced into the result. In the second form, all occurrences of
the second argument are simply replaced by any2. In both cases,
unmodified subexpressions are shared.

See also match.


: (setq  @X 1234  @Y (1 2 3 4))
-> (1 2 3 4)
: (fill '@X)
-> 1234
: (fill '(a b (c @X) ((@Y . d) e)))
-> (a b (c 1234) (((1 2 3 4) . d) e))
: (let X 2 (fill (1 X 3) 'X))
-> (1 2 3)

: (fill (1 ^(list 'a 'b 'c) 9))
-> (1 a b c 9)
: (fill (1 ^(+ 2 3) 7))
-> (1 5 7)

: (fill (1 (a (b . 2) c) 3) 'b 7)
-> (1 (a (7 . 2) c) 3)
: (fill (1 (a (b . 2) c) 3) 2 123)
-> (1 (a (b . 123) c) 3)

: (match '(This is @X) '(This is a pen))
-> T
: (fill '(Got ^ @X))
-> (Got a pen)




(filter 'fun 'lst ..) -> lst


Applies fun to each element of lst. When
additional lst arguments are given, their elements are also passed
to fun. Returns a list of all elements of lst where
fun returned non-NIL. See also fish, find, pick and extract.


: (filter num? (1 A 2 (B) 3 CDE))
-> (1 2 3)
: (filter < (2 9 3 8 4 7) (5 4 3 9 9 5))
-> (2 8 4)
: (filter and (1 NIL 3 NIL 5) (2 3 4 5 6) (7 8 NIL 1 1))
-> (1 5)
: (filter and (range 1 22) '(NIL NIL T .))
-> (3 6 9 12 15 18 21)




(fin 'any) -> num|sym


Returns any if it is an atom, otherwise the CDR of its last
cell. See also last and tail.


: (fin 'a)
-> a
: (fin '(a . b))
-> b
: (fin '(a b . c))
-> c
: (fin '(a b c))
-> NIL




(finally exe . prg) -> any


prg is executed, then exe is evaluated, and the
result of prg is returned. exe will also be evaluated
if prg does not terminate normally due to a runtime error or a call
to throw. See also bye, catch, quit and Error
Handling.


: (finally (prinl "Done!")
   (println 123)
   (quit)
   (println 456) )
123
Done!
: (catch 'A
   (finally (prinl "Done!")
      (println 1)
      (throw 'A 123)
      (println 2) ) )
1
Done!
-> 123




(find 'fun 'lst ..) -> any


Applies fun to successive elements of lst until
non-NIL is returned. Returns that element (and stores the
non-NIL value in the global variable @@), or NIL if fun did
not return non-NIL for any element of lst. When
additional lst arguments are given, their elements are also passed
to fun. See also seek,
pick, fully and filter.


: (find pair (1 A 2 (B) 3 CDE))
-> (B)
: (find '((A B) (> A B)) (1 2 3 4 5 6) (6 5 4 3 2 1))
-> 4
: (find > (1 2 3 4 5 6) (6 5 4 3 2 1))  # shorter
-> 4





(finish . prg) -> exe


Pushes the expressions in prg into the global *Bye in reverse order, to be executed just
before the termination of the PicoLisp interpreter. (finish (foo)
(bar)) is equivalent to (push '*Bye '(bar) '(foo)) See also
bye and once.


: (finish (call "rm" "myfile.tmp"))  # Remove a temporary file
-> (call 'rm "myfile.tmp")




(fish 'fun 'any ['any2] ..) -> lst


Applies fun to each element - and recursively to all sublists -
of any. Returns a list of all items where fun returned
non-NIL. If any2 is non-NIL, it may be
returned by fun to cause the corresponding item or (sub-)list to be
skipped. When additional any arguments are given, they are also
passed to fun. See also seek,

See also filter.


: (fish atom '((a b) c (d e)))
-> (a b c d e)
: (fish sym? '(a -2 (1 b (-3 c 2)) 3 d -1 7))
-> (a b c d)
: (fish gt0 '(a -2 (1 b (-3 c 2)) 3 d -1 7))
-> (1 2 3 7)
: (fish < '(a -2 (1 b (-3 c 2)) 3 d -1 7) NIL 2)
-> (-2 1 -3 -1)
: (fish
   '((X)
      (if (and (pair X) (=1 (car X)))
         "skip"  # Transient symbol (pointer equal)
         (gt0 X) ) )
   '(a -2 (1 b (-3 c 2)) 3 d -1 7)
   "skip" )
-> (3 7)
: (fish == '(a 1 (b (3 b)) 3) NIL 'b)
-> (b b)




(flg? 'any) -> flg


Returns T when the argument any is either
NIL or T. See also bool. (flg? X) is equivalent to
(or (not X) (=T X)).


: (flg? (= 3 3))
-> T
: (flg? (= 3 4))
-> T
: (flg? (+ 3 4))
-> NIL




(flip 'lst ['cnt]) -> lst


Returns lst (destructively) reversed. Without the optional
cnt argument, the whole list is flipped, otherwise only the first
cnt elements. See also reverse and rot.


: (flip (1 2 3 4))         # Flip all  four elements
-> (4 3 2 1)
: (flip (1 2 3 4 5 6) 3)   # Flip only the first three elements
-> (3 2 1 4 5 6)




(flood 'lst1 'fun 'lst2) -> lst


Implements a flooding algorithm, returning a list of flooded nodes of a
graph. lst1 is a list of relevant nodes, fun a
function accepting a node and returning a list of connected nodes, and
lst2 a list of seed nodes.


(load "@lib/simul.l")

: (setq *Graph (1 2 3 4 5))         # For simplicity, a one-dimensional "graph"
-> (1 2 3 4 5)

: (simul~flood
   (maplist prog *Graph)            # List of relevant cells
   '((X)                            # Flood the three central cells (2 3 4)
      (when (member (car X) (2 3))  # 2 -> 3 and 3 -> 4
         (list (cdr X)) ) )
   (list (cddr *Graph)) )           # Seed third (middle) cell
-> ((3 4 5) (2 3 4 5) (4 5))        # -> Cells (3 ..) (2 ..) (4 ..)




(flush) -> flg


Flushes the current output stream by writing all buffered data. A call to
flush for standard output is done automatically before a call to
key. Returns T when
successful. See also rewind.


: (flush)
-> T




(fold 'any ['cnt]) -> sym


Folding to a canonical form: If any is not a symbol, it is
returned as it is. Otherwise, a new transient symbol with all digits and all
letters of any, converted to lower case, is returned. If the
cnt argument is given and non-zero, the result is truncated to that
length. See also lowc.


: (fold " 1A 2-b/3")
-> "1a2b3"
: (fold " 1A 2-B/3" 3)
-> "1a2"




fold/3


Pilog predicate that succeeds if the first
argument, after folding it to a
canonical form, is a prefix of the folded string representation of the
result of applying the get algorithm to
the following arguments. Typically used as filter predicate in select/3 database queries. See also
pre?, isa/2, same/3, bool/3, range/3, head/3, part/3 and tolr/3.


: (?
   @Nr (1 . 5)
   @Nm "main"
   (select (@Item)
      ((nr +Item @Nr) (nm +Item @Nm))
      (range @Nr @Item nr)
      (fold @Nm @Item nm) ) )
 @Nr=(1 . 5) @Nm="main" @Item={B1}
-> NIL




(for sym 'num ['any | (NIL 'any . prg) | (T 'any . prg) ..]) -> any


(for sym|(sym2 . sym) 'lst ['any | (NIL 'any . prg) | (T 'any . prg) ..]) -> any


(for (sym|(sym2 . sym) 'any1 'any2 [. prg]) ['any | (NIL 'any . prg) | (T 'any . prg) ..]) -> any


Conditional loop with local variable(s) and multiple conditional exits:

In the first form, the value of sym is saved, sym is
bound to 1, and the body is executed with increasing values up to
(and including) num.


In the second form, the value of sym is saved, sym is
subsequently bound to the elements of lst, and the body is executed
each time.


In the third form, the value of sym is saved, and sym
is bound to any1. If sym2 is given, it is treated as a
counter variable, first bound to 1 and then incremented for each execution of
the body. While the condition any2 evaluates to
non-NIL, the body is repeatedly executed and, if prg
is given, sym is re-bound to the result of its evaluation.


If a clause has NIL or T as its CAR, the clause's
second element is evaluated as a condition and - if the result is
NIL or non-NIL, respectively - the prg is
executed and the result returned. If the body is never executed,
NIL is returned.


See also do and loop.


# First form:
: (for N 5 (printsp N))
1 2 3 4 5 -> 5
: (for N 5 (printsp N) (NIL (< N 3) (printsp 'enough)))
1 2 3 enough -> enough
: (for N 5 (T (> N 3) (printsp 'enough)) (printsp N))
1 2 3 enough -> enough

# Second form:
: (for X (1 a 2 b) (printsp X))
1 a 2 b -> b
: (for (I . X) '(a b c) (println I X))
1 a
2 b
3 c
-> c

# Third form:
: (for (L (1 2 3 4 5) L) (printsp (pop 'L)))
1 2 3 4 5 -> 5
: (for (N 1 (>= 5 N) (inc N)) (printsp N))
1 2 3 4 5 -> 5
: (for ((I . L) '(a b c d e f) L (cddr L)) (println I L))
1 (a b c d e f)
2 (c d e f)
3 (e f)
-> (e f)




for/2


for/3


for/4


Pilog predicate that generates a sequence of
numbers. See also for and range.


: (? (for @I 3))
 @I=1
 @I=2
 @I=3
-> NIL

: (? (for @I 3 7))
 @I=3
 @I=4
 @I=5
 @I=6
 @I=7
-> NIL

: (? (for @I 7 3 2))
 @I=7
 @I=5
 @I=3
-> NIL

: (? (for @N T))
 @N=1
 @N=2
 @N=3
 ...




(forall 'cls . prg) -> any


(forall '(cnt . cls) . prg) -> any


Runs prg on all database objects of the class cls,
as given by the dbs definition. In the
second form, the cnt'th database file is used instead. The global
variable This is bound to each object.
See also seq and collect.


: (forall '+Item (println (: nr) (: nm)))
1 "Main Part"
2 "Spare Part"
3 "Auxiliary Construction"
4 "Enhancement Additive"
5 "Metal Fittings"
6 "Gadget Appliance"




(fork) -> pid | NIL


Forks a child process. Returns NIL in the child, and the
child's process ID pid in the parent. In the child, the
VAL of the global variable *Fork (should be a prg) is
executed. See also exec, detach, kids, pipe and tell.


: (unless (fork) (do 5 (println 'OK) (wait 1000)) (bye))
-> NIL
OK                                              # Child's output
: OK
OK
OK
OK




(format 'num ['cnt ['sym1 ['sym2]]]) -> sym


(format 'sym|lst ['cnt ['sym1 ['sym2]]]) -> num


Converts a number num to a string, or a string
sym|lst to a number. In both cases, optionally a precision
cnt, a decimal-separator sym1 and a
thousands-separator sym2 can be supplied. Returns
NIL if the conversion is unsuccessful. See also Numbers, pad, hex, oct, bin and round.


: (format 123456789)                   # Integer conversion
-> "123456789"
: (format 123456789 2)                 # Fixed point
-> "1234567.89"
: (format 123456789 2 ",")             # Comma as decimal-separator
-> "1234567,89"
: (format 123456789 2 "," ".")         # and period as thousands-separator
-> "1.234.567,89"

: (format "123456789")                 # String to number
-> 123456789
: (format (1 "23" (4 5 6)))
-> 123456
: (format "1234567.89" 4)              # scaled to four digits
-> 12345678900
: (format "1.234.567,89")              # separators not recognized
-> NIL
: (format "1234567,89" 4 ",")
-> 12345678900
: (format "1.234.567,89" 4 ",")        # thousands-separator not recognized
-> NIL
: (format "1.234.567,89" 4 "," ".")
-> 12345678900




(free 'cnt) -> (sym . lst)


Returns, for the cnt'th database file, the next available
symbol sym (i.e. the first symbol greater than any symbol in the
database), and the list lst of free symbols. See also seq, zap and dbck.


: (pool "x")      # A new database
-> T
: (new T)         # Create a new symbol
-> {2}
: (new T)         # Create another symbol
-> {3}
: (commit)        # Commit changes
-> T
: (zap '{2})      # Delete the first symbol
-> {2}
: (free 1)        # Show free list
-> ({4})          # {3} was the last symbol allocated
: (commit)        # Commit the deletion of {2}
-> T
: (free 1)        # Now {2} is in the free list
-> ({4} {2})




(from 'any ..) -> sym


Skips the current input channel until one of the strings any is
found, and starts subsequent reading from that point. The found any
argument (or NIL if none is found) is returned. See also till and echo.


: (and (from "val='") (till "'" T))
test val='abc'
-> "abc"




(full 'any) -> bool


Returns NIL if any is a non-empty list with at
least one NIL element, otherwise T. (full
X) is equivalent to (not (memq NIL X)). See also fully.


: (full (1 2 3))
-> T
: (full (1 NIL 3))
-> NIL
: (full 123)
-> T




(fully 'fun 'lst ..) -> flg


Applies fun to successive elements of lst, and
returns NIL immediately if one of the results is NIL.
Otherwise, T is returned. When additional lst
arguments are given, their elements are also passed to fun.
(fully foo Lst) is equivalent to (not (find '((X) (not (foo
X))) Lst)). See also find and
full.


: (fully gt0 (1 2 3))
-> T
: (fully gt0 (1 -2 3))
-> NIL




(fun 'fun ['any ..]) -> any


Applies fun to the any arguments. (fun foo
'args) is equivalent to (foo 'args), and (fun (expr)
'args) is equivalent to ((expr) 'args). See also apply and pass.


: (find fun '(sym? ((X) (> X 3)) num?) 'a)
-> sym?
: (find fun '(sym? ((X) (> X 3)) num?) 3)
-> num?
: (find fun '(sym? ((X) (> X 3)) num?) 4)
-> ((X) (> X 3))




(fun? 'any) -> any


Returns NIL when the argument any is neither a
number suitable for a code-pointer, nor a list suitable for a lambda expression
(function). Otherwise a number is returned for a code-pointer, T
for a function without arguments, and a single formal parameter or a list of
formal parameters for a function. See also getd.


: (fun? 1000000000)              # Might be a code pointer
-> 1000000000
: (fun? 10000000000000000000)    # Too big for a code pointer
-> NIL
: (fun? '((A B) (* A B)))        # Lambda expression
-> (A B)
: (fun? '((A B) (* A B) . C))    # Not a lambda expression
-> NIL
: (fun? '(1 2 3 4))              # Not a lambda expression
-> NIL
: (fun? '((A 2 B) (* A B)))      # Not a lambda expression
-> NIL








pil21/doc/refG.html0000644000000000000000000001474614516411737011236 0ustar  





G





G






(gc ['cnt [cnt2]]) -> cnt | NIL


Forces a garbage collection. When cnt is given, so many
megabytes of free cells are reserved, increasing the heap size if necessary. If
cnt is zero, all currently unused heap blocks are purged,
decreasing the heap size if possible. If cnt2 is given, the reserve
size (defaults to 1 megabyte) is set to that value. See also heap.


: (gc)
-> NIL
: (heap)
-> 2
: (gc 4)
-> 4
: (heap)
-> 5




(ge0 'any) -> num | NIL


Returns num when the argument is a number and greater or equal
zero, otherwise NIL. See also lt0, le0, gt0, =0
and n0.


: (ge0 -2)
-> NIL
: (ge0 3)
-> 3
: (ge0 0)
-> 0




(genKey 'sym 'cls ['hook ['num1 ['num2]]]) -> num


Generates a key for a database tree. If a minimal key num1
and/or a maximal key num2 is given, the next free number in that
range is returned. Otherwise, the current maximal key plus one is returned. See
also useKey, genStrKey and maxKey.


: (maxKey (tree 'nr '+Item))
-> 8
: (genKey 'nr '+Item)
-> 9




(genStrKey 'sym 'sym 'cls ['hook]) -> sym


Generates a unique string for a database tree, by prepending as many "# "
sequences as necessary. See also genKey.


: (genStrKey "ben" 'nm '+User)
-> "# ben"




(get 'sym1|lst ['sym2|cnt ..]) -> any


Fetches a value any from the properties of a symbol, or from a
list. From the first argument sym1|lst, values are retrieved in
successive steps by either extracting the value (if the next argument is zero)
or a property from a symbol, the CDR of an asoqed element (if the next argument is a
symbol), the n'th element (if the next argument is a positive number) or the
n'th CDR (if the next argument is a negative number) from a list. See also
put, ;, : and
nth.


: (put 'X 'a 1)
-> 1
: (get 'X 'a)
-> 1
: (put 'Y 'link 'X)
-> X
: (get 'Y 'link)
-> X
: (get 'Y 'link 'a)
-> 1
: (get '((a (b . 1) (c . 2)) (d (e . 3) (f . 4))) 'a 'b)
-> 1
: (get '((a (b . 1) (c . 2)) (d (e . 3) (f . 4))) 'd 'f)
-> 4
: (get '(X Y Z) 2)
-> Y
: (get '(X Y Z) 2 'link 'a)
-> 1




(getd 'any) -> fun | NIL


Returns fun if any is a symbol that has a function
definition, otherwise NIL. See also fun?.


: (getd '+)
-> 67327232
: (getd 'script)
-> ((File . @) (load File))
: (getd 1)
-> NIL

: ht:Fmt             # Initially undefined
-> NIL
: (getd 'ht:Fmt)     # Check shared library
-> 8790207171188
: ht:Fmt             # Now defined
-> 8790207171188




(getl 'sym1|lst1 ['sym2|cnt ..]) -> lst


Fetches the complete property list lst from a symbol. That
symbol is sym1 (if no other arguments are given), or a symbol found
by applying the get algorithm to
sym1|lst1 and the following arguments. See also putl and maps.


: (put 'X 'a 1)
-> 1
: (put 'X 'b 2)
-> 2
: (put 'X 'flg T)
-> T
: (getl 'X)
-> (flg (2 . b) (1 . a))




(glue 'any 'lst) -> sym


Builds a new transient symbol (string) by packing the any argument between
the individual elements of lst. See also text.


: (glue "," '(a b c d))
-> "a,b,c,d"




(goal '([pat 'any ..] . lst) ['sym 'any ..]) -> lst


Constructs a Pilog query list from the list of
clauses lst. The head of the argument list may consist of a
sequence of pattern symbols (Pilog variables) and expressions, which are used
together with the optional sym and any arguments to
form an initial environment. See also prove and fail.


: (goal '((likes John @X)))
-> (((1 (0) NIL ((likes John @X)) NIL T)))
: (goal '(@X 'John (likes @X @Y)))
-> (((1 (0) NIL ((likes @X @Y)) NIL ((0 . @X) 1 . John) T)))




(group 'lst) -> lst


Builds a list of lists, by grouping all elements of lst with
the same CAR into a common sublist. See also Comparing, by, sort and uniq.


: (group '((1 . a) (1 . b) (1 . c) (2 . d) (2 . e) (2 . f)))
-> ((1 a b c) (2 d e f))
: (by name group '("x" "x" "y" "z" "x" "z"))
-> (("x" "x" "x") ("y") ("z" "z"))
: (by length group '(123 (1 2) "abcd" "xyz" (1 2 3 4) "XY"))
-> ((123 "xyz") ((1 2) "XY") ("abcd" (1 2 3 4))




(gt0 'any) -> num | NIL


Returns num when the argument is a number and greater than
zero, otherwise NIL. See also lt0, le0, ge0, =0
and n0.


: (gt0 -2)
-> NIL
: (gt0 3)
-> 3








pil21/doc/refH.html0000644000000000000000000002426214526337355011235 0ustar  





H





H






*Hup


Global variable holding a (possibly empty) prg body, which will
be executed when a SIGHUP signal is sent to the current process. See also
alarm, sigio, *Winch, *Sig[12], *TStp[12] and *Term.


: (de *Hup (msg 'SIGHUP))
-> *Hup




+Hook


Prefix class for +relations,
typically +Link or +Joint. In essence, this maintains an local
database in the referred object. See also Database.


(rel sup (+Hook +Link) (+Sup))   # Supplier
(rel nr (+Key +Number) sup)      # Item number, unique per supplier
(rel dsc (+Ref +String) sup)     # Item description, indexed per supplier




+Hook2


Prefix class for +index
relations. It maintains both a normal (global) index, and an object-local index
in the corresponding +Hook object.
See also Database.


(rel nm (+Hook2 +IdxFold +String) 3 shop)       # Global and shop-local index




(h) -> flg


(Debug mode only) Edits the history in memory with Vip. Returns
T if Vip was exited with "x" and NIL if exited with
"q". See also history and vi.


: (h)    # Edit history
-> T     # "x"




(has 'any) -> lst


(Debug mode only) Returns a list of all internal symbols which have the
value any. See also who,
can, what and dep.


: +
-> 270310
: (has 270310)
-> (+ @)
: meth
-> 267259
: (has 267259)
-> (@ js> dec> inc> upd> ele> log> chk> val> del> rel> all> url> zap> clr> str> has>




(hash 'any) -> cnt


Generates a 16-bit number (1-65536) from any, suitable as a
hash value for various purposes, like randomly balanced idx structures. See also cache, enum, rev and seed.


: (hash 0)
-> 1
: (hash 1)
-> 55682
: (hash "abc")
-> 8986




(hax 'num) -> sym


(hax 'sym) -> num


Converts a number num to a string in hexadecimal/alpha
notation, or a hexadecimal/alpha formatted string to a number. The digits are
represented with '@' (zero) and the letters 'A' -
'O' (from "alpha" to "omega"). This format is used internally for
the names of external symbols.
See also hex, bin and oct.


: (hax 7)
-> "G"
: (hax 16)
-> "A@"
: (hax 255)
-> "OO"
: (hax "A")
-> 1




(hd 'sym ['cnt]) -> NIL


(Debug mode only) Displays a hexadecimal dump of the file given by
sym, limited to cnt lines. See also proc.


:  (hd "lib.l" 4)
00000000  23 20 32 33 64 65 63 30 39 61 62 75 0A 23 20 28  # 23dec09abu.# (
00000010  63 29 20 53 6F 66 74 77 61 72 65 20 4C 61 62 2E  c) Software Lab.
00000020  20 41 6C 65 78 61 6E 64 65 72 20 42 75 72 67 65   Alexander Burge
00000030  72 0A 0A 28 64 65 20 74 61 73 6B 20 28 4B 65 79  r..(de task (Key
-> NIL




(head 'cnt|lst 'lst) -> lst


Returns a new list made of the first cnt elements of
lst. If cnt is negative, it is added to the length of
lst. If the first argument is a lst, head
is a predicate function returning that argument list if it is equal
to the head of the second argument, and NIL otherwise. See also
tail and pre?.


: (head 3 '(a b c d e f))
-> (a b c)
: (head 0 '(a b c d e f))
-> NIL
: (head 10 '(a b c d e f))
-> (a b c d e f)
: (head -2 '(a b c d e f))
-> (a b c d)
: (head '(a b c) '(a b c d e f))
-> (a b c)




head/3


Pilog predicate that succeeds if the first
(string) argument is a prefix of the string representation of the result of
applying the get algorithm to the
following arguments. Typically used as filter predicate in select/3 database queries. See also
pre?, isa/2, same/3, bool/3, range/3, fold/3, part/3 and tolr/3.


: (?
   @Nm "Muller"
   @Tel "37"
   (select (@CuSu)
      ((nm +CuSu @Nm) (tel +CuSu @Tel))
      (tolr @Nm @CuSu nm)
      (head @Tel @CuSu tel) )
   (val @Name @CuSu nm)
   (val @Phone @CuSu tel) )
 @Nm="Muller" @Tel="37" @CuSu={C3} @Name="Miller" @Phone="37 4773 82534"
-> NIL




(heap 'flg) -> cnt


Returns the total size of the cell heap space in megabytes. If
flg is non-NIL, the size of the currently free space
is returned. See also stack and
gc.


: (gc 4)
-> 4
: (heap)
-> 5
: (heap T)
-> 4




(hear 'cnt) -> cnt


Uses the file descriptor cnt as an asynchronous command input
channel. Any executable list received via this channel will be executed in the
background. As this mechanism is also used for inter-family communication (see
tell), hear is usually
only called explicitly by a top level parent process.


: (call 'mkfifo "fifo/cmd")
-> T
: (hear (open "fifo/cmd"))
-> 3




(help 'sym ['flg]) -> sym


(Debug mode only) Dumps the reference documentation for sym to
the current output channel. If flg is non-NIL, the
examples are dumped too. See also Function Reference
and doc.


: (help 'car)
========================================
(car 'var) -> any

List access: Returns the value of var if it is a symbol, or the first element if
it is a list. See also cdr and c..r.

-> car

: (help 'car T)
========================================
(car 'var) -> any

List access: Returns the value of var if it is a symbol, or the first element if
it is a list. See also cdr and c..r.

: (car (1 2 3 4 5 6))
-> 1

-> car




(here ['sym]) -> sym


Echoes the current input stream until sym is encountered, or
until end of file. See also echo.


$ cat hello.l
(html 0 "Hello" "lib.css" NIL
   (<h2> NIL "Hello")
   (here) )
<p>Hello!</p>
<p>This is a test.</p>

$ pil @lib/http.l @lib/xhtml.l hello.l
HTTP/1.0 200 OK
Server: PicoLisp
Date: Sun, 03 Jun 2007 11:41:27 GMT
Cache-Control: max-age=0
Cache-Control: no-cache
Content-Type: text/html; charset=utf-8

<!DOCTYPE html>
<html lang="en">
<head>
<meta name="viewport" content="width=device-width"/>
<title>Hello</title>
<link rel="stylesheet" href="http://:/lib.css" type="text/css"/>
</head>
<body><h2>Hello</h2>
<p>Hello!</p>
<p>This is a test.</p>
</body></html>




(hex 'num ['num]) -> sym


(hex 'sym) -> num


Converts a number num to a hexadecimal string, or a hexadecimal
string sym to a number. In the first case, if the second argument
is given, the result is separated by spaces into groups of such many digits. See
also bin, oct, hax and format.


: (hex 273)
-> "111"
: (hex "111")
-> 273
: (hex 1234567 4)
-> "12 D687"




(history ['lst]) -> lst


When called without argument, history returns the current
readline(3) history. lst is a list of strings.
Otherwise, the history is set to lst. See also Invocation.


: (+ 1 2 3)
-> 6
: (history)
-> ("(+ 1 2 3)" "(history)")




(host 'any) -> sym


Returns the hostname corresponding to the given IP address. See also
*Adr.


: (host "80.190.158.9")
-> "www.leo.org"








pil21/doc/refI.html0000644000000000000000000004516414757535406011245 0ustar  





I





I






+Idx


Prefix class for maintaining non-unique full-text indexes to +String relations, a subclass of +Ref. Accepts optional arguments for the
minimally indexed substring length (defaults to 3), and a +Hook attribute. Often used in combination
with the +Sn soundex index, or the
+Fold index prefix classes. See also
Database.


(rel nm (+Sn +Idx +String))  # Name




+IdxFold


Prefix class for maintaining non-unique indexes to subsequent substrings of
the folded individual words of
+String relations. Accepts optional
arguments for the minimally indexed substring length (defaults to 3), and a
+Hook attribute. See also +Idx and Database.


(rel nm (+IdxFold +String))            # Item Description




+index


Abstract base class of all database B-Tree index relations (prefix classes
for +relations). The class
hierarchy includes +Key, +Ref, +Idx and +IdxFold. See also Database.


(isa '+index Rel)  # Check for an index relation




(id 'num ['num]) -> sym


(id 'sym [NIL]) -> num


(id 'sym T) -> (num . num)


Converts one (the internal block number) or two (file and block) numbers to
an external symbol, or an external symbol to a number or a pair of numbers.


: (id 7)
-> {7}
: (id 1 2)
-> {2}
: (id '{A2})
-> 2
: (id '{A2} T)
-> (2 . 2)




(idx 'var 'any 'flg) -> lst


(idx 'var 'any) -> lst


(idx 'var) -> lst


Maintains an index tree in var, and checks for the existence of
any. If any is contained in var, the
corresponding subtree is returned, otherwise NIL. In the first
form, any is destructively inserted into the tree if
flg is non-NIL (and any was not already
there), or deleted from the tree if flg is NIL. If all
elements are inserted in sorted order, the tree degenerates into a linear list.
In such cases, 0 may be passed for flg to randomize
the insertion order. The second form only checks for existence, but does not
change the index tree. In the third form (when called with a single
var argument) the contents of the tree are returned as a sorted
list.

See also lup, enum, hash, rev, depth, sort, balance and member.


: (idx 'X 'd T)                              # Insert data
-> NIL
: (idx 'X 2 T)
-> NIL
: (idx 'X '(a b c) T)
-> NIL
: (idx 'X 17 T)
-> NIL
: (idx 'X 'A T)
-> NIL
: (idx 'X 'd T)
-> (d (2 NIL 17 NIL A) (a b c))              # 'd' already existed
: (idx 'X T T)
-> NIL
: X                                          # View the index tree
-> (d (2 NIL 17 NIL A) (a b c) NIL T)
: (idx 'X 'A)                                # Check for 'A'
-> (A)
: (idx 'X 'B)                                # Check for 'B'
-> NIL
: (idx 'X)
-> (2 17 A d (a b c) T)                      # Get list
: (idx 'X 17 NIL)                            # Delete '17'
-> (17 NIL A)
: X
-> (d (2 NIL A) (a b c) NIL T)               # View it again
: (idx 'X)
-> (2 A d (a b c) T)                         # '17' is deleted

: (off X Y)
-> NIL
: (for I 9 (idx 'X I T))                     # Sorted insert order
-> NIL
: (for I 9 (idx 'Y I 0))                     # Randomize
-> NIL
: (view X T)
                        9
                     8
                  7
               6
            5
         4
      3
   2
1
-> NIL
: (view Y T)
         9
      8
         7
   6
      5
         4
3
   2
      1
-> NIL




(if 'any1 any2 . prg) -> any


Conditional execution: If the condition any1 evaluates to
non-NIL, any2 is evaluated and returned. Otherwise,
prg is executed and the result returned. See also ifn, cond, when and if2.


: (if (> 4 3) (println 'OK) (println 'Bad))
OK
-> OK
: (if (> 3 4) (println 'OK) (println 'Bad))
Bad
-> Bad




(if2 'any1 'any2 any3 any4 any5 . prg) -> any


Four-way conditional execution for two conditions: If both conditions
any1 and any2 evaluate to non-NIL,
any3 is evaluated and returned. Otherwise, any4 or
any5 is evaluated and returned if any1 or
any2 evaluate to non-NIL, respectively. If none of the
conditions evaluate to non-NIL, prg is executed and
the result returned. See also if and
cond.


: (if2 T T 'both 'first 'second 'none)
-> both
: (if2 T NIL 'both 'first 'second 'none)
-> first
: (if2 NIL T 'both 'first 'second 'none)
-> second
: (if2 NIL NIL 'both 'first 'second 'none)
-> none




(if@@ 'any1 any2 . prg) -> any


Conditional execution: If the value of the global variable @@ is non-NIL after the evaluation
of any1, any2 is evaluated and returned. Otherwise,
prg is executed and the result returned. In both cases, @ will hold the value of any1. See
also if and if2.


: (de foo (N)
   (if (lt0 N)
      (throw 'lt0 N)
      (sqrt N) ) )
-> foo

: (if@@ (catch 'lt0 (foo 64))
   (msg @ " negative")
   @ )
-> 8

: (if@@ (catch 'lt0 (foo -64))
   (msg @ " negative")
   @ )
-64 negative
-> -64




(ifn 'any1 any2 . prg) -> any


Conditional execution ("If not"): If the condition any1
evaluates to NIL, any2 is evaluated and returned.
Otherwise, prg is executed and the result returned. See also
if, nor, nand, unless and nond.


: (ifn (= 3 4) (println 'OK) (println 'Bad))
OK
-> OK




(import . lst) -> lst


Wrapper function for intern.
Typically used to import symbols from other namespaces, as created by symbols. lst should be
a list of symbols. See also pico, private and local and export.


: (import libA~foo libB~bar)
-> (foo bar)




(in 'any . prg) -> any


Opens any as input channel during the execution of
prg. The current input channel will be saved and restored
appropriately. If the argument is NIL, standard input is used. If
the argument is a symbol, it is used as a file name (opened in read-only mode).
If it is a positive number, it is used as the descriptor of an open file. If it
is a negative number, the saved input channel such many levels above the current
one is used. Otherwise (if it is a list), it is taken as a command with
arguments, and a pipe is opened for input. The (system dependent) exit status
code of the child process is stored in the global variable @@. See also out, err, fd, ipid, call, load, file, poll, pipe and ctl.


: (in "a" (list (read) (read) (read)))  # Read three items from file "a"
-> (123 (a b c) def)

: (in '(file "-b" "--mime" "bin/picolisp")  # Get the mime type
   (line T) )
-> "application/x-executable; charset=binary"




(inc 'num) -> num


(inc 'var ['num]) -> num


The first form returns the value of num incremented by 1. The
second form increments the VAL of var by 1, or by
num. If the first argument is NIL, it is returned
immediately. (inc Num) is equivalent to (+ Num 1) and
(inc 'Var) is equivalent to (set 'Var (+ Var 1)). See
also dec and +.


: (inc 7)
-> 8
: (inc -1)
-> 0
: (zero N)
-> 0
: (inc 'N)
-> 1
: (inc 'N 7)
-> 8
: N
-> 8

: (setq L (1 2 3 4))
-> (1 2 3 4)
: (inc (cdr L))
-> 3
: L
-> (1 3 3 4)




(inc! 'obj 'sym ['num]) -> num


Transaction wrapper function for inc. num defaults to 1. Note that
for incrementing a property value of an entity typically the inc!> message is used. See also
new!, request!, set! and put!.


(inc! Obj 'cnt 0)  # Incrementing a property of a non-entity object




(index 'any 'lst) -> cnt | NIL


Returns the cnt position of any in
lst, or NIL if it is not found. See also offset and sub?.


: (index 'c '(a b c d e f))
-> 3
: (index '(5 6) '((1 2) (3 4) (5 6) (7 8)))
-> 3




(info 'any ['flg]) -> (cnt|flg dat . tim)


Returns information about a file with the name any: The current
size cnt in bytes, and the modification date and time (UTC, or
local time if flg is zero). For directories, T is
returned instead of the size, and NIL for other non-regular files.
The file argument itself is stored in the global variable @@). If flg is non-NIL
and any is the name of a symbolic link, then the link itself is
used, not the file that it refers to. See also dir, date and time.


$ ls -l x.l
-rw-r--r--   1 abu      users         208 Jun 17 08:58 x.l
$ pil +
: (info "x.l")
-> (208 730594 . 32315)
: (stamp 730594 32315)
-> "2000-06-17 08:58:35"




(init 'tree ['any1] ['any2]) -> lst


Initializes a structure for stepping iteratively through a database tree.
any1 and any2 may specify a range of keys. If
any2 is greater than any1, the traversal will be in
opposite direction. See also tree,
step, iter and scan.


: (init (tree 'nr '+Item) 3 5)
-> (((3 . 5) ((3 NIL . {B3}) (4 NIL . {B4}) (5 NIL . {B5}) (6 NIL . {B6}))))




(input exe . prg) -> any


Establishes an input stream, by redirecting the current input channel during
the execution of prg. The current input channel will be saved and
restored appropriately. exe is executed (in the context of the
original input channel) whenever a character is required by read calls in
prg, and should return a single character upon each execution. See
also output, in and pipe.


: (input "A" (char))
-> "A"
: (let L (chop "(+ 2 (* 3 4))")
   (input (++ L) (read)) )
-> (+ 2 (* 3 4))
: (let L (chop "AQIDBAUGBw==")
   (input (++ L)
      (while (ext:Base64)
         (printsp @) ) ) )
1 2 3 4 5 6 7 -> 7




(insert 'cnt 'lst 'any) -> lst


Inserts any into lst at position cnt.
This is a non-destructive operation. See also remove, place, append, delete and replace.


: (insert 3 '(a b c d e) 777)
-> (a b 777 c d e)
: (insert 1 '(a b c d e) 777)
-> (777 a b c d e)
: (insert 9 '(a b c d e) 777)
-> (a b c d e 777)




(intern 'any ['nsp]) -> sym


Creates or finds an internal symbol. If a symbol with the name
any is already intern, it is returned. Otherwise, any
is interned in the current namespace
and returned. If nsp is non-NIL,
any is always interned in the current namespace (if
nsp is T) or in the given namespace, even if
it is found in other namespaces. See also symbols, zap, import and extern.


: (intern "abc")
-> abc
: (intern 'car)
-> car
: ((intern "car") (1 2 3))
-> 1
: ((intern '("c" "a" "r")) (1 2 3))
-> 1




(ipid) -> pid | NIL


Returns the corresponding process ID when the current input channel is
reading from a pipe, otherwise NIL. See also opid, in, pipe and load.


: (in '(ls "-l") (println (line T)) (kill (ipid)))
"total 7364"
-> T




(isa 'cls|typ 'obj) -> obj | NIL


Returns obj when it is an object that inherits from
cls or type. See also OO
Concepts, class, type, new and object.


: (isa '+Address Obj)
-> {A17}
: (isa '(+Male +Person) Obj)
-> NIL




isa/2


Pilog predicate that succeeds if the second
argument is of the type or class given by the first argument, according to the
isa function. Typically used in
db/3 or select/3 database queries. See also
same/3, bool/3, range/3, head/3, fold/3, part/3 and tolr/3.


: (? (db nm +Person @Prs) (isa +Woman @Prs) (val @Nm @Prs nm))
 @Prs={A44} @Nm="Alexandra of Denmark"
 @Prs={A124} @Nm="Alice Maud Mary"
 @Prs={A21} @Nm="Anne"
 @Prs={A57} @Nm="Augusta Victoria".  # Stop




(iter 'tree ['fun] ['any1] ['any2] ['flg]) -> NIL


Iterates through a database tree by applying fun to all values.
fun defaults to println. any1 and
any2 may specify a range of keys. If any2 is greater
than any1, the traversal will be in opposite direction. Note that
the keys need not to be atomic, depending on the application's index structure.
If flg is non-NIL, partial keys are skipped. See also
tree, ubIter, scan, init and step.


: (iter (tree 'nr '+Item))
{B1}
{B2}
{B3}
{B4}
{B5}
{B6}
-> NIL
: (iter (tree 'nr '+Item) '((This) (println (: nm))))
"Main Part"
"Spare Part"
"Auxiliary Construction"
"Enhancement Additive"
"Metal Fittings"
"Gadget Appliance"
"Testartikel"
-> NIL








pil21/doc/refJ.html0000644000000000000000000000526214516412104011217 0ustar  





J





J






+Joint


Class for bidirectional object relations, a subclass of +Link. Expects a (symbolic) attribute, a list
of classes as type of the referred
database object (of class +Entity),
and two optional functions called when 'put'ting and/or 'get'ting a value. A
+Joint corresponds to two +Links, where the attribute
argument is the relation of the back-link in the referred object. See also Database.


(class +Ord +Entity)                   # Order class
(rel pos (+List +Joint) ord (+Pos))    # List of positions in that order
...
(class +Pos +Entity)                   # Position class
(rel ord (+Joint) pos (+Ord))          # Back-link to the parent order




(job 'lst . prg) -> any


Executes a job within its own environment (as specified by symbol-value
pairs in lst). The current values of all symbols are saved, the
symbols are bound to the values in lst, prg is
executed, then the (possibly modified) symbol values are (destructively) stored
in the environment list, and the symbols are restored to their original values.
The return value is the result of prg. Typically used in curried functions and *Run tasks. See also env, bind, let, use and state.


: (de tst ()
   (job '((A . 0) (B . 0))
      (println (inc 'A) (inc 'B 2)) ) )
-> tst
: (tst)
1 2
-> 2
: (tst)
2 4
-> 4
: (tst)
3 6
-> 6
: (pp 'tst)
(de tst NIL
   (job '((A . 3) (B . 6))
      (println (inc 'A) (inc 'B 2)) ) )
-> tst




(journal ['T] 'any ..) -> T


Reads journal data from the files with the names any, and
writes all changes to the database. If the first argument is T, the
replication journal and transaction logs are disabled. See also pool.


: (journal "db.log")
-> T








pil21/doc/refK.html0000644000000000000000000000575214516412142011226 0ustar  





K





K






+Key


Prefix class for maintaining unique indexes to +relations, a subclass of +index. Accepts an optional argument for a
+Hook attribute. See also Database.


(rel nr (+Need +Key +Number))  # Mandatory, unique Customer/Supplier number




(key ['cnt ['var]]) -> sym


Returns the next character from standard input as a single-character
transient symbol. The console is set to raw mode. While waiting for a key press,
a poll(2) system call is executed for all file descriptors and
timers in the VAL of the global variable *Run. If cnt is
non-NIL, that amount of milliseconds is waited maximally, and
NIL is returned upon timeout. Otherwise, the remaining milliseconds
are optionally stored in var. See also raw and wait.


: (key)           # Wait for a key
-> "a"            # 'a' pressed




(kids) -> lst


Returns a list of process IDs of all running child processes. See also
fork, detach, pipe, tell, proc and kill.


: (unless (fork) (wait 60000) (bye))
-> NIL
: (unless (fork) (wait 60000) (bye))
-> NIL

: (proc 'pil)
  PID  PPID  STARTED  SIZE %CPU WCHAN  CMD
 2205 22853 19:45:24  1336  0.1 -      /usr/bin/picolisp /usr/lib/picolisp/lib.l /usr/bin/pil +
 2266  2205 19:45:30  1336  0.0 -        /usr/bin/picolisp /usr/lib/picolisp/lib.l /usr/bin/pil +
 2300  2205 19:45:33  1336  0.0 -        /usr/bin/picolisp /usr/lib/picolisp/lib.l /usr/bin/pil +
-> T

: (kids)
-> (2300 2266)




(kill 'pid ['cnt]) -> flg


Sends a signal with the signal number cnt (or SIGTERM if
cnt is not given) to the process with the ID pid.
Returns T if successful.


: (kill *Pid 20)                                # Stop current process

[2]+  Stopped               pil +               # Unix shell
$ fg                                            # Job control: Foreground
pil +
-> T                                            # 'kill' was successful








pil21/doc/refL.html0000644000000000000000000005155314723340605011233 0ustar  





L





L






+Link


Class for object relations, a subclass of +relation. Expects a list of classes as
type of the referred database object
(of class +Entity). See also Database.


(rel sup (+Ref +Link) NIL (+CuSu))  # Supplier (class Customer/Supplier)




+List


Prefix class for a list of identical relations. Objects of that class
maintain a list of Lisp data of uniform type. See also Database.


(rel pos (+List +Joint) ord (+Pos))  # Positions
(rel nm (+List +Ref +String))        # List of indexed strings
(rel val (+Ref +List +Number))       # Indexed list of numeric values




(last 'lst) -> any


Returns the last element of lst. See also fin and tail.


: (last (1 2 3 4))
-> 4
: (last '((a b) c (d e f)))
-> (d e f)




(later 'var . prg) -> var


Executes prg in a pipe'ed child process. The return value of
prg will later be available in var. Note that
later uses pr and rd to communicate the result, so prg
should not write any data to standard output as a side effect.


: (prog1  # Parallel background calculation of square numbers
   (mapcan '((N) (later (cons) (* N N))) (1 2 3 4))
   (wait NIL (full @)) )
-> (1 4 9 16)




(le0 'any) -> num | NIL


Returns num when the argument is a number less or equal zero,
otherwise NIL. See also lt0, ge0, gt0, =0
and n0.


: (le0 -2)
-> -2
: (le0 0)
-> 0
: (le0 3)
-> NIL




(leaf 'tree) -> any


Returns the first leaf (i.e. the value of the smallest key) in a database
tree. See also tree, minKey, maxKey and step.


: (leaf (tree 'nr '+Item))
-> {B1}
: (db 'nr '+Item (minKey (tree 'nr '+Item)))
-> {B1}




(length 'any) -> cnt | T


Returns the "length" of any. For numbers this is the number of
decimal digits in the value (plus 1 for negative values), for symbols it is the
number of characters in the name, and for lists it is the number of cells (or
T for circular lists). See also size and bytes.


: (length "abc")
-> 3
: (length "äbc")
-> 3
: (length 123)
-> 3
: (length (1 (2) 3))
-> 3
: (length (1 2 3 .))
-> T




(less 'any ['cnt]) -> any


Returns a reduced form of any, where for each list and its
sublists only the first cnt elements (default 4), possibly followed
by .., are retained.


: (less '(a b c d e f))
-> (a b c d ..)
: (less '((a b c) ((d e f g h i) (j k l m n))))
-> ((a b c) ((d e f ..) (j k ..)))
: (less '((a b c) ((d e f g h i) (j k l m n))) 2)
-> ((a b ..) ((d ..) ..))




(let sym 'any . prg) -> any


(let (sym|lst 'any ..) . prg) -> any


Defines local variables. The value of the symbol sym - or the
values of the symbols sym in the list of the second form - are
saved and the symbols are bound to the evaluated any arguments. The
lst arguments in the second form may consist only of symbols and
sublists, and match the any argument (destructuring bind).
prg is executed, then the symbols are restored to their original
values. The result of prg is returned. It is an error condition to
pass NIL as a sym argument. In destructuring patterns,
NIL denotes a "don't care" position. See also let?, bind, recur, with, for, job and use.


: (setq  X 123  Y 456)
-> 456
: (let X "Hello" (println X))
"Hello"
-> "Hello"
: (let (X "Hello" Y "world") (prinl X " " Y))
Hello world
-> "world"
: X
-> 123
: Y
-> 456

: (let (A 1  (B . C) (2 3)  D 4)
   (list A B C D) )
-> (1 2 (3) 4)

: (let (((A . B) (C) . D) '((1 2 3) (4 5 6) 7 8 9))
   (list A B C D) )
-> (1 (2 3) 4 (7 8 9))

: (let (((A . NIL) NIL NIL D) '((1 2 3) (4 5 6) 7 8 9))
   (trail T) )
-> (A 1 D 8)




(let? sym 'any . prg) -> any


Conditional local variable binding and execution: If any
evaluates to NIL, NIL is returned. Otherwise, the
value of the symbol sym is saved and sym is bound to
the evaluated any argument. prg is executed, then
sym is restored to its original value. The result of
prg is returned. It is an error condition to pass NIL
as the sym argument. (let? sym 'any ..) is equivalent
to (when 'any (let sym @ ..)). See also let, bind, job and use.


: (setq Lst (1 NIL 2 NIL 3))
-> (1 NIL 2 NIL 3)
: (let? A (pop 'Lst) (println 'A A))
A 1
-> 1
: (let? A (pop 'Lst) (println 'A A))
-> NIL




(lieu 'any) -> sym | NIL


Returns the argument any when it is an external symbol and
currently manifest in heap space, otherwise NIL. See also ext?.


: (lieu *DB)
-> {1}




(line 'flg ['cnt ..]) -> lst|sym


Reads a line of characters from the current input channel. End of line is
recognized as linefeed (hex "0A"), carriage return (hex "0D"), or the
combination of both. (Note that a single carriage return may not work on network
connections, because the character look-ahead to distinguish from
return+linefeed can block the connection.) If flg is
NIL, a list of single-character transient symbols is returned. When
cnt arguments are given, subsequent characters of the input line
are grouped into sublists, to allow parsing of fixed field length records. If
flg is non-NIL, strings are returned instead of
single-character lists. NIL is returned upon end of file. See also
char, read, till and eof.


: (line)
abcdefghijkl
-> ("a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l")
: (line T)
abcdefghijkl
-> "abcdefghijkl"
: (line NIL 1 2 3)
abcdefghijkl
-> (("a") ("b" "c") ("d" "e" "f") "g" "h" "i" "j" "k" "l")
: (line T 1 2 3)
abcdefghijkl
-> ("a" "bc" "def" "g" "h" "i" "j" "k" "l")




(link 'any ..) -> any


Links one or several new elements any to the end of the list in
the current make environment. This
operation is efficient also for long lists, because a pointer to the last
element of the list is maintained. link returns the last linked
argument. See also yoke, chain and made.


: (make
   (println (link 1))
   (println (link 2 3)) )
1
3
-> (1 2 3)




(lint 'sym) -> lst


(lint 'sym 'cls) -> lst


(lint '(sym . cls)) -> lst


(Debug mode only) Checks the function definition or file contents (in the
first form), or the method body of sym (second and third form), for possible
pitfalls. Returns an association list of diagnoses, where var
indicates improper variables, dup duplicate parameters,
def an undefined function, bnd an unbound variable,
and use unused variables. See also noLint, lintAll, debug, trace and *Dbg.


: (de foo (R S T R)     # 'T' is an improper parameter, 'R' is duplicated
   (let N 7             # 'N' is unused
      (bar X Y) ) )     # 'bar' is undefined, 'X' and 'Y' are not bound
-> foo
: (lint 'foo)
-> ((var T) (dup R) (def bar) (bnd Y X) (use N))




(lintAll ['sym ..]) -> lst


(Debug mode only) Applies lint to
all internal symbols - and optionally
to all files sym - and returns a list of diagnoses. See also
noLint.


: (more (lintAll "file1.l" "file2.l"))
...




(lisp 'sym ['fun]) -> num


Installs under the tag sym a callback function
fun, and returns a pointer num suitable to be passed
to a C function via 'native'. If fun is NIL, the
corresponding entry is freed. Maximally 24 callback functions can be installed
that way. 'fun' should be a function of maximally five numbers, and should
return a number. "Numbers" in this context are 64-bit scalars, and may not only
represent integers, but also pointers or other encoded data. See also native and struct.


(load "@lib/clang.l")

(clang "ltest" NIL
   (cbTest (Fun) cbTest 'N Fun) )

long cbTest(int(*fun)(int,int,int,int,int)) {
   return fun(1,2,3,4,5);
}
/**/

: (cbTest
   (lisp 'cbTest
      '((A B C D E)
         (msg (list A B C D E))
         (* A B C D E) ) ) )
(1 2 3 4 5)
-> 120




(list 'any ['any ..]) -> lst


Returns a list of all any arguments. See also cons.


: (list 1 2 3 4)
-> (1 2 3 4)
: (list 'a (2 3) "OK")
-> (a (2 3) "OK")




lst/3


Pilog predicate that returns subsequent list
elements, after applying the get
algorithm to that object and the following arguments. Often used in database
queries. See also map/3.


: (? (db nr +Ord 1 @Ord) (lst @Pos @Ord pos))
 @Ord={B7} @Pos={A1}
 @Ord={B7} @Pos={A2}
 @Ord={B7} @Pos={A3}
-> NIL




(lst? 'any) -> flg


Returns T when the argument any is a (possibly
empty) list (NIL or a cons pair). See also pair.


: (lst? NIL)
-> T
: (lst? (1 . 2))
-> T
: (lst? (1 2 3))
-> T




(listen 'cnt1 ['cnt2]) -> cnt | NIL


Listens at a socket descriptor cnt1 (as received by port) for an incoming connection, and returns
the new socket descriptor cnt. While waiting for a connection, a
poll(2) system call is executed for all file descriptors and timers
in the VAL of the global variable *Run. If cnt2 is
non-NIL, that amount of milliseconds is waited maximally, and
NIL is returned upon timeout. The global variable *Adr
is set to the IP address of the client. See also accept, connect, *Adr.


: (setq *Socket
   (listen (port 6789) 60000) )  # Listen at port 6789 for max 60 seconds
-> 4
: *Adr
-> "127.0.0.1"




(lit 'any) -> any


Returns the literal (i.e. quoted) value of any, by
consing it with the quote function if necessary. See also strip.


: (lit T)
-> T
: (lit 1)
-> 1
: (lit '(1))
-> (1)
: (lit '(a))
-> '(a)




(load 'any ..) -> any


Loads all any arguments. Normally, the name of each argument is
taken as a file to be executed in a read-eval loop. The argument semantics are
identical to that of in, with the
exception that if an argument is a symbol and its first character is a hyphen
'-', then that argument is parsed as an executable list (without the surrounding
parentheses). When any is T, all remaining command
line arguments are loaded recursively. When any is
NIL, standard input is read, a prompt is issued before each read
operation, the results are printed to standard output (read-eval-print loop),
and load terminates when an empty line is entered. In any case,
load terminates upon end of file, or when NIL is read.
The index for transient symbols is cleared before and after the load, so that
all transient symbols in a file have a local scope. If the namespace was
switched (with symbols) while
executing a file, it is restored to the previous one. Returns the value of the
last evaluated expression. See also script, ipid, call, file, in, out
and str.


: (load "lib.l" "-* 1 2 3")
-> 6




(loc 'sym 'lst) -> sym


Locates in lst a transient symbol with the same name as
sym. Allows to get hold of otherwise inaccessible symbols.


: (loc "X" curry)
-> "X"
: (== @ "X")
-> NIL




(local) sym|lst


Intern symbols locally in the current namespace. (local) expects a
single symbol or a list of symbols immediately following in the current
input stream. See also pico,
symbols, private, export, import and intern.


: (symbols 'myLib 'pico)
-> (pico)
myLib: (local) (foo bar)

myLib: (de foo (A)  # 'foo' is local to 'myLib'
   ...
myLib: (de bar (B)  # 'bar' is local to 'myLib'
   ...




(locale 'sym1 'sym2 ['sym ..])


Sets the current locale to that given by the country file sym1
and the language file sym2 (both located in the "loc/" directory),
and optional application-specific directories sym. The locale
influences the language, and numerical, date and other formats. See also
*Uni, datStr, strDat, expDat, day, telStr, expTel and and money.


: (locale "DE" "de" "app/loc/")
-> NIL
: ,"Yes"
-> "Ja"




(lock ['sym]) -> cnt | NIL


Write-locks an external symbol sym (file record locking), or
the whole database root file if sym is NIL. Returns
NIL if successful, or the ID of the process currently holding the
lock. When sym is non-NIL, the lock is released at the
next call to commit or rollback, otherwise only when another
database is opened with pool, or when
the process terminates. See also *Solo.


: (lock '{1})        # Lock single object
-> NIL
: (lock)             # Lock whole database
-> NIL




(loop ['any | (NIL 'any . prg) | (T 'any . prg) ..]) -> any


Endless loop with multiple conditional exits: The body is executed an
unlimited number of times. If a clause has NIL or T as
its CAR, the clause's second element is evaluated as a condition and - if the
result is NIL or non-NIL, respectively - the
prg is executed and the result returned. See also do and for.


: (let N 3
   (loop
      (prinl N)
      (T (=0 (dec 'N)) 'done) ) )
3
2
1
-> done




(low? 'any) -> sym | NIL


Returns any when the argument is a string (symbol) that starts
with a lowercase character. See also lowc and upp?


: (low? "a")
-> "a"
: (low? "A")
-> NIL
: (low? 123)
-> NIL
: (low? ".")
-> NIL




(lowc 'any) -> any


Lower case conversion: If any is not a symbol, it is returned
as it is. Otherwise, a new transient symbol with all characters of
any, converted to lower case, is returned. See also uppc, fold and low?.


: (lowc 123)
-> 123
: (lowc "ABC")
-> "abc"




(lt0 'any) -> num | NIL


Returns num when the argument is a number and less than zero,
otherwise NIL. See also le0, ge0, gt0, =0
and n0.


: (lt0 -2)
-> -2
: (lt0 3)
-> NIL




(lup 'lst 'any) -> lst


(lup 'lst 'any 'any2) -> lst


Looks up any in the CAR-elements of cons pairs stored in the
index tree lst, as built-up by idx. In the first form, the first found cons
pair is returned, in the second form a list of all pairs whose CAR is in the
range any .. any2. If the tree is empty,
NIL is returned immediately. See also enum? and assoc.


: (idx 'A 'a T)
-> NIL
: (idx 'A (1 . b) T)
-> NIL
: (idx 'A 123 T)
-> NIL
: (idx 'A (1 . a) T)
-> NIL
: (idx 'A (1 . c) T)
-> NIL
: (idx 'A (2 . d) T)
-> NIL
: (idx 'A)
-> (123 a (1 . a) (1 . b) (1 . c) (2 . d))
: (lup A 1)
-> (1 . b)
: (lup A 2)
-> (2 . d)
: (lup A 1 1)
-> ((1 . a) (1 . b) (1 . c))
: (lup A 1 2)
-> ((1 . a) (1 . b) (1 . c) (2 . d))








pil21/doc/refM.html0000644000000000000000000005561114533311472011232 0ustar  





M





M






*Msg


A global variable holding the last recently issued error message. See also
Error Handling, *Err and ^.


: (+ 'A 2)
!? (+ 'A 2)
A -- Number expected
?
:
: *Msg
-> "Number expected"




+Mis


Prefix class to explicitly specify validation functions for +relations. Expects a function that takes
a value and an entity object, and returns NIL if everything is
correct, or an error string. See also Database.


(class +Ord +Entity)            # Order class
(rel pos (+Mis +List +Joint)    # List of positions in that order
   ((Val Obj)
      (when (memq NIL Val)
         "There are empty positions" ) )
   ord (+Pos) )




(macro prg) -> any


Substitues all pat? symbols in
prg (using fill), and
executes the result with run. Used
occasionally to call functions which otherwise do not evaluate their arguments.


: (de timerMessage (@N . @Prg)
   (setq @N (- @N))
   (macro
      (task @N 0 . @Prg) ) )
-> timerMessage
: (timerMessage 6000 (println 'Timer 6000))
-> (-6000 0 (println 'Timer 6000))
: (timerMessage 12000 (println 'Timer 12000))
-> (-12000 0 (println 'Timer 12000))
: (more *Run)
(-12000 2616 (println 'Timer 12000))
(-6000 2100 (println 'Timer 6000))
-> NIL
: Timer 6000
Timer 12000
...




(made ['lst1 ['lst2]]) -> lst


Initializes a new list value for the current make environment. All list elements already
produced with chain, link and yoke are discarded, and lst1 is
used instead. Optionally, lst2 can be specified as the new linkage
cell, otherwise the last cell of lst1 is used. When called without
arguments, made does not modify the environment. In any case, the
current list is returned.


: (make
   (link 'a 'b 'c)         # Link three items
   (println (made))        # Print current list (a b c)
   (made (1 2 3))          # Discard it, start new with (1 2 3)
   (link 4) )              # Link 4
(a b c)
-> (1 2 3 4)




(mail 'any 'cnt|lst 'sym1|lst2 'sym2|lst3 'sym3 'lst4 . prg)'


Sends an eMail via SMTP to a mail server at host any, port
cnt. If the second argument is a list, it should be a structure
(user password . port), and "@bin/ssl" will be called to establish
an encrypted connection. sym1|lst2 should be the "from" address (or
a cons pair of "reply-to" and "from"), sym2|lst3 the "to"
address(es), and sym3 the subject. lst4 is a list of
attachments, each one specified by three elements for path, name and mime type.
prg generates the mail body with prEval. See also connect.


(mail "localhost" 25                               # Local mail server
   "a@bc.de"                                       # "From" address
   "abu@software-lab.de"                           # "To" address
   "Testmail"                                      # Subject
   (quote
      "img/go.png" "go.png" "image/png"            # First attachment
      "img/7fach.gif" "7fach.gif" "image/gif" )    # Second attachment
   "Hello,"                                        # First line
   NIL                                             # (empty line)
   (prinl (pack "This is mail #" (+ 3 4))) )       # Third line




(make .. [(made 'lst ..)] .. [(link 'any ..)] ..) -> any


Initializes and executes a list-building process with the made, chain, link and yoke functions, and returns the resulting list.
The final linkage cell is stored in the global variable @@. For efficiency, pointers to the head and the
tail of the list are maintained internally.


: (make (link 1) (link 2 3) (link 4))
-> (1 2 3 4)
: (make (made (1 2 3)) (link 4))
-> (1 2 3 4)




(map 'fun 'lst ..) -> lst


Applies fun to lst and all successive CDRs. When
additional lst arguments are given, they are passed to
fun in the same way. Returns the result of the last application.
See also mapc, maplist, mapcar, mapcon, mapcan and filter.


: (map println (1 2 3 4) '(A B C))
(1 2 3 4) (A B C)
(2 3 4) (B C)
(3 4) (C)
(4) NIL
-> NIL




map/3


Pilog predicate that returns a list and
subsequent CDRs of that list, after applying the get algorithm to that object and the following
arguments. Often used in database queries. See also lst/3.


: (? (db nr +Ord 1 @Ord) (map @L @Ord pos))
 @Ord={B7} @L=({A1} {A2} {A3})
 @Ord={B7} @L=({A2} {A3})
 @Ord={B7} @L=({A3})
-> NIL




(mapc 'fun 'lst ..) -> any


Applies fun to each element of lst. When
additional lst arguments are given, their elements are also passed
to fun. Returns the result of the last application. See also
map, maplist, mapcar, mapcon, mapcan and filter.


: (mapc println (1 2 3 4) '(A B C))
1 A
2 B
3 C
4 NIL
-> NIL




(mapcan 'fun 'lst ..) -> lst


Applies fun to each element of lst. When
additional lst arguments are given, their elements are also passed
to fun. Returns a (destructively) concatenated list of all results.
See also map, mapc, maplist, mapcar, mapcon, filter.


: (mapcan reverse '((a b c) (d e f) (g h i)))
-> (c b a f e d i h g)




(mapcar 'fun 'lst ..) -> lst


Applies fun to each element of lst. When
additional lst arguments are given, their elements are also passed
to fun. Returns a list of all results. See also map, mapc, maplist, mapcon, mapcan and filter.


: (mapcar + (1 2 3) (4 5 6))
-> (5 7 9)
: (mapcar + (1 2 3) 5)
-> (6 7 8)
: (mapcar '((X Y) (+ X (* Y Y))) (1 2 3 4) (5 6 7 8))
-> (26 38 52 68)




(mapcon 'fun 'lst ..) -> lst


Applies fun to lst and all successive CDRs. When
additional lst arguments are given, they are passed to
fun in the same way. Returns a (destructively) concatenated list of
all results. See also map, mapc, maplist, mapcar, mapcan and filter.


: (mapcon copy '(1 2 3 4 5))
-> (1 2 3 4 5 2 3 4 5 3 4 5 4 5 5)




(maplist 'fun 'lst ..) -> lst


Applies fun to lst and all successive CDRs. When
additional lst arguments are given, they are passed to
fun in the same way. Returns a list of all results. See also
map, mapc, mapcar, mapcon, mapcan and filter.


: (maplist cons (1 2 3) '(A B C))
-> (((1 2 3) A B C) ((2 3) B C) ((3) C))




(maps 'fun 'sym ['lst ..]) -> any


Applies fun to all properties of sym. When
additional lst arguments are given, their elements are also passed
to fun. Returns the result of the last application. Note that
'maps' should only be used when the property list is not modified by
fun. Otherwise it is better to use a loop over the result of
getl. See also putl.


: (put 'X 'a 1)
-> 1
: (put 'X 'b 2)
-> 2
: (put 'X 'flg T)
-> T
: (getl 'X)
-> (flg (2 . b) (1 . a))
: (maps println 'X '(A B))
flg A
(2 . b) B
(1 . a) NIL
-> NIL




(mark 'sym|0 ['NIL | 'T | '0]) -> flg


Tests, sets or resets a mark for sym in the database (for a
second argument of NIL, T or 0,
respectively), and returns the old value. The marks are local to the current
process (not stored in the database), and vanish when the process terminates. If
the first argument is zero, all marks are cleared.


: (pool "db")
-> T
: (mark '{1} T)      # Mark
-> NIL
: (mark '{1})        # Test
-> T                 # -> marked
: (mark '{1} 0)      # Unmark
-> T
: (mark '{1})        # Test
-> NIL               # -> unmarked




(match 'lst1 'lst2) -> flg


Takes lst1 as a pattern to be matched against
lst2, and returns T when successful. Atoms must be
equal, and sublists must match recursively. Symbols in the pattern list with
names starting with an at-mark "@" (see pat?) are taken as wildcards. They can match
zero, one or more elements, and are bound to the corresponding data. See also
chop, split and fill.


: (match '(@A is @B) '(This is a test))
-> T
: @A
-> (This)
: @B
-> (a test)
: (match '(@X (d @Y) @Z) '((a b c) (d (e f) g) h i))
-> T
: @X
-> ((a b c))
: @Y
-> ((e f) g)
: @Z
-> (h i)




(max 'any ..) -> any


Returns the largest of all any arguments. See also min and Comparing.


: (max 2 'a 'z 9)
-> z
: (max (5) (2 3) 'X)
-> (5)




(maxKey 'tree ['any1 ['any2]]) -> any


Returns the largest key in a database tree. If a minimal key
any1 and/or a maximal key any2 is given, the largest
key from that range is returned. See also tree, leaf, minKey and genKey.


: (maxKey (tree 'nr '+Item))
-> 7
: (maxKey (tree 'nr '+Item) 3 5)
-> 5




(maxi 'fun 'lst ..) -> any


Applies fun to each element of lst. When
additional lst arguments are given, their elements are also passed
to fun. Returns that element from lst for which
fun returned a maximal value (and stores the maximal value in the
global variable @@). See also mini and sort.


: (setq A 1  B 2  C 3)
-> 3
: (maxi val '(A B C))
-> C
: (maxi                          # Symbol with largest list value
   '((X)
      (and (pair (val X)) (size @)) )
   (all) )
-> pico




(member 'any 'lst) -> any


Returns the tail of lst that starts with any when
any is a member of lst, otherwise NIL.
See also memq, assoc and idx.


: (member 3 (1 2 3 4 5 6))
-> (3 4 5 6)
: (member 9 (1 2 3 4 5 6))
-> NIL
: (member '(d e f) '((a b c) (d e f) (g h i)))
-> ((d e f) (g h i))




member/2


Pilog predicate that succeeds if the the first
argument is a member of the list in the second argument. See also equal/2 and member.


:  (? (member @X (a b c)))
 @X=a
 @X=b
 @X=c
-> NIL




(memq 'any 'lst) -> any


Returns the tail of lst that starts with any when
any is a member of lst, otherwise NIL.
== is used for comparison (pointer
equality). See also member, mmeq, asoq, push1q, delq and Comparing.


: (memq 'c '(a b c d e f))
-> (c d e f)
: (memq (2) '((1) (2) (3)))
-> NIL




(meta 'obj|typ 'sym ['sym2|cnt ..]) -> any


Fetches a property value any, by searching the property lists
of the classes and superclasses of obj, or the classes in
typ, for the property key sym, and by applying the
get algorithm to the following optional
arguments. See also var:.


: (setq A '(B))            # Be 'A' an object of class 'B'
-> (B)
: (put 'B 'a 123)
-> 123
: (meta 'A 'a)             # Fetch 'a' from 'B'
-> 123




(meth 'obj ['any ..]) -> any


This function is usually not called directly, but is used by  dm as a template to initialize the
VAL of message symbols. It searches for itself in the methods of
obj and its classes and superclasses, and executes that method. An
error "Bad message" is issued if the search is unsuccessful. See
also OO Concepts, method, send and try.


: meth
-> 67283504    # Value of 'meth'
: rel>
-> 67283504    # Value of any message




(method 'msg 'obj) -> fun


Returns the function body of the method that would be executed upon sending
the message msg to the object obj. If the message
cannot be located in obj, its classes and superclasses,
NIL is returned. See also OO Concepts,
send, try, meth, super, extra, class.


: (method 'mis> '+Number)
-> ((Val Obj) (and Val (not (num? Val)) "Numeric input expected"))




(methods 'sym) -> lst


(Debug mode only) Returns a list of method specifications for the object or
class sym, as they are inherited from sym's classes
and superclasses. See also OO Concepts, dep, class and can.


: (more (methods '+Joint))
(keep> . +Joint)
(lose> . +Joint)
(rel> . +Joint)
(mis> . +Joint)
(T . +Joint)
(print> . +relation)
(zap> . +relation)
(del> . +relation)
(put> . +relation)
(has> . +relation)
(ele> . +relation)




(min 'any ..) -> any


Returns the smallest of all any arguments. See also max and Comparing.


: (min 2 'a 'z 9)
-> 2
: (min (5) (2 3) 'X)
-> X




(minKey 'tree ['any1 ['any2]]) -> any


Returns the smallest key in a database tree. If a minimal key
any1 and/or a maximal key any2 is given, the smallest
key from that range is returned. See also tree, leaf, maxKey and genKey.


: (minKey (tree 'nr '+Item))
-> 1
: (minKey (tree 'nr '+Item) 3 5)
-> 3




(mini 'fun 'lst ..) -> any


Applies fun to each element of lst. When
additional lst arguments are given, their elements are also passed
to fun. Returns that element from lst for which
fun returned a minimal value (and stores the minimal value in the
global variable @@). See also maxi and sort.


: (setq A 1  B 2  C 3)
-> 3
: (mini val '(A B C))
-> A




(mix 'lst cnt|'any ..) -> lst


Builds a list from the elements of the argument lst, as
specified by the following cnt|'any arguments. If such an argument
is a positive number, the n'th element from lst is taken. If it is
a negative number, the n'th CDR. Otherwise that argument is evaluated and the
result is used.


: (mix '(a b c d) 3 4 1 2)
-> (c d a b)
: (mix '(a b c d) -2 1)
-> ((c d) a)
: (mix '(a b c d) 1 'A 4 'D)
-> (a A d D)




(mmeq 'lst 'lst) -> any


Returns the tail of the second argument lst that starts with a
member of the first argument lst, otherwise NIL.
== is used for comparison (pointer
equality). See also member, memq, asoq and delq.


: (mmeq '(a b c) '(d e f))
-> NIL
: (mmeq '(a b c) '(d b x))
-> (b x)




(money 'num ['sym]) -> sym


Formats a number num into a digit string with two decimal
places, according to the current locale. If an additional currency name is
given, it is appended (separated by a space). See also telStr, datStr and format.


: (money 123456789)
-> "1,234,567.89"
: (money 12345 "EUR")
-> "123.45 EUR"
: (locale "DE" "de")
-> NIL
: (money 123456789 "EUR")
-> "1.234.567,89 EUR"




(more 'lst ['fun]) -> flg


(more 'cls) -> any


(Debug mode only) Displays the elements of lst (first form), or
the type and methods of cls (second form). fun
defaults to println. In the second
form, the method definitions of cls are pretty-printed with
pp. After each step, more
waits for a key, and terminates when ESC is pressed. In that case,
T is returned, otherwise (when end of data is reached)
NIL. See also query and
show.


: (more (all))                         # Display all internal symbols
!
$
%
&
*
-> T

: (more (all) show)                    # 'show' all internal symbols
! 27131845007
   doc "@doc/ref_.html"
   *Dbg ((1458 "@src/flow.l" llvm pico))
$ 27131845049
   doc "@doc/ref_.html"
   *Dbg ((1508 "@src/flow.l" llvm pico))
% -27131839417
   doc "@doc/ref_.html"
   *Dbg ((1245 "@src/big.l" llvm pico))
& -27131839537
   doc "@doc/ref_.html"
   *Dbg ((1380 "@src/big.l" llvm pico))
* -27131839339
   doc "@doc/ref_.html"
   *Dbg ((1174 "@src/big.l" llvm pico))
...

: (more '+Link)                        # Display a class
(+relation)
(dm mis> (Val Obj)
   (and
      Val
      (nor (isa (: type) Val) ("canQuery" Val))
      "Type error" ) )
(dm T (Var Lst)
   (unless (=: type (car Lst)) (quit "No Link" Var))
   (super Var) )
-> NIL




(msg 'any ['any ..]) -> any


Prints any with print, followed by all any
arguments (printed with prin) and a
newline, to standard error. The first any argument is returned.


: (msg (1 a 2 b 3 c) " is a mixed " "list")
(1 a 2 b 3 c) is a mixed list
-> (1 a 2 b 3 c)








pil21/doc/refN.html0000644000000000000000000004015214757550224011235 0ustar  





N





N






+Need


Prefix class for mandatory +relations. Note that this does not
enforce any requirements by itself, it only returns an error message if the
mis> message is explicitly called, e.g. by GUI functions. See
also Database.


(rel nr (+Need +Key +Number))  # Item number is mandatory




+Number


Class for numeric relations, a subclass of +relation. Accepts an optional argument
for the fixpoint scale (currently not used). See also Database.


(rel pr (+Number) 2)  # Price, with two decimal places




(n== 'any ..) -> flg


Returns T when not all any arguments are the same
(pointer equality). (n== 'any ..) is equivalent to (not (==
'any ..)). See also == and Comparing.


: (n== 'a 'a)
-> NIL
: (n== (1) (1))
-> T




(n0 'any) -> flg


Returns T when any is not a number with value
zero. See also =0, lt0, le0, ge0 and gt0.


: (n0 (- 6 3 2 1))
-> NIL
: (n0 'a)
-> T




(nT 'any) -> flg


Returns T when any is not the symbol
T. See also =T.


: (nT 0)
-> T
: (nT "T")
-> T
: (nT T)
-> NIL




(name 'sym) -> sym


Returns a new transient symbol with the name of sym. See also
str, sym, symbols, zap and intern.


: (name 'abc)
-> "abc"
: (name "abc")
-> "abc"
: (name '{A17})
-> "A17"
: (name (new))
-> NIL




(namespaces ['flg]) -> lst


(Debug mode only) Returns a list of all namespaces nested in the current search
order. When flg is non-NIL, their nested tree
is printed as a side effect. See also symbols and shadows.


$ pil +
: (namespaces)
-> (pico vip llvm priv)
: (namespaces T)
   pico
      vip
      llvm
      priv
-> (pico vip llvm priv)

$ pty  # After starting "steps", "browser" and "chess" in PilBox
chess: (namespaces T)
   chess
   simul
   android
      steps
      browser
   pico
      svg
      vip
      gis
      llvm
      priv
-> (chess simul android steps browser pico svg vip gis llvm priv)




(nand 'any ..) -> flg


Logical NAND. The expressions any are evaluated from left to
right. If NIL is encountered, T is returned
immediately. Else NIL is returned. (nand ..) is
equivalent to (not (and ..)). See also and, nor, unless, ifn and nond.


: (nand (lt0 7) (read))
-> T
: (nand (lt0 -7) (read))
abc
-> NIL
: (nand (lt0 -7) (read))
NIL
-> T




(native 'cnt1|sym1 'cnt2|sym2 'any 'any ..) -> any


Calls a native function. The first argument should specify a shared object
library, either "@" (the current main program), sym1
(a library path name), or cnt1 (a library handle obtained by a
previous call). The second argument should be a symbol name sym2,
or a function handle cnt2 obtained by a previous call).
Practically, the first two arguments will be always passed as transient symbols,
which will get the library handle and function handle assigned as values to be
cached and used in subsequent calls. The third argument any is a
result specification, while all following arguments are the arguments to the
native function. The functionality is described in detail in Native C Calls.


The result specification may either be one of the
atoms


   NIL   void
   B     byte     # Byte (unsigned 8 bit)
   C     char     # Character (UTF-8, 1-4 bytes)
   W     short    # Word (signed 16 bit)
   I     int      # Integer (signed 32 bit)
   N     long     # Number (signed 64 bit)
   P     void*    # Pointer (unsigned 64 bit)
   S     string   # String (UTF-8)
  -1.0   float    # Scaled fixpoint number
  +1.0   double   # Scaled fixpoint number
   T              # Direct Lisp value




or nested lists of these atoms with size specifications to denote arrays and
structures, e.g.


   (N . 4)        # long[4];           -> (1 2 3 4)
   (N (C . 4))    # {long; char[4];}   -> (1234 ("a" "b" "c" NIL))
   (N (B . 7))    # {long; byte[7];}   -> (1234 (1 2 3 4 5 6 7))




Arguments can be

    

  • integers (up to 64-bit) or pointers, passed as numbers

  • strings, passed as symbols

  • Lisp expressions, passed as cons pairs with T in the CAR

  • fixpoint numbers, passed as cons pairs consisting of a the value and the
   scale (if the scale is positive, the number is passed as a
   double, otherwise as a float)

  • structures, passed as lists with
   
      
   
    • a variable in the CAR (to receive the returned structure data, ignored
      when the CAR is NIL)
   
    • a cons pair for the size and result specification in the CADR (see
      above), and
   
    • an optional sequence of initialization items in the
      CDDR, where each may be
      
        
      
      • a positive number, stored as an unsigned byte value
      
      • a negative number, whose absolute value is stored as an unsigned
         integer
      
      • a pair (num . cnt) where 'num' is stored in
         a field of 'cnt' bytes
      
      • a pair (sym . cnt) where 'sym' is stored as
         a null-terminated string in a field of 'cnt' bytes
      
      • a list (1.0 num ...) where the 'num'
         elements (scaled fixpoint numbers) are stored as a sequence of double
         precision floating point numbers
      
      • a list (-1.0 num ...) where the 'num'
         elements (scaled fixpoint numbers) are stored as a sequence of single
         precision floating point numbers
      
      
      If the last CDR of the initialization sequence is a number, it is used
      as a fill-byte value for the remaining space in the structure.
   
    




native takes care of allocating memory for strings, arrays or
structures, and frees that memory when done.


For NaN or negative infinity fixpoint values NIL, and for
positive infinity T is returned.


See also %@, struct, adr, lisp and errno.


: (native "@" "unlink" 'I "file")  # Same as (%@ "unlink" 'I "file")
-> 0
: (native "libcrypto.so" "SHA1" '(B . 20) "abcd" 4 0)
-> (129 254 139 254 135 87 108 62 203 34 66 111 142 87 132 115 130 145 122 207)




(need 'cnt ['lst ['any]]) -> lst


(need 'cnt ['num|sym]) -> lst


Produces a list of at least cnt elements. When called without
optional arguments, a list of cnt NIL's is returned.
When lst is given, it is extended to the left (if cnt
is positive) or (destructively) to the right (if cnt is negative)
with any elements. In the second form, a list of cnt
atomic values is returned. See also range.


: (need 5)
-> (NIL NIL NIL NIL NIL)  # Allocate 5 cells
: (need 5 '(a b c))
-> (NIL NIL a b c)
: (need -5 '(a b c))
-> (a b c NIL NIL)
: (need 5 '(a b c) " ")  # String alignment
-> (" " " " a b c)
: (need 7 0)
-> (0 0 0 0 0 0 0)
: (need 5 (2 3) 1)
-> (1 1 1 2 3)




(new ['flg|num|sym] ['typ ['any ..]]) -> obj


Creates and returns a new object. If the first (optional) argument is
T or a number, the new object will be an external symbol (created
in database file 1 if T, or in the corresponding database file if
num is given). If it is a symbol, it is used directly.
typ (a list of classes) is assigned to the VAL, and
the initial T message is sent with the arguments any
to the new object. If no T message is defined for the classes in
typ or their superclasses, the any arguments should
evaluate to alternating keys and values for the initialization of the new
object. See also box, object, class, type, isa, send and Database.


: (new)
-> $134426427
: (new T '(+Address))
-> {A3}




(new! 'typ ['any ..]) -> obj


Transaction wrapper function for new. (new! '(+Cls) 'key 'val ...)
is equivalent to (dbSync) (new (db: +Cls) '(+Cls) 'key 'val ...) (commit
'upd). See also request!, set!, put! and inc!.


: (new! '(+Item)  # Create a new item
   'nr 2                      # Item number
   'nm "Spare Part"           # Description
   'sup (db 'nr '+CuSu 2)     # Supplier
   'inv 100                   # Inventory
   'pr 12.50 )                # Price






Can only be used inside functions with a variable number of arguments (with
@). Returns the next argument from the internal list. See also
args, arg, rest, and pass.


: (de foo @ (println (next)))          # Print next argument
-> foo
: (foo)
NIL
-> NIL
: (foo 123)
123
-> 123




(nil . prg) -> NIL


Executes prg, and returns NIL. See also t, prog,
prog1 and prog2.


: (nil (println 'OK))
OK
-> NIL




nil/1


Pilog predicate expects an argument variable,
and succeeds if that variable is bound to NIL. See also not/1.


: (? @X NIL (nil @X))
 @X=NIL
-> NIL




(noLint 'sym)


(noLint 'sym|(sym . cls) 'sym2)


(Debug mode only) Excludes the check for a function definition of
sym (in the first form), or for variable binding and usage of
sym2 in the function definition, file contents or method body of
sym (second form), during calls to lint. See also lintAll.


: (de foo ()
   (bar FreeVariable) )
-> foo
: (lint 'foo)
-> ((def bar) (bnd FreeVariable))
: (noLint 'bar)
-> bar
: (noLint 'foo 'FreeVariable)
-> (foo . FreeVariable)
: (lint 'foo)
-> NIL




(nond ('any1 . prg1) ('any2 . prg2) ..) -> any


Negated ("non-cond") multi-way conditional: If any of the anyN
conditions evaluates to NIL, prgN is executed and the
result returned. Otherwise (all conditions evaluate to non-NIL),
NIL is returned. See also cond, ifn, unless, nor and nand.


: (nond
   ((= 3 3) (println 1))
   ((= 3 4) (println 2))
   (NIL (println 3)) )
2
-> 2




(nor 'any ..) -> flg


Logical NOR. The expressions any are evaluated from left to
right. If a non-NIL value is encountered, NIL is
returned immediately. Else T is returned. (nor ..) is
equivalent to (not (or ..)). See also or, nand, unless, ifn and nond.


: (nor (lt0 7) (= 3 4))
-> T




(not 'any) -> flg


Logical negation. Returns T if any evaluates to
NIL.


: (not (== 'a 'a))
-> NIL
: (not (get 'a 'a))
-> T




not/1


Pilog predicate that succeeds if and only if
the goal cannot be proven. See also nil/1, true/0 and fail/0.


: (? (equal 3 4))
-> NIL
: (? (not (equal 3 4)))
-> T




(nsp 'sym) -> sym


Returns the (first) namespace
where sym is found in, according to the current symbols search order. See also
pico.


(load "@lib/gis.l")

: (symbols '(gis pico))
-> (pico)
gis: (nsp 'gis)
-> pico
gis: (nsp 'Zoom)
-> gis
gis: (nsp 'osmStat)
-> gis




(nth 'lst 'cnt ..) -> lst


Returns the tail of lst starting from the cnt'th
element of lst. Successive cnt arguments operate on
the CARs of the results in the same way. (nth 'lst 2) is equivalent
to (cdr 'lst). See also get.


: (nth '(a b c d) 2)
-> (b c d)
: (nth '(a (b c) d) 2 2)
-> (c)
: (cdadr '(a (b c) d))
-> (c)




(num? 'any) -> num | NIL


Returns any when the argument any is a number,
otherwise NIL. See also sym?, atom and pair.


: (num? 123)
-> 123
: (num? (1 2 3))
-> NIL








pil21/doc/refO.html0000644000000000000000000002604114516412367011235 0ustar  





O





O






*ObjIdx


Holds an idx tree of objects
created by obj.





*Once


Holds an idx tree of already
loaded source locations (as returned
by file) See also once.


: *Once
-> (("lib/" "misc.l" . 11) (("lib/" "http.l" . 9) (("lib/" "form.l" . 11))))




*OS


A global constant holding the name of the operating system. Possible values
include "Linux", "Android", "FreeBSD",
"OpenBSD", "SunOS", "Darwin" or
"Cygwin". See also *CPU
and version.


: *OS
-> "Linux"




(obj (typ sym [hook] val ..) [var1 val1 ..]) -> obj


(obj typ any [var1 val1 ..]) -> obj


Finds or creates a database object, and initializes additional properties
using the varN and valN arguments. In the first form,
a request for (typ sym [hook]
val ..) is called, while the second form uses cache to maintain objects without unique
+Keys by indexing *ObjIdx with the any argument.


: (obj ((+Item) nr 2) nm "Spare Part" sup `(db 'nr '+CuSu 2) inv 100 pr 1250)
-> {B2}




(object 'sym 'any ['sym2 'any2 ..]) -> obj


Defines sym to be an object with the value (or type)
any. The property list is initialized with all optionally supplied
key-value pairs. See also OO Concepts, new, type and isa.


: (object 'Obj '(+A +B +C) 'a 1 'b 2 'c 3)
-> Obj
: (show 'Obj)
Obj (+A +B +C)
   c 3
   b 2
   a 1
-> Obj




(oct 'num ['num]) -> sym


(oct 'sym) -> num


Converts a number num to an octal string, or an octal string
sym to a number. In the first case, if the second argument is
given, the result is separated by spaces into groups of such many digits. See
also bin, hex, hax and format.


: (oct 73)
-> "111"
: (oct "111")
-> 73
: (oct 1234567 3)
-> "4 553 207"




(off var ..) -> NIL


Stores NIL in all var arguments. See also on, onOff, zero and one.


: (off A B)
-> NIL
: A
-> NIL
: B
-> NIL




(offset 'lst1 'lst2) -> cnt | NIL


Returns the cnt position of the tail list lst1 in
lst2, or NIL if it is not found. See also index, sub? and tail.


: (offset '(c d e f) '(a b c d e f))
-> 3
: (offset '(c d e) '(a b c d e f))
-> NIL




(on var ..) -> T


Stores T in all var arguments. See also off, onOff, zero and one.


: (on A B)
-> T
: A
-> T
: B
-> T




(once . prg) -> any


Executes prg once, when the current file is loaded the first time. Subsequent loads at a
later time will not execute prg, and once returns
NIL. See also *Once and
finish.


(once
   (zero *Cnt1 *Cnt2)  # Init counters
   (load "file1.l" "file2.l") )  # Load other files

`(once T)  # Ignore next time the rest of this file




(one var ..) -> 1


Stores 1 in all var arguments. See also zero, on, off
and onOff.


: (one A B)
-> 1
: A
-> 1
: B
-> 1




(onOff var ..) -> flg


Logically negates the values of all var arguments. Returns the
new value of the last symbol. See also on, off,
zero and one.


: (onOff A B)
-> T
: A
-> T
: B
-> T
: (onOff A B)
-> NIL
: A
-> NIL
: B
-> NIL




(open 'any ['flg]) -> cnt | NIL


Opens the file with the name any in read/write mode (or
read-only if flg is non-NIL), and returns a file
descriptor cnt (or NIL on error). A leading
"@" character in any is substituted with the
PicoLisp Home Directory, as it was remembered during interpreter startup.
If flg is NIL and the file does not exist, it is
created. The file descriptor can be used in subsequent calls to in and out. See also close and poll.


: (open "x")
-> 3




(opid) -> pid | NIL


Returns the corresponding process ID when the current output channel is
writing to a pipe, otherwise NIL. See also ipid and out.


: (out '(cat) (call 'ps "-p" (opid)))
  PID TTY          TIME CMD
 7127 pts/3    00:00:00 cat
-> T




(opt) -> sym


Return the next command line argument ("option", as would be processed by
load) as a string, and remove it from
the remaining command line arguments. See also Invocation and argv.


$ pil  -"de f () (println 'opt (opt))"  -f abc  -bye
opt "abc"




(or 'any ..) -> any


Logical OR. The expressions any are evaluated from left to
right. If a non-NIL value is encountered, it is returned
immediately. Else the result of the last expression is returned. See also
nor, and and unless.


: (or (= 3 3) (read))
-> T
: (or (= 3 4) (read))
abc
-> abc




or/2


Pilog predicate that takes an arbitrary number
of clauses, and succeeds if one of them can be proven. See also not/1.


: (?
   (or
      ((equal 3 @X) (equal @X 4))
      ((equal 7 @X) (equal @X 7)) ) )
 @X=7
-> NIL




(out 'any . prg) -> any


Opens any as output channel during the execution of
prg. The current output channel will be saved and restored
appropriately. If the argument is NIL, standard output is used. If
the argument is a symbol, it is used as a file name (opened in read/write-append
mode if the first character is "+"). If it is a positive number, it
is used as the descriptor of an open file. If it is a negative number, the saved
output channel such many levels above the current one is used. Otherwise (if it
is a list), it is taken as a command with arguments, and a pipe is opened for
output. The (system dependent) exit status code of the child process is stored
in the global variable @@. In all cases,
flush is called when prg
is done. See also in,  err,  fd, opid,  call, ctl, pipe,  poll,  close and load.


: (out "a" (println 123 '(a b c) 'def))  # Write one line to file "a"
-> def
: (out '(lpr) (prinl "Hello"))  # Send line to line printer
-> "Hello"




(output exe . prg) -> any


Establishes an output stream, by redirecting the current output channel
during the execution of prg. The current output channel will be
saved and restored appropriately. exe is executed (in the context
of the original output channel) whenever a character needs to be output by print
calls in prg. That character is passed in the global variable
@@, and the following character in the
stream in @@@ (single-character
look-ahead). See also input, out and pipe.


: (output (prin (uppc @@)) (prinl "abc"))
ABC
-> "abc"
: (output (println @@ @@@) (prin "abc"))
"a" "b"
"b" "c"
"c" NIL
-> "abc"
: (pack
   (make
      (output (link @@)
         (print '(+ 2 (* 3 4))) ) ) )
-> "(+ 2 (* 3 4))"
: (pack
   (make
      (let L (1 2 3 4 5 6 7)
         (output (link @@)
            (while L
               (ext:Base64 (++ L) (++ L) (++ L)) ) ) ) ) )
-> "AQIDBAUGBw=="








pil21/doc/refP.html0000644000000000000000000010345214763346440011242 0ustar  





P





P






*PPid


A global constant holding the process-id of the parent picolisp process, or
NIL if the current process is a top level process.


: (println *PPid *Pid)
NIL 5286

: (unless (fork) (println *PPid *Pid) (bye))
5286 5522




*Pid


A global constant holding the current process-id.


: *Pid
-> 6386
: (call "ps")  # Show processes
  PID TTY          TIME CMD
 .... ...      ........ .....
 6386 pts/1    00:00:00 pil   # <- current process
 6388 pts/1    00:00:00 ps
-> T




*Prompt


Global variable holding a (possibly empty) prg body, which is
executed - and the result printed -
every time before a prompt is output to the console in the
"read-eval-print-loop" (REPL).


: (de *Prompt (pack "[" (stamp) "]"))
# *Prompt redefined
-> *Prompt
[2011-10-11 16:50:05]: (+ 1 2 3)
-> 6
[2011-10-11 16:50:11]:




(pack 'any ..) -> sym


Returns a transient symbol whose name is concatenated from all arguments
any. A NIL arguments contributes nothing to the result
string, a number is converted to a digit string, a symbol supplies the
characters of its name, and for a list its elements are taken. See also text and glue.


: (pack 'car " is " 1 '(" symbol " name))
-> "car is 1 symbol name"




(pad 'cnt 'any) -> sym


Returns a transient symbol with any packed with leading '0' characters, up to a
field width of cnt. See also format and align.


: (pad 5 1)
-> "00001"
: (pad 5 123456789)
-> "123456789"




(pair 'any) -> any


Returns any when the argument is a cons pair. See also atom, num?, sym? and lst?.


: (pair NIL)
-> NIL
: (pair (1 . 2))
-> (1 . 2)
: (pair (1 2 3))
-> (1 2 3)




part/3


Pilog predicate that succeeds if the first
argument, after folding it to a
canonical form, is a substring of the folded string representation of the
result of applying the get algorithm to
the following arguments. Typically used as filter predicate in select/3 database queries. See also
sub?, isa/2, same/3, bool/3, range/3, head/3, fold/3 and tolr/3.


: (?
   @Nr (1 . 5)
   @Nm "part"
   (select (@Item)
      ((nr +Item @Nr) (nm +Item @Nm))
      (range @Nr @Item nr)
      (part @Nm @Item nm) ) )
 @Nr=(1 . 5) @Nm="part" @Item={B1}
 @Nr=(1 . 5) @Nm="part" @Item={B2}
-> NIL




(pass 'fun ['any ..]) -> any


Passes to fun all arguments any, and all remaining
variable arguments (@) as they would be returned by rest. (pass 'fun 'any) is
equivalent to (apply 'fun (rest) 'any). See also apply.


: (de bar (A B . @)
   (println 'bar A B (rest)) )
-> bar
: (de foo (A B . @)
   (println 'foo A B)
   (pass bar 1)
   (pass bar 2) )
-> foo
: (foo 'a 'b 'c 'd 'e 'f)
foo a b
bar 1 c (d e f)
bar 2 c (d e f)
-> (d e f)




(pat? 'any) -> pat | NIL


Returns any when the argument any is a symbol
whose name starts with an at-mark "@", otherwise NIL.


: (pat? '@)
-> @
: (pat? "@Abc")
-> "@Abc"
: (pat? "ABC")
-> NIL
: (pat? 123)
-> NIL




(patch 'lst 'any . prg) -> any


Destructively replaces all sub-expressions of lst, that
match the pattern any,
by the result of the execution of prg. See also daemon and redef.


: (pp 'hello)
(de hello NIL
   (prinl "Hello world!") )
-> hello

: (patch hello 'prinl 'println)
-> NIL
: (pp 'hello)
(de hello NIL
   (println "Hello world!") )
-> hello

: (patch hello '(prinl @S) (fill '(println "We said: " . @S)))
-> NIL
: (hello)
We said: Hello world!
-> "Hello world!"




(path 'any) -> sym


Substitutes any leading "@" or "~" character in
the any argument with the PicoLisp or User Home
Directory respectively, as they were remembered during interpreter startup.
Optionally, the name may be preceded by a "+" character (as used by
in and out). This mechanism is used internally by all
I/O functions. See also Invocation, basename and dirname.


$ /usr/bin/picolisp /usr/lib/picolisp/lib.l
: (path "a/b/c")
-> "a/b/c"
: (path "@a/b/c")
-> "/usr/lib/picolisp/a/b/c"
: (path "+@a/b/c")
-> "+/usr/lib/picolisp/a/b/c"




(peek) -> sym


Single character look-ahead: Returns the same character as the next call to
char would return. Note that if the
next character is a multi-byte character, only the first byte is
returned. See also skip.


$ cat a
# Comment
abcd
$ pil +
: (in "a" (list (peek) (char)))
-> ("#" "#")




permute/2


Pilog predicate that succeeds if the second
argument is a permutation of the list in the second argument. See also append/3.


: (? (permute (a b c) @X))
 @X=(a b c)
 @X=(a c b)
 @X=(b a c)
 @X=(b c a)
 @X=(c a b)
 @X=(c b a)
-> NIL




(pick 'fun 'lst ..) -> any


Applies fun to successive elements of lst until
non-NIL is returned. Returns that value, or NIL if
fun did not return non-NIL for any element of
lst. When additional lst arguments are given, their
elements are also passed to fun. (pick 'fun 'lst) is
equivalent to (fun (find 'fun 'lst)). See also seek, find and extract.


: (setq A NIL  B 1  C NIL  D 2  E NIL  F 3)
-> 3
: (find val '(A B C D E))
-> B
: (pick val '(A B C D E))
-> 1




pico


A global constant holding the initial (default) namespace of internal symbols. Its value
is two cons pairs of the symbol ~ (as a marker) and two
'idx' trees, one for symbols
with short names and one for symbols with long names (more than 7 bytes
in the name). See also symbols, nsp, import and intern.


: (symbols)
-> (pico)
: (cdr pico)
-> (rollback (*NoTrace (*CtryCode (+IdxFold) genStrKey) basename ...




(pilog 'lst . prg) -> any


Evaluates a Pilog query, and executes
prg for each result set with all Pilog variables bound to their
matching values. See also solve,
?, goal and prove.


: (pilog '((append @X @Y (a b c))) (println @X '- @Y))
NIL - (a b c)
(a) - (b c)
(a b) - (c)
(a b c) - NIL
-> NIL




(pipe exe) -> cnt


(pipe exe . prg) -> any


Executes exe in a fork'ed child process (which terminates
thereafter). In the first form, pipe just returns a file descriptor
to write to the standard input and read from the standard output of that
process. In the second form, it opens the standard output of that process as
input channel during the execution of prg. The current input
channel will be saved and restored appropriately, and the (system dependent)
exit status code of the child process is stored in the global variable @@. See also later, ipid, in and out.


: (pipe                                # equivalent to 'any'
   (prinl "(a b # Comment\nc d)")         # Child
   (read) )                               # Parent
-> (a b c d)

: (pipe                                # pipe through an external program
   (out '(tr "[a-z]" "[A-Z]")             # Child
      (prinl "abc def ghi") )
   (line T) )                             # Parent
-> "ABC DEF GHI"

: (setq P
     (pipe
        (in NIL                           # Child: Read stdin
           (while (line T)
              (prinl (uppc @))            # and write to stdout
              (flush) ) ) ) )
-> 3
: (out P (prinl "abc def"))               # Parent: Send line to child
-> "abc def"
: (in P (line))                           # Parent: Read reply
-> ("A" "B" "C" " " "D" "E" "F")




(place 'cnt 'lst 'any) -> lst


Places any into lst at position cnt.
This is a non-destructive operation. See also insert, remove, append, delete and replace.


: (place 3 '(a b c d e) 777)
-> (a b 777 d e)
: (place 1 '(a b c d e) 777)
-> (777 b c d e)
: (place 9 '(a b c d e) 777)
-> (a b c d e 777)




(plio 'num) -> any


(plio 'num 'cnt 'any) -> cnt


The first form returns one item stored in PLIO format at the memory location
pointed to by num. The second form stores an item any
in a buffer of size cnt. See also byte and struct.


: (buf P 64
   (plio P 64 (1 a (2 b c) d))  # Store expression
   (plio P) )                   # Fetch it
-> (1 a (2 b c) d)




(poll 'cnt) -> cnt | NIL


Checks for the availability of data for reading on the file descriptor
cnt. See also open,
in and close.


: (and (poll *Fd) (in @ (read)))  # Prevent blocking




(pool ['sym1 ['lst] ['sym2] ['sym3]]) -> T


Opens the file sym1 as a database file in read/write mode. If
the file does not exist, it is created. A currently open database is closed.
lst is a list of block size scale factors (i.e. numbers),
defaulting to (2) (for a single file with a 256 byte block size). If
lst is given, an individual database file is opened for each item.
If sym2 is non-NIL, it is opened in append-mode as an
asynchronous replication journal. If sym3 is non-NIL,
it is opened for reading and appending, to be used as a synchronous transaction
log during commits. Calling
(pool) without arguments just closes the current database. See also
dbs, *Dbs and journal.


: *Dbs
-> (1 2 2 4)
: (pool "dbFile" *Dbs)
-> T

$ ls -l dbFile*
-rw-r--r-- 1 abu abu  256 Jul  3 08:30 dbFile@
-rw-r--r-- 1 abu abu  256 Jul  3 08:30 dbFileA
-rw-r--r-- 1 abu abu  256 Jul  3 08:30 dbFileB
-rw-r--r-- 1 abu abu 1024 Jul  3 08:30 dbFileC

# DB directly on a device
: (pool "/dev/hda2")
-> T




(pool2 'sym . prg) -> any


Temporary switches to another database specified by sym. This
database must be a multi-file DB with exactly the same *Dbs structure as the currently open one. The
current database is not closed - I/O is just redirected to the new one. All
files are opened before prg runs, and are closed thereafter. The
result of prg is returned. No replication journal or transaction
log is written. Also, possibly cached objects of the current DB remain in the
heap, so an explicit call to rollback may be necessary. See also
blk.


(pool2 "db2/"  # Update a read-only DB
   (journal "file.jnl") )

(rollback)
(pool2 "db2/"  # Access object(s)
   (show *DB) )
(rollback)




(pop 'var) -> any


Pops the first element (CAR) from the stack in var. See also
push, ++, shift, queue, cut, del and fifo.


: (setq S '((a b c) (1 2 3)))
-> ((a b c) (1 2 3))
: (pop S)
-> a
: (pop (cdr S))
-> 1
: (pop 'S)
-> (b c)
: S
-> ((2 3))




(port ['T] 'cnt|(cnt . cnt) ['var]) -> cnt


Opens a TCP-Port cnt (or a UDP-Port if the first argument is
T), and returns a socket descriptor suitable as an argument for
listen or accept (or udp, respectively). If cnt is zero,
some free port number is allocated. If a pair of cnts is given
instead, it should be a range of numbers which are tried in turn. When
var is given, it is bound to the port number.


: (port 0 'A)                       # Allocate free port
-> 4
: A
-> 1034                             # Got 1034
: (port (4000 . 4008) 'A)           # Try one of these ports
-> 5
: A
-> 4002




(pp 'sym) -> sym


(pp 'sym 'cls) -> sym


(pp '(sym . cls)) -> sym


Pretty-prints the function or method definition of sym. The
output format would regenerate that same definition when read and executed. See
also pretty, debug and vi.


: (pp 'tab)
(de tab (Lst . @)
   (for N Lst
      (let V (next)
         (and (gt0 N) (space (- N (length V))))
         (prin V)
         (and
            (lt0 N)
            (space (- 0 N (length V))) ) ) )
   (prinl) )
-> tab

: (pp 'has> '+Entity)
(dm has> (Var Val)
   (or
      (nor Val (get This Var))
      (has> (meta This Var) Val (get This Var)) ) )
-> has>

: (more (can 'has>) pp)
(dm (has> . +relation) (Val X)
   (and (= Val X) X) )

(dm (has> . +Fold) (Val X)
   (extra
      Val
      (if (= Val (fold Val)) (fold X) X) ) )

(dm (has> . +Entity) (Var Val)
   (or
      (nor Val (get This Var))
      (has> (meta This Var) Val (get This Var)) ) )

(dm (has> . +List) (Val X)
   (and
      Val
      (or
         (extra Val X)
         (find '((X) (extra Val X)) X) ) ) )

(dm (has> . +Bag) (Val X)
   (and
      Val
      (or (super Val X) (car (member Val X))) ) )




(pr 'any ..) -> any


Binary print: Prints all any arguments to the current output
channel in encoded binary format. See also rd, bytes, tell, hear and wr.


: (out "x" (pr 7 "abc" (1 2 3) 'a))  # Print to "x"
-> a
: (hd "x")
00000000  04 0E 0E 61 62 63 01 04 02 04 04 04 06 03 05 61  ...abc.........a
-> NIL




(prBase64 'cnt ['str]) -> NIL


Multiline base64 printing. Echoes bytes from the current input channel to
the current output channel in Base64 format. A newline is inserted after every
cnt byte-triples (character-quadruples). If str is
given (typically a carriage return), it is output before the newline. See also
echo mail.


: (in "image.png" (prBase64 18))  # Print 72 columns




(prEval 'prg ['cnt]) -> any


Executes prg, similar to run, by evaluating all expressions in
prg (within the binding environment given by cnt-1).
As a side effect, all atomic expressions will be printed with prinl. See also eval.


: (let Prg 567
   (prEval
      '("abc" (prinl (+ 1 2 3)) Prg 987) ) )
abc
6
567
987
-> 987




(pre? 'any1 'any2) -> any2 | NIL


Returns any2 when the string representation of
any1 is a prefix of the string representation of any2.
See also sub? and head.


: (pre? "abc" "abcdefg")
-> "abcdef"
: (pre? "def" "abcdefg")
-> NIL
: (pre? (+ 3 4) "7fach")
-> "7fach"
: (pre? NIL "abcdefg")
-> "abcdefg"

: (pre? "abc" '(a b c d e f g))
-> "abcdefg"
: (pre? '(a b c) "abcdefg")
-> "abcdefg"




(pretty 'any 'cnt)


Pretty-prints any. If any is an atom, or a list
with a size not greater than 12, it is
printed as is. Otherwise, only the
opening parenthesis and the CAR of the list is printed, all other elements are
pretty-printed recursively indented by three spaces, followed by a space and the
corresponding closing parenthesis. The initial indentation level
cnt defaults to zero. See also pp.


: (pretty '(a (b c d) (e (f (g) (h) (i)) (j (k) (l) (m))) (n o p) q))
(a
   (b c d)
   (e
      (f (g) (h) (i))
      (j (k) (l) (m)) )
   (n o p)
   q )-> ")"




(prin 'any ..) -> any


Prints the string representation of all any arguments to the
current output channel. No space or newline is printed between individual items,
or after the last item. For lists, all elements are prin'ted
recursively. See also prinl.


: (prin 'abc 123 '(a 1 b 2))
abc123a1b2-> (a 1 b 2)




(prinl 'any ..) -> any


Prints the string representation of all any arguments to the
current output channel, followed by a newline. No space or newline is printed
between individual items. For lists, all elements are prin'ted
recursively. See also prin.


: (prinl 'abc 123 '(a 1 b 2))
abc123a1b2
-> (a 1 b 2)




(print 'any ..) -> any


Prints all any arguments to the current output channel. If
there is more than one argument, a space is printed between successive
arguments. No space or newline is printed after the last item. See also println, printsp, sym and str


: (print 123)
123-> 123
: (print 1 2 3)
1 2 3-> 3
: (print '(a b c) 'def)
(a b c) def-> def




(println 'any ..) -> any


Prints all any arguments to the current output channel,
followed by a newline. If there is more than one argument, a space is printed
between successive arguments. See also print, printsp.


: (println '(a b c) 'def)
(a b c) def
-> def




(printsp 'any ..) -> any


Prints all any arguments to the current output channel,
followed by a space. If there is more than one argument, a space is printed
between successive arguments. See also print, println.


: (printsp '(a b c) 'def)
(a b c) def -> def




(prior 'lst1 'lst2) -> lst | NIL


Returns the cell in lst2 which immediately precedes the cell
lst1, or NIL if lst1 is not found in
lst2 or is the very first cell. == is used for comparison (pointer equality). See
also offset and memq.


: (setq L (1 2 3 4 5 6))
-> (1 2 3 4 5 6)
: (setq X (cdddr L))
-> (4 5 6)
: (prior X L)
-> (3 4 5 6)




(private) sym|lst


Intern symbols locally into an internal special namespace named 'priv'. This
namespace is always searched first, but never gets new symbols
automatically interned. (private) expects a single symbol
or a list of symbols immediately following in the current input stream.
See also pico, symbols, local, export, import and intern.


: (symbols 'myLib 'pico)
-> (pico)
myLib: (symbols)
-> (myLib pico)
myLib: (private) (foo bar)  # Intern 'foo' and 'bar' in 'priv'
myLib: (symbols)
-> (myLib pico)
myLib: (all 'priv)
-> (priv~foo priv~bar)




(proc 'sym ..) -> T


(Debug mode on Linux only) Shows a list of processes with command names
given by the sym arguments, using the system ps
utility. See also kids, kill and hd.


: (proc 'pil)
  PID  PPID  STARTED  SIZE %CPU WCHAN  CMD
16993  3267 12:38:21  1516  0.5 -      /usr/bin/picolisp /usr/lib/picolisp/lib.l /usr/bin/pil +
15731  1834 12:36:35  2544  0.1 -      /usr/bin/picolisp /usr/lib/picolisp/lib.l /usr/bin/pil app/main.l -main -go +
15823 15731 12:36:44  2548  0.0 -        /usr/bin/picolisp /usr/lib/picolisp/lib.l /usr/bin/pil app/main.l -main -go +
-> T




(prog . prg) -> any


Executes prg, and returns the result of the last expression.
See also nil, t, prog1 and prog2.


: (prog (print 1) (print 2) (print 3))
123-> 3




(prog1 'any1 . prg) -> any1


Executes all arguments, and returns the result of the first expression
any1. See also nil,
t, prog and prog2.


: (prog1 (print 1) (print 2) (print 3))
123-> 1




(prog2 'any1 'any2 . prg) -> any2


Executes all arguments, and returns the result of the second expression
any2. See also nil,
t, prog and prog1.


: (prog2 (print 1) (print 2) (print 3))
123-> 2




(prompt 'any . prg) -> any


Sets the prompt for non-REPL readline(3) calls to
any during the execution of prg. See also tty.


: (prompt "== " (line))
== abc
-> ("a" "b" "c")




(prop 'sym1|lst ['sym2|cnt ..] 'sym) -> var


Fetches a property for a property key sym from a symbol. That
symbol is sym1 (if no other arguments are given), or a symbol found
by applying the get algorithm to
sym1|lst and the following arguments. The property (the cons pair,
not just its value) is returned, suitable for direct (destructive) manipulations
with functions expecting a var argument. See also ::.


: (put 'X 'cnt 0)
-> 0
: (prop 'X 'cnt)
-> (0 . cnt)
: (inc (prop 'X 'cnt))        # Directly manipulate the property value
-> 1
: (get 'X 'cnt)
-> 1




(protect . prg) -> any


Executes prg, and returns the result of the last expression. If
a signal is received during that time, its handling will be delayed until the
execution of prg is completed. See also alarm, *Hup, *Sig[12] and kill.


: (protect (journal "db1.log" "db2.log"))
-> T




(prove 'lst ['lst]) -> lst


The Pilog interpreter. Tries to prove the query
list in the first argument, and returns an association list of symbol-value
pairs, or NIL if not successful. The query list is modified as a
side effect, allowing subsequent calls to prove for further
results. The optional second argument may contain a list of symbols; in that
case the successful matches of rules defined for these symbols will be traced.
See also goal, -> and unify.


: (prove (goal '((equal 3 3))))
-> T
: (prove (goal '((equal 3 @X))))
-> ((@X . 3))
: (prove (goal '((equal 3 4))))
-> NIL




(prune ['cnt])


Optimizes memory usage by pruning in-memory nodes of database trees.
Typically called repeatedly during bulk data imports. If cnt is
0, the pruning process is initialized, and if it is
NIL, further pruning will be disabled. Otherwise, all nodes which
have not been accessed (with fetch or
store) for cnt calls to
prune will be wiped. See
also lieu.


(in File1
   (prune 0)
   (while (someData)
      (new T '(+Cls1) ..)
      (at (0 . 10000) (commit) (prune 100)) ) )
(in File2
   (prune 0)
   (while (moreData)
      (new T '(+Cls2) ..)
      (at (0 . 10000) (commit) (prune 100)) ) )
(commit)
(prune)




(push 'var 'any ..) -> any


Implements a stack using a list in var. The any
arguments are cons'ed in front of the value list. See also push1, push1q, pop, shift, queue and fifo.


: (push 'S 3)              # Use the VAL of 'S' as a stack
-> 3
: S
-> (3)
: (push 'S 2)
-> 2
: (push 'S 1)
-> 1
: S
-> (1 2 3)
: (push S 999)             # Now use the CAR of the list in 'S'
-> 999
: (push S 888 777)
-> 777
: S
-> ((777 888 999 . 1) 2 3)




(push1 'var 'any ..) -> any


Maintains a unique list in var. Each any argument
is cons'ed in front of the value list only if it is not already a member of that list. See also push, push1q, pop and queue.


: (push1 'S 1 2 3)
-> 3
: S
-> (3 2 1)
: (push1 'S 2 4)
-> 4
: S
-> (4 3 2 1)




(push1q 'var 'any ..) -> any


Maintains a unique list in var. Each any argument
is cons'ed in front of the value list only if it is not already memq of that list (pointer equality). See also
push, push1, pop and queue.


: (push1q 'S 'a (1) 'b (2) 'c)
-> c
: S
-> (c (2) b (1) a)
: (push1q 'S 'b (1) 'd)       # (1) is not pointer equal to the previous one
-> d
: S
->  (d (1) c (2) b (1) a)     # (1) is twice in the list




(put 'sym1|lst ['sym2|cnt ..] 'any) -> any


Stores a new value any for a property key (or in the symbol
value for zero) in a symbol, or in a list. That symbol is sym1 (if
no other arguments are given), or a symbol found by applying the get algorithm to sym1|lst and the
following arguments. If the final destination is a list, the value is stored in
the CDR of an asoqed element (if the
key argument is a symbol), or the n'th element (if the key is a number). See
also =:.


: (put 'X 'a 1)
-> 1
: (get 'X 'a)
-> 1
: (prop 'X 'a)
-> (1 . a)

: (setq L '(A B C))
-> (A B C)
: (setq B 'D)
-> D
: (put L 2 0 'p 5)  # Store '5' under the 'p' property of the value of 'B'
-> 5
: (getl 'D)
-> ((5 . p))




(put! 'obj 'sym 'any) -> any


Transaction wrapper function for put. Note that for setting property values of
entities typically the put!> message is used. See also
new!, request!, set! and inc!.


(put! Obj 'cnt 0)  # Setting a property of a non-entity object




(putl 'sym1|lst1 ['sym2|cnt ..] 'lst) -> lst


Stores a complete new property list lst in a symbol. That
symbol is sym1 (if no other arguments are given), or a symbol found
by applying the get algorithm to
sym1|lst1 and the following arguments. All previously defined
properties for that symbol are lost. See also getl and maps.


: (putl 'X '((123 . a) flg ("Hello" . b)))
-> ((123 . a) flg ("Hello" . b))
: (get 'X 'a)
-> 123
: (get 'X 'b)
-> "Hello"
: (get 'X 'flg)
-> T




(pwd) -> sym


Returns the path to the current working directory. See also dir and cd.


: (pwd)
-> "/home/app"








pil21/doc/refQ.html0000644000000000000000000000577014533315641011241 0ustar  





Q





Q






(qsym . sym) -> lst


Returns a cons pair of the value and property list of sym. See
also quote, val and getl.


: (setq A 1234)
-> 1234
: (put 'A 'a 1)
-> 1
: (put 'A 'b 2)
-> 2
: (put 'A 'f T)
-> T
: (qsym . A)
-> (1234 f (2 . b) (1 . a))




(quote . any) -> any


Returns any unevaluated. The reader recognizes the single quote
char ' as a macro for this function. See also lit.


: 'a
-> a
: '(foo a b c)
-> (foo a b c)
: (quote (quote (quote a)))
-> ('('(a)))




(query 'lst ['lst]) -> flg


Handles an interactive Pilog query. The two
lst arguments are passed to prove. query displays each
result, waits for a key, and terminates when ESC is pressed. See also ?, pilog and solve.


: (query (goal '((append @X @Y (a b c)))))
 @X=NIL @Y=(a b c)
 @X=(a) @Y=(b c)
 @X=(a b) @Y=(c)
 @X=(a b c) @Y=NIL
-> NIL




(queue 'var 'any) -> any


Implements a queue using a list in var. The any
argument is (destructively) concatenated to the end of the value list. See also
push, pop, rid and fifo.


: (queue 'A 1)
-> 1
: (queue 'A 2)
-> 2
: (queue 'A 3)
-> 3
: A
-> (1 2 3)
: (pop 'A)
-> 1
: A
-> (2 3)




(quit ['any ['any]])


Stops current execution. If no arguments are given, all pending finally expressions are executed and control
is returned to the top level read-eval-print loop. Otherwise, an error handler
is entered. The first argument can be some error message, and the second might
be the reason for the error. See also Error
Handling.


: (de foo (X) (quit "Sorry, my error" X))
-> foo
: (foo 123)                                  # 'X' is bound to '123'
123 -- Sorry, my error                       # Error entered
? X                                          # Inspect 'X'
-> 123
?                                            # Empty line: Exit
:








pil21/doc/refR.html0000644000000000000000000007165014767053735011256 0ustar  





R





R






*Rule


A global variable holding the current Pilog
rule symbol. It is cleared at the beginning of a new REPL. See also be and clause.


: (be likes (John Mary))
-> likes
: *Rule
-> likes




*Run


This global variable can hold a list of prg expressions which
are used during key, sync, wait and listen. The first element of each expression
must either be a positive number (thus denoting a file descriptor to wait for)
or a negative number (denoting a timeout value in milliseconds (in that case
another number must follow to hold the remaining time)). A poll(2)
system call is performed with these values, and the corresponding
prg body is executed when input data are available or when a
timeout occurred (with @ set to the file
descriptor or timeout value). See also task.


: (de *Run (-2000 0 (println '2sec)))     # Install 2-sec-timer
-> *Run
: 2sec                                    # Prints "2sec" every 2 seconds
2sec
2sec
                                          # (Ctrl-D) Exit
$




+Ref


Prefix class for maintaining non-unique indexes to +relations, a subclass of +index. Accepts an optional argument for a
+Hook attribute. See also Database.


(rel tel (+Fold +Ref +String))  # Phone number with folded, non-unique index




+Ref2


Prefix class for maintaining a secondary ("backing") index to +relations. Can only be used as a prefix
class to +Key or +Ref. It maintains an index in the current
(sub)class, in addition to that in one of the superclasses (must be a
+Ref), to allow (sub)class-specific queries. See also Database.


(class +Ord +Entity)             # Order class
(rel nr (+Need +Ref +Number))    # Order number
...
(class +EuOrd +Ord)              # EU-specific order subclass
(rel nr (+Ref2 +Key +Number))    # Order number with backing index




+relation


Abstract base class of all database relations. Relation objects are usually
defined with rel. The class hierarchy
includes the classes +Any, +Bag, +Bool, +Number, +Date, +Time, +Symbol, +String, +Link, +Joint and +Blob, and the prefix classes +Hook, +Hook2, +index, +Key, +Ref, +Ref2, +Idx, +IdxFold, +Sn, +Fold, +Aux, +UB, +Dep, +List, +Need, +Mis, +Alt and +Swap. See also Database and +Entity.


Messages to relation objects include


mis> (Val Obj)       # Return error if mismatching type or value
has> (Val X)         # Check if the value is present
put> (Obj Old New)   # Put new value
rel> (Obj Old New)   # Maintain relational structures
lose> (Obj Val)      # Delete relational structures
keep> (Obj Val)      # Restore deleted relational structures
zap> (Obj Val)       # Clean up relational structures




(rand ['cnt1 'cnt2] | ['T]) -> cnt | flg


Returns a pseudo random number in the range of the positive short numbers
cnt1 and cnt2 (or -2147483648 .. +2147483647 if no
arguments are given). If the argument is T, a boolean value
flg is returned. Note that if a range is given, the results are
"more random" because the higher bits of the internal generator are used. See
also seed.


: (rand 3 9)
-> 3
: (rand 3 9)
-> 7




(range 'num1 'num2 ['num3]) -> lst


Produces a list of numbers in the range num1 through
num2. When num3 is non-NIL, it is used
to increment num1 (if it is smaller than num2) or to
decrement num1 (if it is greater than num2). See also
need.


: (range 1 6)
-> (1 2 3 4 5 6)
: (range 6 1)
-> (6 5 4 3 2 1)
: (range -3 3)
-> (-3 -2 -1 0 1 2 3)
: (range 3 -3 2)
-> (3 1 -1 -3)




range/3


Pilog predicate that succeeds if the first
argument is in the range of the result of applying the get algorithm to the following arguments.
Typically used as filter predicate in select/3 database queries. See also
Comparing, isa/2, same/3, bool/3, head/3, fold/3, part/3 and tolr/3.


: (?
   @Nr (1 . 5)  # Numbers between 1 and 5
   @Nm "part"
   (select (@Item)
      ((nr +Item @Nr) (nm +Item @Nm))
      (range @Nr @Item nr)
      (part @Nm @Item nm) ) )
 @Nr=(1 . 5) @Nm="part" @Item={B1}
 @Nr=(1 . 5) @Nm="part" @Item={B2}
-> NIL




(rank 'any 'lst ['flg]) -> lst


Searches a ranking list. lst should be sorted. Returns the
element from lst with a maximal CAR less or equal to
any (if flg is NIL), or with a minimal
CAR greater or equal to any (if flg is
non-NIL), or NIL if no match is found. See also
assoc and Comparing.


: (rank 0 '((1 . a) (100 . b) (1000 . c)))
-> NIL
: (rank 50 '((1 . a) (100 . b) (1000 . c)))
-> (1 . a)
: (rank 100 '((1 . a) (100 . b) (1000 . c)))
-> (100 . b)
: (rank 300 '((1 . a) (100 . b) (1000 . c)))
-> (100 . b)
: (rank 9999 '((1 . a) (100 . b) (1000 . c)))
-> (1000 . c)
: (rank 50 '((1000 . a) (100 . b) (1 . c)) T)
-> (100 . b)




(rassoc 'any 'lst) -> lst


Reverse assoc. Returns the first
element from lst with its CDR equal to any, or
NIL if no match is found. See also rasoq and asoq.


: (rassoc 7 '((999 1 2 3) ("b" . 7) ("ok" "Hello")))
-> ("b" . 7)
: (rassoc (1 2 3) '((999 1 2 3) ("b" . 7) ("ok" "Hello")))
-> (999 1 2 3)
: (rassoc 'u '((999 1 2 3) ("b" . 7) ("ok" "Hello")))
-> NIL




(rasoq 'any 'lst) -> lst


Reverse asoq. Returns the first
element from lst with any as its CDR, or
NIL if no match is found. == is used for comparison (pointer equality). See
also assoc and rassoc.


: (rasoq 'b '((1 . a) (2 . b) (3 . c))) )
-> (2 . b)
: (rasoq "b" '((1 . a) (2 . b) (3 . c))) )
-> NIL




(raw ['flg]) -> flg


Console mode control function. When called without arguments, it returns the
current console mode (NIL for "cooked mode"). Otherwise, the
console is set to the new state. See also key.


$ pil +
: (raw)
-> NIL
: (raw T)
-> T
...  # Raw mode, no echo!




(rc 'sym 'any1 ['any2 ['any3 'any4..]]) -> any


Fetches a value from a resource file sym, or stores one or more
key-value pairs (any1 . any2) in that file, using the key
any1 (and optionally any3 etc. for multiple stores).
All values are stored in a list in the file, using assoc. During the whole operation, the file is
exclusively locked with ctl.


: (info "a.rc")               # File exists?
-> NIL                        # No
: (rc "a.rc" 'a 1)            # Store 1 for 'a'
-> 1
: (rc "a.rc" 'b (2 3 4))      # Store (2 3 4) for 'b'
-> (2 3 4)
: (rc "a.rc" 'c 'b)           # Store 'b' for 'c'
-> b
: (info "a.rc")               # Check file
-> (28 733124 . 61673)
: (in "a.rc" (echo))          # Display it
((c . b) (b 2 3 4) (a . 1))
-> T
: (rc "a.rc" 'c)              # Fetch value for 'c'
-> b
: (rc "a.rc" @)               # Fetch value for 'b'
-> (2 3 4)




(rd ['sym]) -> any


(rd 'cnt) -> num | NIL


Binary read: Reads one item from the current input channel in encoded binary
format. When called with a cnt argument (second form), that number
of raw bytes (in big endian format if cnt is positive, otherwise
little endian) is read as a single number. Upon end of file, if the
sym argument is given, it is returned, otherwise NIL.
See also pr, tell, hear and wr.


: (out "x" (pr 'abc "EOF" 123 "def"))
-> "def"
: (in "x" (rd))
-> abc
: (in "x"
   (make
      (use X
         (until (== "EOF" (setq X (rd "EOF")))  # '==' detects end of file
            (link X) ) ) ) )
-> (abc "EOF" 123 "def")  # as opposed to reading a symbol "EOF"

: (in "/dev/urandom" (rd 20))
-> 396737673456823753584720194864200246115286686486




(read ['sym1 ['sym2]]) -> any


Reads one item from the current input channel. NIL is returned
upon end of file. When called without arguments, an arbitrary Lisp expression is
read. Otherwise, a token (a number, an internal symbol, a transient symbol (for
punctuation), or a list of symbols (for a string)) is read. In that case,
sym1 specifies which set of characters to accept for continuous
symbol names (in addition to the standard alphanumerical characters), and
sym2 an optional comment character. See also any, str, line, skip and eof.


: (list (read) (read) (read))    # Read three things from console
123                              # a number
abcd                             # a symbol
(def                             # and a list
ghi
jkl
)
-> (123 abcd (def ghi jkl))
: (make (while (read "_" "#") (link @)))
abc = def_ghi("xyz"+-123) # Comment
NIL
-> (abc "=" def_ghi "(" ("x" "y" "z") "+" "-" 123 ")")




(recur fun) -> any


(recurse ..) -> any


Implements anonymous recursion, by defining the function
recurse on the fly. During the execution of fun, the
symbol recurse is bound to the function definition
fun. See also let,
lambda and tco.


: (de fibonacci (N)
   (when (lt0 N)
      (quit "Bad fibonacci" N) )
   (recur (N)
      (if (>= 2 N)
         1
         (+
            (recurse (dec N))
            (recurse (- N 2)) ) ) ) )
-> fibonacci
: (fibonacci 22)
-> 17711
: (fibonacci -7)
-7 -- Bad fibonacci




(redef sym . fun) -> sym


Redefines sym in terms of itself. The current definition is
saved in a new symbol, which is substituted for each occurrence of
sym in fun, and which is also returned. See also
de, undef, daemon and patch.


: (de hello () (prinl "Hello world!"))
-> hello
: (pp 'hello)
(de hello NIL
   (prinl "Hello world!") )
-> hello

: (redef hello (A B)
   (println 'Before A)
   (prog1 (hello) (println 'After B)) )
-> "hello"
: (pp 'hello)
(de hello (A B)
   (println 'Before A)
   (prog1 ("hello") (println 'After B)) )
-> hello
: (hello 1 2)
Before 1
Hello world!
After 2
-> "Hello world!"

: (redef * @
   (msg (rest))
   (pass *) )
-> "*"
: (* 1 2 3)
(1 2 3)
-> 6

: (redef + @
   (pass (ifn (num? (next)) pack +) (arg)) )
-> "+"
: (+ 1 2 3)
-> 6
: (+ "a" 'b '(c d e))
-> "abcde"





(rel sym lst [any ..]) -> any


Defines a relation for sym in the current class *Class, using lst as the list of
classes for that relation, and possibly additional arguments any
for its initialization. See also Database, class, extend, dm and var.


(class +Person +Entity)
(rel nm  (+List +Ref +String))            # Names
(rel tel (+Ref +String))                  # Telephone
(rel adr (+Joint) prs (+Address))         # Address

(class +Address +Entity)
(rel cit (+Need +Hook +Link) (+City))     # City
(rel str (+List +Ref +String) cit)        # Street
(rel prs (+List +Joint) adr (+Person))    # Inhabitants

(class +City +Entity)
(rel nm  (+List +Ref +String))            # Zip / Names




(release 'sym) -> NIL


Releases the mutex represented by the file 'sym'. This is the reverse
operation of acquire.


: (release "sema1")
-> NIL




(remark 'any)


Global variable holding a (possibly empty) function, which will be called
when a value is printed in the REPL. It can be used to provide further
information about that value.


: (date)
-> 739542  # 2024-12-16
: (scl 3)
-> 3  # 0.003
: 12.3
-> 12300  # 12.300
: (date)
-> 739542  # 2024-12-16 739.542



remote/2


Pilog predicate for remote database queries. It
takes a list and an arbitrary number of clauses. The list should contain a Pilog
variable for the result in the CAR, and a list of resources in the CDR. The
clauses will be evaluated on remote machines according to these resources. Each
resource must be a cons pair of two functions, an "out" function in the CAR, and
an "in" function in the CDR. See also *Ext, revolve/2, select/3 and db/3.


(setq *Ext           # Set up external offsets
   (mapcar
      '((@Host @Ext)
         (cons @Ext
            (curry (@Host @Ext (Sock)) (Obj)
               (when (or Sock (setq Sock (connect @Host 4040)))
                  (ext @Ext
                     (out Sock (pr (cons 'qsym Obj)))
                     (prog1
                        (in Sock (rd))
                        (unless @
                           (close Sock)
                           (off Sock) ) ) ) ) ) ) )
      '("localhost")
      '(20) ) )

(de rsrc ()  # Simple resource handler, ignoring errors or EOFs
   (extract
      '((@Ext Host)
         (let? @Sock (connect Host 4040)
            (cons
               (curry (@Ext @Sock) (X)  # out
                  (ext @Ext (out @Sock (pr X))) )
               (curry (@Ext @Sock) ()  # in
                  (ext @Ext (in @Sock (rd))) ) ) ) )
      '(20)
      '("localhost") ) )

: (?
   @Nr (1 . 3)
   @Sup 2
   @Rsrc (rsrc)
   (remote (@Item . @Rsrc)
      (db nr +Item @Nr @Item)
      (val @Sup @Item sup nr) )
   (show @Item) )
{AF2} (+Item)
   pr 1250
   inv 100
   sup {AG2}
   nm "Spare Part"
   nr 2
 @Nr=(1 . 3) @Sup=2 @Rsrc=((((X) (ext 20 (out 3 (pr X)))) NIL (ext 20 (in 3 (rd))))) @Item={AF2}
-> NIL




(remove 'cnt 'lst) -> lst


Removes the element at position cnt from lst. This
is a non-destructive operation. See also insert, place, append, delete and replace.


: (remove 3 '(a b c d e))
-> (a b d e)
: (remove 1 '(a b c d e))
-> (b c d e)
: (remove 9 '(a b c d e))
-> (a b c d e)




(repeat) -> lst


Makes the current Pilog definition "tail
recursive", by closing the previously defined rules in the definition's T
property to a circular list. See also repeat/0 and be.


(be a (1))     # Define three facts
(be a (2))
(be a (3))
(repeat)       # Unlimited supply

: (? (a @N))
 @N=1
 @N=2
 @N=3
 @N=1
 @N=2
 @N=3.         # Stop
-> NIL




repeat/0


Pilog predicate that always succeeds, also on
backtracking. See also repeat and
true/0.


: (be integer (@I)   # Generate unlimited supply of integers
   (^ @C (box 0))    # Init to zero
   (repeat)          # Repeat from here
   (^ @I (inc @C)) )
-> integer

: (? (integer @X))
 @X=1
 @X=2
 @X=3
 @X=4.               # Stop
-> NIL




(replace 'lst 'any1 'any2 ..) -> lst


Replaces in lst all occurrences of any1 with
any2. For optional additional argument pairs, this process is
repeated. This is a non-destructive operation. See also append, delete, insert, remove and place.


: (replace '(a b b a) 'a 'A)
-> (A b b A)
: (replace '(a b b a) 'b 'B)
-> (a B B a)
: (replace '(a b b a) 'a 'B 'b 'A)
-> (B A A B)




(request 'typ 'sym ['hook] 'val ..) -> obj


Returns a database object. If a matching object cannot be found (using
db), a new object of the given type is
created (using new). See also obj.


: (request '(+Item) 'nr 2)
-> {B2}




(request! 'typ 'sym ['hook] 'val ..) -> obj


Transaction wrapper function for request.
See also new!, set!, put! and inc!.





(rest) -> lst


Can only be used inside functions with a variable number of arguments (with
@). Returns the list of all remaining arguments from the internal
list. See also args, next, arg and pass.


: (de foo @ (println (rest)))
-> foo
: (foo 1 2 3)
(1 2 3)
-> (1 2 3)




(retract) -> lst


Removes a Pilog fact or rule. See also be, clause, asserta and assertz.


: (be a (1))
-> a
: (be a (2))
-> a
: (be a (3))
-> a

: (retract '(a (2)))
-> (((1)) ((3)))

:  (? (a @N))
 @N=1
 @N=3
-> NIL




retract/1


Pilog predicate that removes a fact or rule.
See also retract, asserta/1 and assertz/1.


: (be a (1))
-> a
: (be a (2))
-> a
: (be a (3))
-> a

: (? (retract (a 2)))
-> T
: (rules 'a)
1 (be a (1))
2 (be a (3))
-> a




(rev 'cnt1 'cnt2) -> cnt


Reverses the lowest cnt1 bits of cnt2. See also
>> and hash.


: (bin (rev 4 (bin "0101")))
-> "1010"
: (rev 32 1)
-> 2147483648
: (hex @)
-> "80000000"
: (rev 32 (hex "E0000000"))
-> 7




(reverse 'lst) -> lst


Returns a reversed copy of lst. See also flip.


: (reverse (1 2 3 4))
-> (4 3 2 1)




(rewind) -> flg


Sets the file position indicator for the current output stream to the
beginning of the file, and truncates the file length to zero. Returns
T when successful. See also flush.


: (out "a" (prinl "Hello world"))
-> "Hello world"
: (in "a" (echo))
Hello world
-> T
: (info "a")
-> (12 733216 . 53888)
: (out "a" (rewind))
-> T
: (info "a")
-> (0 733216 . 53922)




revolve/2


Pilog predicate for quasi-parallel evaluation
of clauses. It takes a list and an arbitrary number of clauses. The list should
contain a Pilog variable for the result in the CAR, another Pilog variable for
passing the values in the CADR, and a list of values in the CDDR. The clauses
will be evaluated in a round-robin fashion. See also remote/2.


: (solve
   (quote
      @Rsrc '((1 2 3 4) (5 6 7 8) (a b c))
      (revolve (@Res @Lst . @Rsrc)
         (lst @Res @Lst) ) )
   @Res )
-> (1 5 a 2 6 b 3 7 c 4 8)




(rid 'var 'any) -> any


Destructively removes all occurrences of any from the (possibly
circular) value of var, and returns the new value. See also
fifo, queue, cut and del.


$: (off E)
-> NIL
: (fifo 'E 1 2 3 2 4 2)
-> 2
: E
-> (2 1 2 3 2 4 .)
$: (rid 'E 2)
-> (4 1 3 .)
$: (rid 'E 4)
-> (3 1 .)




(rollback) -> flg


Cancels a transaction, by discarding all modifications of external symbols.
See also commit.


: (pool "db")
-> T
# .. Modify external objects ..
: (rollback)            # Rollback
-> T




(root 'tree) -> (num . sym)


Returns the root of a database index tree, with the number of entries in
num, and the base node in sym. See also tree.


: (root (tree 'nr '+Item))
-> (6 . {H1})




(rot 'lst ['cnt]) -> lst


Rotate: The contents of the cells of lst are (destructively)
shifted right, and the value from the last cell is stored in the first cell.
Without the optional cnt argument, the whole list is rotated,
otherwise only the first cnt elements. See also flip .


: (rot (1 2 3 4))             # Rotate all four elements
-> (4 1 2 3)
: (rot (1 2 3 4 5 6) 3)       # Rotate only the first three elements
-> (3 1 2 4 5 6)




(round 'num1 ['num2]) -> sym


Formats a number num1 with num2 decimal places,
according to the current scale *Scl.
num2 defaults to 3. See also Numbers
and format.


: (scl 4)               # Set scale to 4
-> 4  # 0.0004
: (round 123456)        # Format with three decimal places
-> "12.346"
: (round 123456 2)      # Format with two decimal places
-> "12.35"
: (format 123456 *Scl)  # Format with full precision
-> "12.3456"




(rt cnt . prg) -> any


Real/Runtime measurement: Executes prg, then (destructively)
adds the number of elapsed microseconds to the cnt parameter. Thus,
cnt will finally contain the total number of microseconds spent in
prg. See also usec.


: (de foo ()                        # Define function with empty loop
   (rt 0 (do 999999999)) )
-> foo
: (foo)                             # Execute it
-> NIL
: (pp 'foo)
(de foo NIL
   (rt 2022324 (do 999999999)) )    # 'rt' incremented 'cnt' by 2022324
-> foo




(rules 'sym ..) -> sym


Prints all rules defined for the sym arguments. See also Pilog and be.


: (rules 'member 'append)
1 (be member (@X (@X . @)))
2 (be member (@X (@ . @Y)) (member @X @Y))
1 (be append (NIL @X @X))
2 (be append ((@A . @X) @Y (@A . @Z)) (append @X @Y @Z))
-> append




(run 'any ['cnt]) -> any


If any is an atom, run behaves like eval. Otherwise any is a list,
which is evaluated in sequence. The last result is returned. If an offset
cnt is given, the value of @ in the cnt'th call environment
is used during that evaluation. cnt should be greater than zero.
See also up.


: (run '((println (+ 1 2 3)) (println 'OK)))
6
OK
-> OK

: (de f (N . Prg)
   (when (gt0 N)
      (prinl "1: @ = " @)  # '@' is 4, as 'N' is 4 from the call below
      (run Prg 1) ) )  # but printed is 3, as it was set by 'and'
-> f

: (and 3 (f 4 (prinl "2: @ = " @)))  # '@' was 3 when 'f' was called
1: @ = 4
2: @ = 3
-> 3








pil21/doc/refS.html0000644000000000000000000012103114760113620011223 0ustar  





S





S






*Scl


A global variable holding the current fixpoint input scale. See also Numbers and scl.


: (str "123.45")  # Default value of '*Scl' is 0
-> (123)
: (setq *Scl 3)
-> 3
: (str "123.45")
-> (123450)

: 123.4567
-> 123457
: 12.3456
-> 12346




*Sig1


*Sig2


Global variables holding (possibly empty) prg bodies, which
will be executed when a SIGUSR1 signal (or a SIGUSR2 signal, respectively) is
sent to the current process. See also alarm, *Hup, sigio, *TStp[12], *Winch and *Term.


: (de *Sig1 (msg 'SIGUSR1))
-> *Sig1




*Solo


A global variable indicating exclusive database access. Its value is
0 initially, set to T (or NIL) during
cooperative database locks when lock
is successfully called with a NIL (or non-NIL)
argument. See also *Zap.


: *Solo
-> 0
: (lock *DB)
-> NIL
: *Solo
-> NIL
: (rollback)
-> T
: *Solo
-> 0
: (lock)
-> NIL
: *Solo
-> T
: (rollback)
-> T
: *Solo
-> T




+Sn


Prefix class for maintaining indexes according to a modified soundex
algorithm, for tolerant name searches, to +String relations. Typically used in
combination with the +Idx prefix
class. See also Database.


(rel nm (+Sn +Idx +String))  # Name




+String


Class for string (transient symbol) relations, a subclass of +Symbol. Accepts an optional argument for
the string length (currently not used). See also Database.


(rel nm (+Sn +Idx +String))  # Name, indexed by soundex and substrings




+Swap


Prefix class for +relations
where the data are to be stored in the value of a separate external symbol
instead of the relation's object. Typically used for data which are relatively
large and/or rarely accessed. Doesn't work with bidirectional relations
(+Joint or +index). See also Database.


(rel pw (+Swap +String))               # Password
(rel nr (+Swap +List +Number))         # List of bignums




+Symbol


Class for symbolic relations, a subclass of +relation. Objects of that class typically
maintain internal symbols, as opposed to the more often-used +String for transient symbols. See also Database.


(rel perm (+List +Symbol))  # Permission list




same/3


Pilog predicate that succeeds if the first
argument matches the result of applying the get algorithm to the following arguments.
Typically used as filter predicate in select/3 database queries. See also
isa/2, bool/3, range/3, head/3, fold/3, part/3 and tolr/3.


: (?
   @Nr 2
   @Nm "Spare"
   (select (@Item)
      ((nr +Item @Nr) (nm +Item @Nm))
      (same @Nr @Item nr)
      (head @Nm @Item nm) ) )
 @Nr=2 @Nm="Spare" @Item={B2}




(scan 'tree ['fun] ['any1] ['any2] ['flg])


Scans through a database tree by applying fun to all key-value
pairs. fun should be a function accepting two arguments for key and
value. It defaults to println.
any1 and any2 may specify a range of keys. If
any2 is greater than any1, the traversal will be in
opposite direction. Note that the keys need not to be atomic, depending on the
application's index structure. If flg is non-NIL,
partial keys are skipped. See also tree, iter, init and step.


: (scan (tree 'nm '+Item))
("ASLRSNSTRSTN" {B3} . T) {B3}
("Additive" {B4}) {B4}
("Appliance" {B6}) {B6}
("Auxiliary Construction" . {B3}) {B3}
("Construction" {B3}) {B3}
("ENNSNNTTTF" {B4} . T) {B4}
("Enhancement Additive" . {B4}) {B4}
("Fittings" {B5}) {B5}
("GTSTFLNS" {B6} . T) {B6}
("Gadget Appliance" . {B6}) {B6}
...

: (scan (tree 'nm '+Item) println NIL T T)  # 'flg' is non-NIL
("Auxiliary Construction" . {B3}) {B3}
("Enhancement Additive" . {B4}) {B4}
("Gadget Appliance" . {B6}) {B6}
("Main Part" . {B1}) {B1}
("Metal Fittings" . {B5}) {B5}
("Spare Part" . {B2}) {B2}
-> NIL




(scl 'num [. prg]) -> num


If prg is given, it binds *Scl dynamically to num during the
execution of prg. Otherwise, it sets *Scl globally to num. See also Numbers.


: (scl 0)
-> 0
: (str "123.45")
-> (123)
: (scl 1)
-> 1  # 0.1
: (read)
123.45
-> 1235  # 123.5
: (scl 3)
-> 3  # 0.003
: (str "123.45")
-> (123450)
: (scl 1 (str "123.45"))
-> (1235)
: *Scl
-> 3  # 0.003




(script 'any ..) -> any


The first any argument is loaded, with the remaining arguments passed as variable arguments. They can be
accessed with next, arg, args and rest. With that, the syntax in the script is
the same as that in the body of a function with variable arguments (see lambda expressions, "when the CAR is the symbol @").


$ cat x
(* (next) (next))

$ pil +
: (script "x" 3 4)
-> 12




(search 'any 'lst ['any 'lst ..] ['fun]) -> lst


(search 'lst) -> obj | NIL


Searches the database for an arbitrary number
of any criteria. The first form returns a list holding a query
structure according to the corresponding lst lists of relation
specifications. A search criterion can be an atom for an exact search, or a cons
pair for a range search. A relation specification can be a list (var cls
[hook]) for an index search, a cons pair (sym . sym) for the
two endpoints of a +Joint, or - only
instead of the first specification in lst - two functions: A
generator function and a filter function. The final fun argument
may optionally filter and possibly modify each result. The second form takes a
query structure as returned from the first form, and returns the next result (an
object) or NIL (if there are no more matching results).
search is described in detail in The 'search'
Function. See also init, step and collect.


: (for
   (Q
      (search
         (2 . 5) '((nr +Item))  # Select all items with numbers between 2 and 5
         "Active" '((nm +CuSu) (sup +Item)) )  # and suppliers matching "Active"
      (search Q) )
   (show @) )
{B3} (+Item)
   sup {C1}
   nr 3
   pr 15700
   inv 100
   nm "Auxiliary Construction"
{B5} (+Item)
   sup {C1}
   nr 5
   pr 7980
   inv 100
   nm "Metal Fittings"
-> {B5}




(sect 'lst1 'lst2) -> lst


Returns the intersection of list arguments, all elements which are both in
lst1 and in lst2. See also diff.


: (sect (1 2 3 4) (3 4 5 6))
-> (3 4)
: (sect (1 2 3) (4 5 6))
-> NIL




(seed 'any) -> cnt


Initializes the random generator's seed, and returns a pseudo random number
in the range -2147483648 .. +2147483647. See also rand and hash.


: (seed "init string")
-> -417605464
: (rand)
-> -1061886707
: (rand)
-> 822065436

: (seed (time))
-> 128285383




(seek 'fun 'lst ..) -> lst


Applies fun to lst and all successive CDRs, until
non-NIL is returned. Returns the tail of lst starting
with that element (and stores the non-NIL value in the global
variable @@), or NIL if
fun did not return non-NIL for any element of
lst. When additional lst arguments are given, they are
passed to fun in the same way. See also find, pick.


: (seek '((X) (> (car X) 9)) (1 5 8 12 19 22))
-> (12 19 22)




(select [var ..] cls [hook] [var val ..]) -> obj | NIL


(Debug mode only) Interactive database function, loosely modelled after the
SQL 'SELECT' command. A front-end to search. When called with only a
cls argument, select steps through all objects of that
class, and shows their complete
contents (this is analog to 'SELECT * from CLS'). If cls is
followed by attribute/value specifications, the search is limited to these
values (this is analog to 'SELECT * from CLS where VAR = VAL'). If before
cls one or several attribute names are supplied, only these
attribute (instead of the full show) are printed. These attribute
specifications may also be lists, then those will be evaluated to retrieve
related data. After each step, select waits for a key, and
terminates when ESC is pressed. The global variable This is set to the last result. See also Database and Pilog.


: (select +Item)                       # Show all items
{B1} (+Item)
   nr 1
   nm "Main Part"
   pr 29900
   inv 100
   sup {C1}
{B2} (+Item)
   nr 2
   nm "Spare Part"
   pr 1250
   inv 100
   sup {C2}
-> {B2}                                # ESC was pressed

: (select +Item nr 3)                  # Show only item 3
{B3} (+Item)
   nr 3
   sup {C1}
   pr 15700
   nm "Auxiliary Construction"
   inv 100
-> NIL

# Show selected attributes for items 3 through 3
: (select nr nm pr (: sup nm) +Item nr (3 . 5))
3 "Auxiliary Construction" 157.00 "Active Parts Inc." {B3}
4 "Enhancement Additive" 9.99 "Seven Oaks Ltd." {B4}
5 "Metal Fittings" 79.80 "Active Parts Inc." {B5}
-> NIL




select/3


Pilog database predicate that allows combined
searches over +index and other
relations. It takes a list of Pilog variables, a list of generator clauses, and
an arbitrary number of filter clauses. The functionality is described in detail
in The 'select' Predicate. See also db/3, isa/2, same/3, bool/3, range/3, head/3, fold/3, part/3, tolr/3 and remote/2.


: (?
   @Nr (2 . 5)          # Select all items with numbers between 2 and 5
   @Sup "Active"        # and suppliers matching "Active"
   (select (@Item)                                  # Bind results to '@Item'
      ((nr +Item @Nr) (nm +CuSu @Sup (sup +Item)))  # Generator clauses
      (range @Nr @Item nr)                          # Filter clauses
      (part @Sup @Item sup nm) ) )
 @Nr=(2 . 5) @Sup="Active" @Item={B3}
 @Nr=(2 . 5) @Sup="Active" @Item={B5}
-> NIL




(send 'msg 'obj ['any ..]) -> any


Sends the message msg to the object obj,
optionally with arguments any. If the message cannot be located in
obj, its classes and superclasses, an error "Bad
message" is issued. See also OO Concepts,
try, method, meth, super and extra.


: (send 'stop> Dlg)  # Equivalent to (stop> Dlg)
-> NIL




(seq 'cnt|sym1) -> sym | NIL


Sequential single step: Returns the first external symbol in the
cnt'th database file, or the next external symbol following
sym1 in the database, or NIL when the end of the
database is reached. See also free.


: (pool "db")
-> T
: (seq *DB)
-> {2}
: (seq @)
-> {3}




(set 'var 'any ..) -> any


Stores new values any in the var arguments. See
also setq, val, swap, con and def.


: (set 'L '(a b c)  (cdr L) 999)
-> 999
: L
-> (a 999 c)




(set! 'obj 'any) -> any


Transaction wrapper function for set. Note that for setting the value of entities
typically the set!> message
is used. See also new!, request!, put! and inc!.


(set! Obj (* Count Size))  # Setting a non-entity object to a numeric value




(setq var 'any ..) -> any


Stores new values any in the var arguments. See
also set, val and def.


: (setq  A 123  B (list A A))  # Set 'A' to 123, then 'B' to (123 123)
-> (123 123)




(shadows ['flg]) -> lst


(Debug mode only) Returns a list of all symbols shadowing other symbols in
the current namespace search order.
When flg non-NIL, these and the overshadowed
symbols are printed as a side effect. See also symbols and namespaces.


: (symbols '(vip pico))
-> (pico)
vip: (shadows T)
   vi pico~vi
   cmd pico~cmd
   shift pico~shift
-> (vi cmd shift)
vip: (symbols '(pico))
-> (vip pico)

$ pty  # After starting "chess" in PilBox
chess: (shadows T)
   field pico~field
   wake android~wake
   queue pico~queue
   alarm pico~alarm
-> (field wake queue alarm)
chess: (nsp 'field)
-> chess
chess: (nsp 'wake)
-> simul
chess: (nsp 'alarm)
-> android




(shift 'var) -> any


Sets the list in var to its CDR. (shift 'var) is
equivalent to (set 'var (cdr (val 'var))). See also push and pop.


: (setq A (1 2 3))
-> (1 2 3)
: (shift 'A)
-> (2 3)
: A
-> (2 3)




(show 'any ['sym|cnt ..]) -> any


Shows the name, value and property list of a symbol found by applying the
get algorithm to any and
the following arguments. See also view.


: (setq A 123456)
-> 123456
: (put 'A 'x 1)
-> 1
: (put 'A 'lst (9 8 7))
-> (9 8 7)
: (put 'A 'flg T)
-> T

: (show 'A)
A 123456
   flg
   lst (9 8 7)
   x 1
-> A

: (show 'A 'lst 2)
-> 8




show/1


Pilog predicate that always succeeds, and shows
the name, value and property list of the argument symbol. See also show.


: (? (db nr +Item 2 @Item) (show @Item))
{B2} (+Item)
   nm "Spare Part"
   nr 2
   pr 1250
   inv 100
   sup {C2}
 @Item={B2}
-> NIL




(sigio 'cnt . prg) -> cnt


Sets a signal handler prg for SIGIO on the file descriptor
cnt. Returns the file descriptor. See also alarm, *Hup, *Winch, *Sig[12], *TStp[12] and *Term.


# First session
: (sigio (setq *SigSock (port T 4444))  # Register signal handler at UDP port
   (while (udp *SigSock)                # Queue all received data
      (fifo '*SigQueue @) ) )
-> 3

# Second session
: (for I 7 (udp "localhost" 4444 I))  # Send numbers to first session

# First session
: (fifo '*SigQueue)
-> 1
: (fifo '*SigQueue)
-> 2




(size 'any) -> cnt


Returns the "size" of any. For numbers this is the number of
bytes needed for the value, for external symbols it is the number of bytes it
would occupy in the database, for other symbols it is the number of bytes
occupied by the UTF-8 representation of the name, and for lists it is the total
number of cells in this list and all its sublists. See also length and bytes.


: (size "abc")
-> 3
: (size "äbc")
-> 4
: (size 127)  # One byte
-> 1
: (size 128)  # Two bytes (eight bits plus sign bit!)
-> 2
: (size (1 (2) 3))
-> 4
: (size (1 2 3 .))
-> 3






Skips all whitespace (and comments if any is given) in the
input stream. Returns the next available character, or NIL upon end
of file. See also peek and eof.


$ cat a
# Comment
abcd
$ pil +
: (in "a" (skip "#"))
-> "a"




(solve 'lst [. prg]) -> lst


Evaluates a Pilog query and, returns the list
of result sets. If prg is given, it is executed for each result
set, with all Pilog variables bound to their matching values, and returns a list
of the results. See also pilog,
?, goal and prove.


: (solve '((append @X @Y (a b c))))
-> (((@X) (@Y a b c)) ((@X a) (@Y b c)) ((@X a b) (@Y c)) ((@X a b c) (@Y)))

: (solve '((append @X @Y (a b c))) @X)
-> (NIL (a) (a b) (a b c))




(sort 'lst ['fun]) -> lst


Returns a sorted list by destructively exchanging the elements of
lst. If fun is given, it is used as a "less than"
predicate for comparisons. Typically, sort is used in combination
with by, giving shorter and often more efficient
solutions than with the predicate function. See also Comparing, group, maxi, mini and uniq.


: (sort '(a 3 1 (1 2 3) d b 4 T NIL (a b c) (x y z) c 2))
-> (NIL 1 2 3 4 a b c d (1 2 3) (a b c) (x y z) T)
: (sort '(a 3 1 (1 2 3) d b 4 T NIL (a b c) (x y z) c 2) >)
-> (T (x y z) (a b c) (1 2 3) d c b a 4 3 2 1 NIL)
: (by cadr sort '((1 4 3) (5 1 3) (1 2 4) (3 8 5) (6 4 5)))
-> ((5 1 3) (1 2 4) (1 4 3) (6 4 5) (3 8 5))




(space ['cnt]) -> cnt


Prints cnt spaces, or a single space when cnt is
not given. See also beep, prin and char.


: (space)
 -> 1
: (space 1)
 -> 1
: (space 2)
  -> 2




(sp? 'any) -> flg


Returns T when the argument any is
NIL, or if it is a string (symbol) that consists only of whitespace
characters.


: (sp? "  ")
-> T
: (sp? "ABC")
-> NIL
: (sp? 123)
-> NIL




(split 'lst 'any ..) -> lst


Splits lst at all places containing an element any
and returns the resulting list of sublists. See also stem.


: (split (1 a 2 b 3 c 4 d 5 e 6) 'e 3 'a)
-> ((1) (2 b) (c 4 d 5) (6))
: (mapcar pack (split (chop "The quick brown fox") " "))
-> ("The" "quick" "brown" "fox")




(sqrt 'num ['flg|num]) -> num


Returns the square root of the num argument. If
flg is given and non-NIL, the result will be rounded.
If in addition to that flg is a number, the first argument will be
multiplied with it before doing the square root calculation. See also */.


: (sqrt 64)
-> 8
: (sqrt 1000)
-> 31
: (sqrt 1000 T)
-> 32
: (sqrt 10000000000000000000000000000000000000000)
-> 100000000000000000000

: (scl 6)
-> 6  # 0.000006
: (sqrt 2.0 1.0)
-> 1414214  # 1.414214




(ssl 'host 'path . prg) -> any


Executes prg in an input stream (using in) from "@bin/ssl" requesting path
from host.


: (ssl "picolisp.com" "wiki/?home" (line T))
-> "<!DOCTYPE html>"




(stack ['cnt ['cnt]]) -> cnt | (.. (any . cnt) . cnt)


Maintains the stack segment sizes for coroutines. By default, coroutine sizes are 64 kB
each, and the main stack segment size is 256 kB. These sizes can only be changed
before starting any coroutine. If called with at least one argument and no
coroutine running, the stack segment size is set to the first cnt
argument, and optionally the main segment size is set to the second
cnt argument. Otherwise, the current size in kilobytes is returned
and - if there are running coroutines - pairs of their tags and unused stack
spaces are consed in front of the
size. See also heap.


$ ulimit -s unlimited  &&  pil +  # Guarantee stack space
: (stack)        # Current size
-> 64            # 64 kB
: (stack 20 80)  # Reduce to 20 kB
-> 20
: (co 'inc (let N 0 (loop (yield (inc 'N)))))  # Create two coroutines
-> 1
: (co 'dec (let N 0 (loop (yield (dec 'N)))))
-> -1
: (stack)
-> ((dec . 19) (inc . 19) (T . 75) . 20)




(stamp ['dat 'tim]|['T]) -> sym


Returns a date-time string in the form "YYYY-MM-DD HH:MM:SS". If
dat and tim is missing, the current date and time is
used. If T is passed, the current Coordinated Universal Time (UTC)
is used instead. See also date and
time.


: (stamp)
-> "2000-09-12 07:48:04"
: (stamp (date) 0)
-> "2000-09-12 00:00:00"
: (stamp (date 2000 1 1) (time 12 0 0))
-> "2000-01-01 12:00:00"




(state 'var (sym|lst exe [. prg]) ..) -> any


Implements a finite state machine. The variable var holds the
current state as a symbolic value. When a clause is found that contains the
current state in its CAR sym|lst value, and where the
exe in its CADR evaluates to non-NIL, the current
state will be set to that value, the body prg in the CDDR will be
executed, and the result returned. T is a catch-all for any state.
If no state-condition matches, NIL is returned. See also case, cond and job.


: (de tst ()
   (job '((Cnt . 4))
      (state '(start)
         (start 'run
            (printsp 'start) )
         (run (and (gt0 (dec 'Cnt)) 'run)
            (printsp 'run) )
         (run 'stop
            (printsp 'run) )
         (stop 'start
            (setq Cnt 4)
            (println 'stop) ) ) ) )
-> tst
: (do 12 (tst))
start run run run run stop
start run run run run stop
-> stop
: (pp 'tst)
(de tst NIL
   (job '((Cnt . 4))
      (state '(start)
      ...
-> tst
: (do 3 (tst))
start run run -> run
: (pp 'tst)
(de tst NIL
   (job '((Cnt . 2))
      (state '(run)
      ...
-> tst




(stem 'lst 'any ..) -> lst


Returns the tail of lst that does not contain any of the
any arguments. (stem 'lst 'any ..) is equivalent to
(last (split 'lst 'any ..)). See also tail and split.


: (stem (chop "abc/def\\ghi") "/" "\\")
-> ("g" "h" "i")




(step 'lst ['flg]) -> any


Single-steps iteratively through a database tree. lst is a
structure as received from init. If
flg is non-NIL, partial keys are skipped. The key for
each returned value is stored in the global variable @@. See also tree, scan, iter, leaf and fetch.


: (setq Q (init (tree 'nr '+Item) 3 5))
-> (((3 . 5) ((3 NIL . {B3}) (4 NIL . {B4}) (5 NIL . {B5}) (6 NIL . {B6}))))
: (get (step Q) 'nr)
-> 3
: (get (step Q) 'nr)
-> 4
: (get (step Q) 'nr)
-> 5
: (get (step Q) 'nr)
-> NIL




(store 'tree 'any1 'any2 ['(num1 . num2)])


Stores a value any2 for the key any1 in a database
tree. num1 is a database file number, as used in new (defaulting to 1), and num2 a
database block size (defaulting to 256). When any2 is
NIL, the corresponding entry is deleted from the tree. See also
tree and fetch.


: (store (tree 'nr '+Item) 2 '{B2})




(str 'sym ['sym1]) -> lst


(str 'lst) -> sym


In the first form, the string sym is parsed into a list. This
mechanism is also used by load. If
sym1 is given, it should specify a set of characters, and
str will then return a list of tokens analog to read. The second form does the reverse
operation by building a string from a list. See also any, name and sym.


: (str "a (1 2) b")
-> (a (1 2) b)
: (str '(a "Hello" DEF))
-> "a \"Hello\" DEF"
: (str "a*3+b*4" "_")
-> (a "*" 3 "+" b "*" 4)




(str? 'any) -> sym | NIL


Returns the argument any when it is a transient symbol
(string), otherwise NIL. See also sym?, box? and ext?.


: (str? 123)
-> NIL
: (str? '{ABC})
-> NIL
: (str? 'abc)
-> NIL
: (str? "abc")
-> "abc"




(strDat 'sym) -> dat


Converts a string sym in the date format of the current
locale to a date. See also expDat, $dat and datStr.


: (strDat "2007-06-01")
-> 733134
: (strDat "01.06.2007")
-> NIL
: (locale "DE" "de")
-> NIL
: (strDat "01.06.2007")
-> 733134
: (strDat "1.6.2007")
-> 733134




(strip 'any) -> any


Strips all leading quote calls from any. See also
lit.


: (strip 123)
-> 123
: (strip '''(a))
-> (a)
: (strip (quote quote a b c))
-> (a b c)




(struct 'num 'any 'any ..) -> any


Creates or extracts data structures, suitable to be passed to or returned
from native functions. The first
num argument should be a native value, either a scalar, or a
pointer obtained by calling functions like malloc(). The second
argument any is a result
specification, while all following initialization items are stored in the structure
pointed to by the first argument. See also Native C
Calls.


: (scl 2)
-> 2  # 0.02

## /* We assume the following C structure */
## typedef struct value {
##    int x, y;
##    double a, b, c;
##    long z;
##    char nm[4];
## } value;

# Allocate structure
: (setq P (%@ "malloc" 'N 56))
-> 498324676928

# Store two integers, three doubles, one long, and four characters
: (struct P NIL -7 -4 (1.0 0.11 0.22 0.33) (7 . 8) 65 66 67 0)
-> NIL

# Extract the structure
: (struct P '((I . 2) (1.0 . 3) N (C . 4)))
-> ((7 4) (11 22 33) 7 ("A" "B" "C"))

# Do both in a single call (allowing conversions of data types)
: (struct P
   '((I . 2) (1.0 . 3) N (C . 4))
   -7 -4 (1.0 0.11 0.22 0.33) (7 . 8) 65 66 67 0 )
-> ((7 4) (11 22 33) 7 ("A" "B" "C"))

# De-allocate structure
: (%@ "free" NIL P)
-> NIL




(sub? 'any1 'any2) -> any2 | NIL


Returns any2 when the string representation of
any1 is a substring of the string representation of
any2. See also pre?,
offset and index.


: (sub? "def" "abcdefg")
-> "abcdefg"
: (sub? "abb" "abcdefg")
-> NIL
: (sub? NIL "abcdefg")
-> "abcdefg"

: (sub? "def" '(a b c d e f g))
-> "abcdefg"
: (sub? '(d e f) "abcdefg")
-> "abcdefg"




(subr 'sym) -> num


Converts a Lisp-function that was previously converted with expr back to a SUBR function.


: car
-> 67313448
: (expr 'car)
-> (@ (pass $385260187))
: (subr 'car)
-> 67313448
: car
-> 67313448




(sum 'fun 'lst ..) -> num


Applies fun to each element of lst. When
additional lst arguments are given, their elements are also passed
to fun. Returns the sum of all numeric values returned from
fun.


: (setq A 1  B 2  C 3)
-> 3
: (sum val '(A B C))
-> 6
: (sum * (3 4 5) (5 6 7))        # Vector dot product
-> 74
: (sum                           # Total size of symbol list values
   '((X)
      (and (pair (val X)) (size @)) )
   (what) )
-> 32021




(super ['any ..]) -> any


Can only be used inside methods. Sends the current message to the current
object This, this time starting the search for a method at the
superclass(es) of the class where the current method was found. See also OO Concepts, extra, method, meth, send and try.


(dm stop> ()         # 'stop>' method of current class
   (super)           # Call the 'stop>' method of the superclass
   ... )             # other things




(swap 'var 'any) -> any


Set the value of var to any, and return the
previous value. See also xchg and
set.


: (setq A 7  L (1 2 3))
-> (1 2 3)
: (swap (cdr L) (swap 'A 'xyz))
-> 2
: A
-> xyz
: L
-> (1 7 3)




(sym 'any) -> sym


Generate the printed representation of any into the name of a
new symbol sym. This is the reverse operation of any. See also name and str.


: (sym '(abc "Hello" 123))
-> "(abc \"Hello\" 123)"




(sym? 'any) -> flg


Returns T when the argument any is a symbol. See
also num?, atom, pair, str?, box? and ext?.


: (sym? 'a)
-> T
: (sym? NIL)
-> T
: (sym? 123)
-> NIL
: (sym? '(a b))
-> NIL




(symbols) -> lst


(symbols 'lst) -> lst


(symbols 'lst . prg) -> any


(symbols ['T] 'sym1 'sym2 ..) -> lst


Creates and manages namespaces of
internal symbols: In the first form, the current list of namespaces is
returned. In the second form, the current namespace list is set to
lst, and the previous namespace list is returned. In the
third form, the current namespace list is set to lst during
the execution of prg, and the result is returned. In the
fourth form, sym1 is initialized to a new namespace if its
value is NIL and not modified otherwise, sym1,
sym2 and all following arguments are set as the current
namespace list, and if the value of the global variable *Dbg is non-NIL, the current line
number and file name (if any) are stored in the *Dbg
property of sym1. If the first argument is T,
the resulting namespace list is also exported from the current REPL. See
also pico, nsp, -symbols, private, local, namespaces, shadows, export, import, intern and load.


: (symbols 'myLib 'pico)
-> (pico)
myLib: (de foo (X)
   (bar (inc X)) )
-> foo
myLib: (symbols 'pico)
-> (myLib pico)
: (pp 'foo)
(de foo . NIL)
-> foo
: (pp 'myLib~foo)
(de "foo" (X)
   ("bar" (inc X)) )
-> "foo"
: (symbols '(myLib pico))
-> (pico)
myLib: (pp 'foo)
(de foo (X)
   (bar (inc X)) )
-> foo
myLib:




(-symbols) -> lst


Command line frontend to symbols. Inserts the next command line
argument as the first namespace into the current search order. --symbols
myLib on the command line (see Invocation)
is equivalent to -"symbols '(myLib ...)". See also opt.


$ ./pil lib/gis.l lib/simul.l  --symbols gis  --symbols simul  +
simul: (symbols)
-> (simul gis pico)
simul:




(sync) -> flg


Waits for pending data from all family processes. While other processes are
still sending data (via the tell
mechanism), a poll(2) system call is executed for all file
descriptors and timers in the VAL of the global variable *Run. When used in a non-database context,
(tell) should be called in the end to inform the parent process
that it may grant synchronization to other processes waiting for
sync. In a database context, where sync is usually
called by dbSync, this is not
necessary because it is done internally by commit or rollback.

See also key and wait.


: (or (lock) (sync))       # Ensure database consistency
-> T                       # (numeric process-id if lock failed)




(sys 'any ['any]) -> sym


Returns or sets a system environment variable.


: (sys "TERM")  # Get current value
-> "xterm"
: (sys "TERM" "vt100")  # Set new value
-> "vt100"
: (sys "TERM")
-> "vt100"




(sysdefs 'sym1 '[sym2])


Loads system-dependent definitions for all symbols in the section named
sym1 from the file "@lib/sysdefs" (or an alternative file given by
sym2). All symbols in that section are defined to their given values. See also native.


: (sysdefs "networking")  # Load networking system definitions








pil21/doc/refT.html0000644000000000000000000006102014751705223011233 0ustar  





T





T






*Term


Global variable holding a (possibly empty) prg body, which will
be executed when a SIGTERM signal is sent to the current process. If it returns
non-NIL, the signal is ignored.
See also
alarm, sigio, *Hup, *Winch, *Sig[12] and *TStp[12].


: (de *Term (msg 'SIGTERM) T)
-> *Term




*TStp1


*TStp2


Global variables holding (possibly empty) prg bodies, which
will be executed when a SIGTSTP signal (*TStp1) or a SIGCONT signal
(*TStp2) is sent to the current process. See also alarm, sigio, *Hup, *Winch, *Sig[12] and *Term.


: (de *TStp1 (msg 'SIGTSTP))
-> *TStp1




*Tmp


A global variable holding the temporary directory name created with tmp. See also *Bye.


: *Bye
-> ((saveHistory) (and *Tmp (call 'rm "-r" *Tmp)))
: (tmp "foo" 123)
-> "/home/app/.pil/tmp/27140/foo123"
: *Tmp
-> "/home/app/.pil/tmp/27140/"




+Time


Class for clock time values (as calculated by time), a subclass of +Number. See also Database.


(rel tim (+Time))  # Time of the day




T


A global constant, evaluating to itself. T is commonly returned
as the boolean value "true" (though any non-NIL values could be
used). It represents the absolute maximum, as it is larger than any other
object. As a property key, it is used to store Pilog clauses, and inside Pilog clauses it is the
cut operator. See also NIL and
and Comparing.


: T
-> T
: (= 123 123)
-> T
: (get 'not T)
-> ((@P (1 @P) T (fail)) (@P))




This


Holds the current object during method execution (see OO Concepts), or inside the body of a with statement. As it is a normal symbol,
however, it can be used in normal bindings anywhere. See also isa, :,
=:, :: and var:.


: (with 'X (println 'This 'is This))
This is X
-> X
: (put 'X 'a 1)
-> 1
: (put 'X 'b 2)
-> 2
: (put 'Y 'a 111)
-> 111
: (put 'Y 'b 222)
-> 222
: (mapcar '((This) (cons (: a) (: b))) '(X Y))
-> ((1 . 2) (111 . 222))




(t . prg) -> T


Executes prg, and returns T. See also nil, prog, prog1 and prog2.


: (t (println 'OK))
OK
-> T




(tab 'lst 'any ..) -> NIL


Print all any arguments in a tabular format. lst
should be a list of numbers, specifying the field width for each argument. All
items in a column will be left-aligned for negative numbers, otherwise
right-aligned. See also align,
center and wrap.


: (let Fmt (-3 14 14)
   (tab Fmt "Key" "Rand 1" "Rand 2")
   (tab Fmt "---" "------" "------")
   (for C '(A B C D E F)
      (tab Fmt C (rand) (rand)) ) )
Key        Rand 1        Rand 2
---        ------        ------
A               0    1481765933
B     -1062105905    -877267386
C      -956092119     812669700
D       553475508   -1702133896
E      1344887256   -1417066392
F      1812158119   -1999783937
-> NIL




(tail 'cnt|lst 'lst) -> lst


Returns the last cnt elements of lst. If
cnt is negative, it is added to the length of lst. If
the first argument is a lst, tail is a predicate
function returning that argument list if it is equal to the tail of
the second argument, and NIL otherwise. (tail -2 Lst)
is equivalent to (nth Lst 3). See also offset, head, last and stem.


: (tail 3 '(a b c d e f))
-> (d e f)
: (tail -2 '(a b c d e f))
-> (c d e f)
: (tail 0 '(a b c d e f))
-> NIL
: (tail 10 '(a b c d e f))
-> (a b c d e f)
: (tail '(d e f) '(a b c d e f))
-> (d e f)




(task 'num ['num] [sym 'any ..] [. prg]) -> lst


A front-end to the *Run global. If
called with only a single num argument, the corresponding entry is
removed from the value of *Run. Otherwise, a new entry is created.
If an entry with that key already exists, an error is issued. For negative
numbers, a second number must be supplied. If sym/any
arguments are given, a job environment
is built for the *Run entry. See also tasks and timeout.


: (task -10000 5000 N 0 (tty (println (inc 'N))))  # Install task for every 10 seconds
-> (-10000 5000 (job '((N . 0)) (tty (println (inc 'N)))))
: 1                                                # ... after 5 seconds
2                                                  # ... after 10 seconds
3                                                  # ... after 10 seconds
(task -10000)                                      # remove again
-> NIL

: (task (port T 4444) (eval (udp @)))              # Receive RPC via UDP
-> (3 (eval (udp @)))

# Another session (on the same machine)
: (udp "localhost" 4444 '(println *Pid))  # Send RPC message
-> (println *Pid)




(tasks . prg)


Runs a task with variable event
specification in a single *Run entry.
The task body prg should return either a positive number (a file
descriptor) or a negative number (a timeout value) to be used in the next
iteration. The first value must be a timeout. A value of NIL
removes the task. Uses -2 as implicit key. See also timeout.


(tasks  # Three iterations with varying timeout
   (let X (pop '(((-1000 . a) (-4000 . b) (-1000 . c))))
      (tty (println (cdr X)))
      (car X) ) )

(tasks
   (co 'echoes  # Coroutine
      (use S
         (loop  # Loop infinitely
            (yield -4000)  # First wait 4 seconds
            (tty (println 'OK))
            (yield  # Then wait for remote data
               (setq S
                  (pipe (exec "sh" "-c" "sleep 2; echo 7")) ) )
            (tty (println (in S (read))))
            (close S) ) ) ) )




(tco lst . prg) -> any


(tc ['any ..])


Tail call optimization. tco implements a loop which is
restarted whenever tc is called during the execution of
prg. This is faster and uses much less stack space than a recursive
function call. lst is a list of parameter symbols. tc
must be the very last function called in a function body. See also recur and catch.


: (de f (N)
   (if (=0 N)
      'OK
      (printsp N)
      (f (dec N)) ) )  # Recursive call
-> f
: (f 8)
8 7 6 5 4 3 2 1 -> OK

# Equivalent to
: (de f (N)
   (tco (N)
      (if (=0 N)
         'OK
         (printsp N)
         (tc (dec N)) ) ) )  # Tail call
-> f
: (f 8)
8 7 6 5 4 3 2 1 -> OK

# Mutually recursive functions
: (de f (N)
   (tco (N)
      (if (le0 N)
         'OK
         (printsp N)
         (g (dec N)) ) ) )
-> f
: (de g (N)
   (if (le0 N)
      'OK
      (tc (dec N)) ) )  # Tail call
-> g
: (f 8)
8 6 4 2 -> OK




(telStr 'sym) -> sym


Formats a telephone number according to the current locale. If the string head matches the local
country code, it is replaced with the national trunk prefix, otherwise
+ is prepended. See also expTel, datStr, money and format.


: (telStr "49 1234 5678-0")
-> "+49 1234 5678-0"
: (locale "DE" "de")
-> NIL
: (telStr "49 1234 5678-0")
-> "01234 5678-0"




(tell ['cnt] 'sym ['any ..]) -> any


Family IPC: Send an executable list (sym any ..) to all family
members (i.e. all children of the current process, and all other children of the
parent process, see fork) for
automatic execution. When the cnt argument is given and non-zero,
it should be the PID of such a process, and the list will be sent only to that
process. If cnt is zero, the list will be sent to the parent
process instead. When called without arguments, no message is actually sent, and
the parent process may grant sync to
the next waiting process. tell is also used internally by commit to notify about database changes. When
called explicitly, the size of the message is limited to the POSIX constant
PIPE_BUF. See also kids, detach and hear.


: (call 'ps "x")                          # Show processes
  PID TTY      STAT   TIME COMMAND
  ..
 1321 pts/0    S      0:00 /usr/bin/picolisp ..  # Parent process
 1324 pts/0    S      0:01 /usr/bin/picolisp ..  # First child
 1325 pts/0    S      0:01 /usr/bin/picolisp ..  # Second child
 1326 pts/0    R      0:00 ps x
-> T
: *Pid                                    # We are the second child
-> 1325
: (tell 'println '*Pid)                   # Ask all others to print their Pid's
1324
-> *Pid




(test 'any . prg)


Executes prg, and issues an error if the result does not match the any argument. See also
assert.


: (test 12 (* 3 4))
-> NIL
: (test 12 (+ 3 4))
((+ 3 4))
12 -- 'test' failed
?




(text 'any1 'any ..) -> sym


Builds a new transient symbol (string) from the string representation of
any1, by replacing all occurrences of an at-mark "@",
followed by one of the letters "1" through "9", and
"A" through "Z", with the corresponding
any argument. In this context "@A" refers to the 10th
argument. A literal at-mark in the text can be represented by two successive
at-marks. See also pack and glue.


: (text "abc @1 def @2" 'XYZ 123)
-> "abc XYZ def 123"
: (text "a@@bc.@1" "de")
-> "a@bc.de"




(throw 'sym 'any)


Non-local jump into a previous catch environment with the jump label
sym (or T as a catch-all). Any pending finally expressions are executed, local
symbol bindings are restored, open files are closed and internal data structures
are reset appropriately, as the environment was at the time when the
corresponding catch was called. Then any is returned
from that catch. See also quit.


: (de foo (N)
   (println N)
   (throw 'OK) )
-> foo
: (let N 1  (catch 'OK (foo 7))  (println N))
7
1
-> 1




(till 'any ['flg]) -> lst|sym


Reads from the current input channel till a character contained in
any is found (or until end of file if any is
NIL). If flg is NIL, a list of
single-character transient symbols is returned. Otherwise, a single string is
returned. See also from and line.


: (till ":")
abc:def
-> ("a" "b" "c")
: (till ":" T)
abc:def
-> "abc"




(tim$ 'tim ['flg]) -> sym


Formats a time tim.
If flg is NIL, the format is HH:MM, otherwise it is
HH:MM:SS. See also $tim and dat$.


: (tim$ (time))
-> "10:57"
: (tim$ (time) T)
-> "10:57:56"




(time ['T]) -> tim


(time 'tim) -> (h m s)


(time 'h 'm ['s]) -> tim | NIL


(time '(h m [s])) -> tim | NIL


Calculates the time of day, represented as the number of seconds since
midnight. When called without arguments, the current local time is returned.
When called with a T argument, the time of the last call to
date is returned. When called with a
single number tim, it is taken as a time value and a list with the
corresponding hour, minute and second is returned. When called with two or three
numbers (or a list of two or three numbers) for the hour, minute (and optionally
the second), the corresponding time value is returned (or NIL if
they do not represent a legal time). See also date, stamp, usec, tim$ and $tim.


: (time)                         # Now
-> 32334
: (time 32334)                   # Now
-> (8 58 54)
: (time 12 70)                   # Illegal time
-> NIL




(timeout ['num])


Sets or refreshes a timeout value in the *Run global, so that the current process
executes bye after the given period. If
called without arguments, the timeout is removed. Uses -1 as
implicit key. See also task.


: (timeout 3600000)           # Timeout after one hour
-> (-1 3600000 (bye))
: *Run                        # Look after a few seconds
-> ((-1 3574516 (bye)))




(tmp ['any ..]) -> sym


Returns the path name to the packed any arguments in a
process-local temporary directory. The directory name consists of the path to
".pil/tmp/" in the user's home directory, followed by the current process ID
*Pid. This directory is automatically
created if necessary, and removed upon termination of the process (bye). See also *Tmp and *Bye .


: *Pid
-> 27140
: (tmp "foo" 123)
-> "/home/app/.pil/tmp/27140/foo123"
: (out (tmp "foo" 123) (println 'OK))
-> OK
: (dir (tmp))
-> ("foo123")
: (in (tmp "foo" 123) (read))
-> OK




tolr/3


Pilog predicate that succeeds if the first
argument, after folding it to a
canonical form, is either a substring or a +Sn soundex match of the result of
applying the get algorithm to the
following arguments. Typically used as filter predicate in select/3 database queries. See also
isa/2, same/3, bool/3, range/3, head/3, fold/3 and part/3.


: (?
   @Nr (1 . 5)
   @Nm "Sven"
   (select (@CuSu)
      ((nr +CuSu @Nr) (nm +CuSu @Nm))
      (range @Nr @CuSu nr)
      (tolr @Nm @CuSu nm) )
   (val @Name @CuSu nm) )
 @Nr=(1 . 5) @Nm="Sven" @CuSu={C2} @Name="Seven Oaks Ltd."




(touch 'sym) -> sym


When sym is an external symbol, it is marked as "modified" so
that upon a later commit it will be
written to the database file. An explicit call of touch is only
necessary when the value or properties of sym are indirectly
modified.


: (get '{2} 'lst)
-> (1 2 3 4 5)
: (set (cdr (get (touch '{2}) 'lst)) 999)    # Only read-access, need 'touch'
-> 999
: (get '{2} 'lst)                            # Modified second list element
-> (1 999 3 4 5)




(trace 'sym)


(trace 'sym 'cls)


(trace '(sym . cls))


(Debug mode only) Inserts a $ trace
function call at the beginning of the function or method body of
sym, so that trace information will be printed before and after
execution. Can only be used with EXPRs and SUBRs. Built-in functions (SUBRs) are
automatically converted to Lisp expressions (see expr). See also *Dbg, traceAll and untrace, debug and lint.


: (trace '+)
-> +
: (+ 3 4)
 + : 3 4
 + = 7
-> 7




(-trace)


(Debug mode only) Command line frontend to trace. See also -debug.


$ ./pil --trace append +
: (append (1 2 3) (4 5 6))
 append : (1 2 3) (4 5 6)
 append = (1 2 3 4 5 6)
-> (1 2 3 4 5 6)




(traceAll ['lst]) -> sym


(Debug mode only) Traces all Lisp level functions by inserting a $ function call at the beginning. lst
may contain symbols which are to be excluded from that process. In addition, all
symbols in the global variable *NoTrace are excluded. See also
trace, untrace and *Dbg.


: (traceAll)      # Trace all Lisp level functions
-> balance




(trail ['flg]) -> lst


Returns a stack backtrace for the current point of program execution. The
list elements are either list expressions (denoting function or method calls),
or symbols followed by their corresponding values. If flg is
NIL, the symbols and their values are omitted, and only the
expressions are returned. See also bt,
up and env.


: (de f (A B)
   (g (inc A) (dec B)) )
-> f
: (de g (X Y)
   (trail T) )
-> g
: (f 3 4)
-> ((f 3 4) A 3 B 4 (g (inc A) (dec B)) X 4 Y 3)




(tree 'sym 'cls ['hook]) -> tree


Returns a data structure specifying a database index tree. sym
and cls determine the relation, with an optional hook
object. See also root, fetch, store, count, leaf, minKey, maxKey, init, step, scan, iter, prune, zapTree and chkTree.


: (tree 'nm '+Item)
-> (nm . +Item)




(trim 'lst) -> lst


Returns a copy of lst with all trailing whitespace characters
or NIL elements removed. See also clip.


: (trim (1 NIL 2 NIL NIL))
-> (1 NIL 2)
: (trim '(a b " " " "))
-> (a b)




true/0


Pilog predicate that always succeeds. See also
fail/0 and repeat/0.


:  (? (true))
-> T




(try 'msg 'obj ['any ..]) -> any


Tries to send the message msg to the object obj,
optionally with arguments any. If obj is not an
object, or if the message cannot be located in obj, in its classes
or superclasses, NIL is returned. See also OO Concepts, send, method, meth, super and extra.


: (try 'msg> 123)
-> NIL
: (try 'html> 'a)
-> NIL




(tty . prg) -> any


Redirects the current output channel to the terminal (stderr) during the
execution of prg. The current output channel and the state of
readline(3) will be saved and restored appropriately. See also
out.


: (task -2000 0 (tty (println (inc (0)))))
-> (-2000 0 (tty (println (inc (0)))))
1
2
3
: (* 3 4)  # Typed while numbers are printed




(type 'any) -> lst


Return the type (list of classes) of the object any. See also
OO Concepts, isa, class, new and object.


: (type '{1A;3})
(+Address)
: (type '+DnButton)
-> (+Tiny +Rid +JS +Able +Button)








pil21/doc/refU.html0000644000000000000000000003244214516412720011236 0ustar  





U





U






*Uni


A global variable holding an idx
tree, with all unique data that were collected with the comma (,)
read-macro. Typically used for localization. Setting *Uni to
T disables this mechanism. See also Read-Macros and locale.


: (off *Uni)            # Clear
-> NIL
: ,"abc"                # Collect a transient symbol
-> "abc"
: ,(1 2 3)              # Collect a list
-> (1 2 3)
: *Uni
-> ("abc" NIL (1 2 3))




+UB


Prefix class for +Aux to maintain
an UB-Tree index instead of the direct values. This allows efficient range
access to multi-dimensional data. Only positive numeric keys are supported. See
also ubIter and Database.


(class +Pos +Entity)
(rel x (+UB +Aux +Ref +Number) (y z))
(rel y (+Number))
(rel z (+Number))

: (scan (tree 'x '+Pos))
(288362200753438306 . {13}) {13}
(348187139486943716 . {16}) {16}
(605261596962573238 . {11}) {11}
(638523558602802506 . {7}) {7}   # UBKEY of (453062 450921 613956)
(654697989157410399 . {12}) {12}
...

: (show '{7})
{7} (+Pos)
   x 453062
   y 450921
   z 613956
-> {7}

# Discrete queries work the same way as without the +UB prefix
: (db 'x '+Pos 453062 'y 450921 'z 613956)
-> {7}
: (aux 'x '+Pos 453062 450921 613956)
-> {7}
: (? (db x +Pos (453062 450921 613956) @Pos))
 @Pos={7}
-> NIL

# Range queries work efficiently with 'collect'. Note that though also Pilog
queries can handle UB-trees, they may do so sub-optimally for certain ranges.
: (collect 'x '+Pos (200000 200000 200000) (899999 899999 899999))
-> ({7} {14} {17} {15})




(u) -> T


(Debug mode only) Removes ! all
breakpoints in all subexpressions of the current breakpoint. Typically used when
single-stepping a function or method with debug. See also d and unbug.


! (u)                         # Unbug subexpression(s) at breakpoint
-> T




(ubIter 'tree 'dim 'fun 'lst1 'lst2)


Efficiently iterates through a database +UB tree, by applying fun to all
values. dim is the number of the key dimensions, lst1
and lst2 specify a range of keys. collect uses ubIter internally
for UB-tree queries. See also iter.


: (ubIter (tree 'x '+Pos) 3 show (200000 200000 200000) (899999 899999 899999))
{7} (+Pos)
   z 613956
   y 450921
   x 453062
{14} (+Pos)
   z 771372
   y 262217
   x 862358
{17} (+Pos)
   z 676836
   y 529576
   x 398229
{15} (+Pos)
   z 889332
   y 691799
   x 265381
-> NIL




(udp 'any1 'any2 'any3) -> any


(udp 'cnt) -> any


Simple unidirectional sending/receiving of UDP packets. In the first form,
any3 is sent to a UDP server listening at host any1,
port any2. In the second form, one item is received from a UDP
socket cnt, established with port. See also listen and connect.


# First session
: (port T 6666)
-> 3
: (udp 3)  # Receive a datagram

# Second session (on the same machine)
: (udp "localhost" 6666 '(a b c))
-> (a b c)

# First session
-> (a b c)




(ultimo 'y 'm) -> cnt


Returns the date of the last day
of the month m in the year y. See also day and week.


: (date (ultimo 2007 1))
-> (2007 1 31)
: (date (ultimo 2007 2))
-> (2007 2 28)
: (date (ultimo 2004 2))
-> (2004 2 29)
: (date (ultimo 2000 2))
-> (2000 2 29)
: (date (ultimo 1900 2))
-> (1900 2 28)




(unbug 'sym) -> T


(unbug 'sym 'cls) -> T


(unbug '(sym . cls)) -> T


(Debug mode only) Removes all !
breakpoints in the function or method body of sym, as inserted with debug or d, or directly with vi. See also u.


: (pp 'tst)
(de tst (N)
   (! println (+ 3 N)) )         # 'tst' has a breakpoint '!'
-> tst
: (unbug 'tst)                   # Unbug it
-> T
: (pp 'tst)                      # Restore
(de tst (N)
   (println (+ 3 N)) )




(undef 'sym) -> fun


(undef 'sym 'cls) -> fun


(undef '(sym . cls)) -> fun


Undefines the function or method sym. Returns the previous
definition. See also de, dm, def
and redef.


: (de hello () "Hello world!")
-> hello
: hello
-> (NIL "Hello world!")
: (undef 'hello)
-> (NIL "Hello world!")
: hello
-> NIL




(unify 'any) -> lst


(unify 'cnt) -> cnt


The first form unifies any with the current Pilog environment at the current level and with a
value of NIL, and returns the new environment or NIL
if not successful. The second form unifies all variables at the given level with
the current one. See also prove and
->.


: (? (^ @A (unify '(@B @C))))
 @A=(((NIL . @C) 0 . @C) ((NIL . @B) 0 . @B) T)




(uniq 'lst) -> lst


Returns a unique list, by eliminating all duplicate elements from
lst. See also Comparing, sort and group.


: (uniq (2 4 6 1 2 3 4 5 6 1 3 5))
-> (2 4 6 1 3 5)




uniq/2


Pilog predicate that succeeds if the second
argument is not yet stored in the first argument's index structure. idx is used internally storing for the values
and checking for uniqueness. See also member/2.


: (let U NIL
   (? (lst @X (a b c b c d)) (uniq U @X)) )
 @X=a
 @X=b
 @X=c
 @X=d
-> NIL
: (solve '((^ @B (box)) (lst @X (a b c b c d)) (uniq @B @X)) @X)
-> (a b c d)




(unless 'any . prg) -> any


Conditional execution: When the condition any evaluates to
non-NIL, NIL is returned. Otherwise prg
is executed and the result returned. See also when, ifn, nor, nand and nond.


: (unless (= 3 3) (println 'Strange 'result))
-> NIL
: (unless (= 3 4) (println 'Strange 'result))
Strange result
-> result




(until 'any . prg) -> any


Conditional loop: While the condition any evaluates to
NIL, prg is repeatedly executed. If prg
is never executed, NIL is returned. Otherwise the result of
prg is returned. See also while, for, loop and do.


: (until (=T (setq N (read)))
   (println 'square (* N N)) )
4
square 16
9
square 81
T
-> 81




(untrace 'sym) -> sym


(untrace 'sym 'cls) -> sym


(untrace '(sym . cls)) -> sym


(Debug mode only) Removes the $ trace
function call at the beginning of the function or method body of
sym, so that no more trace information will be printed before and
after execution. Built-in functions (SUBRs) are automatically converted to their
original form (see subr). See also
trace and traceAll.


: (trace '+)                           # Trace the '+' function
-> +
: +
-> (@ ($ + @ (pass $385455126)))       # Modified for tracing
: (untrace '+)                         # Untrace '+'
-> +
: +
-> 67319120                            # Back to original form




(up [cnt] sym ['val]) -> any


Looks up (or modifies) the cnt'th previously saved value of
sym in the corresponding enclosing environment. If cnt
is not given, 1 is used. It is allowed to omit the sym argument,
then the corresponding expression (function or method call) is returned. See
also eval, run, trail and env.


: (let N 1 ((quote (N) (println N (up N))) 2))
2 1
-> 1
: (let N 1 ((quote (N) (println N (up N) (up N 7))) 2) N)
2 1 7
-> 7

: (de foo (N)
   (println (up))
   (inc N) )
-> foo
: (foo 7)
(foo 7)
-> 8




(upd sym ..) -> lst


Synchronizes the internal state of all passed (external) symbols by passing
them to wipe. upd is the
standard function passed to commit
during database transactions.


(commit 'upd)  # Commit changes, informing all sister processes




(upp? 'any) -> sym | NIL


Returns any when the argument is a string (symbol) that starts
with an uppercase character. See also uppc and low?


: (upp? "A")
-> "A"
: (upp? "a")
-> NIL
: (upp? 123)
-> NIL
: (upp? ".")
-> NIL




(uppc 'any) -> any


Upper case conversion: If any is not a symbol, it is returned
as it is. Otherwise, a new transient symbol with all characters of
any, converted to upper case, is returned. See also lowc, fold and upp?.


: (uppc 123)
-> 123
: (uppc "abc")
-> "ABC"
: (uppc 'car)
-> "CAR"




(use sym . prg) -> any


(use (sym ..) . prg) -> any


Defines local variables. The value of the symbol sym - or the
values of the symbols sym in the list of the second form - are
saved, prg is executed, then the symbols are restored to their
original values. During execution of prg, the values of the symbols
can be temporarily modified. The return value is the result of prg.
See also bind, job and let.


: (setq  X 123  Y 456)
-> 456
: (use (X Y) (setq  X 3  Y 4) (* X Y))
-> 12
: X
-> 123
: Y
-> 456




(useKey 'sym 'cls ['hook]) -> num


Generates or reuses a key for a database tree, by randomly trying to locate
a free number. See also genKey.


: (maxKey (tree 'nr '+Item))
-> 8
: (useKey 'nr '+Item)
-> 12




(usec ['flg]) -> num


Returns a number of microseconds. If flg is
non-NIL, the microsecond fraction of the last call to time is returned, otherwise the number of
microseconds since interpreter startup. See also date.


: (usec)
-> 1154702479219050
: (list (date (date)) (time (time T)) (usec T))
-> ((2013 1 4) (10 12 39) 483321)








pil21/doc/refV.html0000644000000000000000000001231214516412761011236 0ustar  





V





V






(val 'var) -> any


Returns the current value of var. See also setq, set and def.


: (setq L '(a b c))
-> (a b c)
: (val 'L)
-> (a b c)
: (val (cdr L))
-> b




val/3


Pilog predicate that returns the value of an
object's attribute. Typically used in database queries. The first argument is a
Pilog variable to bind the value, the second is the object, and the third and
following arguments are used to apply the get algorithm to that object. See also db/3 and select/3.


: (?
   (db nr +Item (2 . 5) @Item)   # Fetch articles 2 through 5
   (val @Nm @Item nm)            # Get item description
   (val @Sup @Item sup nm) )     # and supplier's name
 @Item={B2} @Nm="Spare Part" @Sup="Seven Oaks Ltd."
 @Item={B3} @Nm="Auxiliary Construction" @Sup="Active Parts Inc."
 @Item={B4} @Nm="Enhancement Additive" @Sup="Seven Oaks Ltd."
 @Item={B5} @Nm="Metal Fittings" @Sup="Active Parts Inc."
-> NIL




(var sym . any) -> any


(var (sym . cls) . any) -> any


Defines a class variable sym with the initial value
any for the current class, implicitly given by the value of the
global variable *Class, or - in the
second form - for the explicitly given class cls. See also OO Concepts, rel and var:.


: (class +A)
-> +A
: (var a . 1)
-> 1
: (var b . 2)
-> 2
: (show '+A)
+A NIL
   b 2
   a 1
-> +A




(var: sym) -> any


Fetches the value of a class variable sym for the current
object This, by searching the property
lists of its class(es) and superclasses. See also OO
Concepts, var, with, meta, :,
=: and ::.


: (class +A)
-> +A
: (var a . 1)
-> 1
: (var b . 2)
-> 2
: (object 'O '(+A) 'a 9 'b 8)
-> O
: (with 'O (list (: a) (: b) (var: a) (var: b)))
-> (9 8 1 2)




(version ['flg]) -> lst


Prints the current version as a string of dot-separated numbers, and returns
the current version as a list of numbers. The JVM- and C-versions print an
additional "JVM" or "C", respectively, separated by a space. When
flg is non-NIL, printing is suppressed. See also *CPU and *OS.


$ pil -version
15.11.0
: (version T)
-> (15 11 0)




(vi 'sym) -> sym | NIL


(vi 'sym 'cls) -> sym | NIL


(vi 'lst) -> lst | NIL


(v . lst) -> lst | NIL


(v) -> NIL


(Debug mode only) Opens the Vip editor on the function or method definition
of sym (source file or direct path name), or on a list of symbols
lst (in-memory). (v) resumes a Vip session suspended
with "qz". See also doc, *Dbg, debug and pp.


: (vi 'put> '+Entity)  # Edit the method's source code
: (v {1})  # In-memory-edit the database root object
-> put>




(view 'lst ['T]) -> any


Views lst as tree-structured ASCII graphics. When the
T argument is given, lst should be a binary tree
structure (as generated by idx), which
is then shown as a left-rotated tree. See also pretty and show.


: (balance 'I '(a b c d e f g h i j k l m n o))
-> NIL
: I
-> (h (d (b (a) c) f (e) g) l (j (i) k) n (m) o)

: (view I)
+-- h
|
+---+-- d
|   |
|   +---+-- b
|   |   |
|   |   +---+-- a
|   |   |
|   |   +-- c
|   |
|   +-- f
|   |
|   +---+-- e
|   |
|   +-- g
|
+-- l
|
+---+-- j
|   |
|   +---+-- i
|   |
|   +-- k
|
+-- n
|
+---+-- m
|
+-- o
-> NIL

: (view I T)
         o
      n
         m
   l
         k
      j
         i
h
         g
      f
         e
   d
         c
      b
         a
-> NIL








pil21/doc/refW.html0000644000000000000000000001656714516413013011246 0ustar  





W





W






*Winch


Global variable holding a (possibly empty) prg body, which will
be executed when a SIGWINCH signal is sent to the current process. See also
alarm, sigio, *Hup, *Sig[12], *TStp[12] and *Term.


: (de *Winch (msg 'SIGWINCH))
-> *Winch




(wait 'cnt|NIL . prg) -> any


(wait 'cnt|NIL T 'fd) -> fd|NIL


Waits for a condition. While the result of the execution of prg
is NIL (first form), or no input is available for the file
descriptor in fd (second form), a poll(2) system call
is executed for all file descriptors and timers in the VAL of the
global variable *Run. When
cnt is non-NIL, the waiting time is limited to
cnt milliseconds. Returns the result of prg. See also
key and sync.


: (wait 2000)                                # Wait 2 seconds
-> NIL
: (prog
   (zero *Cnt)
   (setq *Run                                # Install background loop
      '((-2000 0 (println (inc '*Cnt)))) )   # Increment '*Cnt' every 2 sec
   (wait NIL (> *Cnt 6))                     # Wait until > 6
   (off *Run) )
1                                            # Waiting ..
2
3
4
5
6
7
-> NIL




(week 'dat) -> num


Returns the number of the week for a given date dat. See also day, ultimo, datStr and strDat.


: (datStr (date))
-> "2007-06-01"
: (week (date))
-> 22




(when 'any . prg) -> any


Conditional execution: When the condition any evaluates to
non-NIL, prg is executed and the result is returned.
Otherwise NIL is returned. See also unless, if, and
and cond.


: (when (> 4 3) (println 'OK) (println 'Good))
OK
Good
-> Good




(while 'any . prg) -> any


Conditional loop: While the condition any evaluates to
non-NIL, prg is repeatedly executed. If
prg is never executed, NIL is returned. Otherwise the
result of prg is returned. See also until, for, loop and do.


: (while (read)
   (println 'got: @) )
abc
got: abc
1234
got: 1234
NIL
-> 1234




(what 'sym) -> lst


(Debug mode only) Returns a list of all internal symbols that match the
pattern string sym. See also match, who, has and can.


: (what "cd@dr")
-> (cdaddr cdaadr cddr cddddr cdddr cddadr cdadr)




(who 'any) -> lst


(Debug mode only) Returns a list of all functions or method definitions that
contain the atom or pattern any. See also match, what, has and can.


: (who 'caddr)                         # Who is using 'caddr'?
-> ($dat lint1 expDat datStr $tim tim$ mail _gen dat$ datSym)

: (who "Type error")
-> ((mis> . +Link) *Uni (mis> . +Joint))

: (more (who "Type error") pp)         # Pretty print all results
(dm (mis> . +Link) (Val Obj)
   (and
      Val
      (nor (isa (: type) Val) (canQuery Val))
      "Type error" ) )
.                                      # Stop
-> T




(wipe 'sym|lst) -> sym|lst


Clears the VAL and the property list of sym, or of
all symbols in the list lst. When a symbol is an external symbol,
its state is also set to "not loaded". Does nothing when sym is an
external symbol that has been modified or deleted ("dirty").


: (setq A (1 2 3 4))
-> (1 2 3 4)
: (put 'A 'a 1)
-> 1
: (put 'A 'b 2)
-> 2
: (show 'A)
A (1 2 3 4)
   b 2
   a 1
-> A
: (wipe 'A)
-> A
: (show 'A)
A NIL
-> A




(with 'var . prg) -> any


Saves the current object This and sets it to the new value
var. Then prg is executed, and This is
restored to its previous value. The return value is the result of
prg. Used typically to access the local data of var in
the same manner as inside a method body. prg is not executed (and
NIL is returned) when var is NIL.
(with 'X . prg) is equivalent to (let? This 'X . prg).


: (put 'X 'a 1)
-> 1
: (put 'X 'b 2)
-> 2
: (with 'X (list (: a) (: b)))
-> (1 2)




(wr 'cnt ..) -> cnt


Writes all cnt arguments as raw bytes to the current output
channel. See also rd and pr.


: (out "x" (wr 1 255 257))  # Write to "x"
-> 257
: (hd "x")
00000000  01 FF 01                                         ...
-> NIL




(wrap 'cnt 'lst) -> sym


(wrap 'cnt 'sym) -> lst


The first form returns a transient symbol with all characters in
lst packed in lines with
a maximal length of cnt. The second form converts a symbol to a
list of transient symbols each with a maximal length of cnt. See
also tab, align and center.


: (wrap 20 (chop "The quick brown fox jumps over the lazy dog"))
-> "The quick brown fox^Jjumps over the lazy^Jdog"
: (wrap 8 (chop "The quick brown fox jumps over the lazy dog"))
-> "The^Jquick^Jbrown^Jfox^Jjumps^Jover the^Jlazy dog"
: (wrap 8 "The quick brown fox jumps over the lazy dog")
-> ("The" "quick" "brown" "fox" "jumps" "over the" "lazy dog")








pil21/doc/refX.html0000644000000000000000000000242414516413051011234 0ustar  





X





X






(xchg 'var 'var ..) -> any


Exchange the values of successive var argument pairs. See also
swap and set.


: (setq  A 1  B 2  C '(a b c))
-> (a b c)
: (xchg  'A C  'B (cdr C))
-> 2
: A
-> a
: B
-> b
: C
-> (1 2 c)




(xor 'any 'any) -> flg


Returns T if exactly one of the arguments evaluates to non-NIL.


: (xor T NIL)
-> T
: (xor T T)
-> NIL




(x| 'num ..) -> num


Returns the bitwise XOR of all num arguments. When
one of the arguments evaluates to NIL, it is returned immediately.
See also &, | and bit?.


: (x| 2 7)
-> 5
: (x| 2 7 1)
-> 4








pil21/doc/refY.html0000644000000000000000000000360214516413114011234 0ustar  





Y





Y






(yield 'any ['any2]) -> any


Transfers control from the current coroutine back to the caller (when the
any2 tag is not given), or to some other coroutine (specified by
any2) to continue execution at the point where that coroutine had
called yield before. In the first case, the value any
will be returned from the corresponding co call, in the second case it will be the return
value of that yield call. See also stack, catch and throw.


: (co "rt1"                            # Start first routine
   (msg (yield 1) " in rt1 from rt2")  # Return '1', wait for value from "rt2"
   7 )                                 # Then return '7'
-> 1

: (co "rt2"                            # Start second routine
   (yield 2 "rt1") )                   # Send '2' to "rt1"
2 in rt1 from rt2
-> 7




(yoke 'any ..) -> any


Inserts one or several new elements any in front of the list in
the current make environment.
yoke returns the last inserted argument. See also link, chain and made.


: (make (link 2 3) (yoke 1) (link 4))
-> (1 2 3 4)








pil21/doc/refZ.html0000644000000000000000000000613614516413152011244 0ustar  





Z





Z






*Zap


A global variable holding a list and a pathname. If given, and the value of
*Solo is NIL, external
symbols which are no longer accessible can be collected in the CAR, e.g. during
DB tree processing, and written to the file in the CDR at the next commit. A (typically periodic) call to
zap_ will clean them up later.


: (setq *Zap '(NIL . "db/app/_zap"))
-> (NIL . "db/app/_zap")




(zap 'sym) -> sym


"Delete" the symbol sym. For internal symbols, that means to
remove it from the current namespace, effectively transforming it to a transient
symbol. For external symbols, it means to mark it as "deleted", so that upon a
later commit it will be removed from
the database file. See also intern.


: (de foo (Lst) (car Lst))          # 'foo' calls 'car'
-> foo
: (zap 'car)                        # Delete the symbol 'car'
-> "car"
: (pp 'foo)
(de foo (Lst)
   ("car" Lst) )                    # 'car' is now a transient symbol
-> foo
: (foo (1 2 3))                     # 'foo' still works
-> 1
: (car (1 2 3))                     # Reader returns a new 'car' symbol
!? (car (1 2 3))
car -- Undefined
?




(zapTree 'sym)


Recursively deletes a tree structure from the database. See also tree, chkTree and prune.


: (zapTree (cdr (root (tree 'nm '+Item))))




(zap_)


Delayed deletion (with zap) of
external symbols which were collected e.g. during DB tree processing. An
auxiliary file (with the name taken from the CDR of the value of *Zap, concatenated with a "_"
character) is used as an intermediary file.


: *Zap
-> (NIL . "db/app/Z")
: (call 'ls "-l" "db/app")
...
-rw-r--r-- 1 abu abu     1536 2007-06-23 12:34 Z
-rw-r--r-- 1 abu abu     1280 2007-05-23 12:15 Z_
...
: (zap_)
...
: (call 'ls "-l" "db/app")
...
-rw-r--r-- 1 abu abu     1536 2007-06-23 12:34 Z_
...




(zero var ..) -> 0


Stores 0 in all var arguments. See also one, on,
off and onOff.


: (zero A B)
-> 0
: A
-> 0
: B
-> 0








pil21/doc/ref_.html0000644000000000000000000004573314717414064011265 0ustar  





Other





Other






(! . exe) -> any


Low level breakpoint function: The current execution environment is saved
and the I/O channels are redirected to the console. Then exe is
displayed, and a read-eval-print-loop is entered (with ! as its
prompt character), to evaluate expressions and examine the current program
environment. An empty input line terminates the read-eval-print-loop, the
environment and I/O channels are restored, and the result of exe is
returned. ! is normally inserted into existing programs with the
debug function. See also e, ^ and
*Dbg.


: (de foo (N) (and (println 1) (! println N) (println 2)))
-> foo
: (foo 7)
1                 # Executed '(println 1)'
(println N)       # Entered breakpoint
! N               # Examine the value of 'N'
-> 7
! (e)             # Evaluate '^', i.e. (println N)
7
-> 7
! (e @)           # Evaluate '@' -> the result of '(println 1)'
-> 1
!                 # Empty line: continue
7                 # Executed '(println N)'
2                 # Executed '(println 2)'
-> 2




($ sym|lst lst . prg) -> any


Low level trace function: The first argument sym|lst is printed
to the console with a proper indentation, followed by a colon :. If
a function is traced, the first argument is the function symbol, else if a
method is traced, it is a cons pair of message and class. The second argument
lst should be a list of symbols, identical to the function's
argument list. The current values of these symbols are printed, followed by a
newline. Then prg is executed, and its return value printed in a
similar way (this time with an equals sign = instead of a colon)
and returned. $ is normally inserted into existing programs with
the trace function.


: (de foo (A B) ($ foo (A B) (* A B)))
-> foo
: (foo 3 4)
 foo : 3 4        # Function entry, arguments 3 and 4
 foo = 12         # Function exit, return value 12
-> 12




($dat 'sym1 ['sym2]) -> dat


Converts a string sym1 in ISO format to a date, optionally using a delimiter character
sym2. See also dat$,
$tim, strDat and expDat.


: ($dat "20070601")
-> 733134
: ($dat "2007-06-01" "-")
-> 733134




($tim 'sym) -> tim


Converts a string to a time. The
minutes and seconds are optional and default to zero. See also tim$ and $dat.


: (time ($tim "10:57:56"))
-> (10 57 56)
: (time ($tim "10:57"))
-> (10 57 0)
: (time ($tim "10"))
-> (10 0 0)




(% 'num ..) -> num


Returns the remainder from the divisions of successive num
arguments. The sign of the result is that of the first argument. When one of the
arguments evaluates to NIL, it is returned immediately. See also
/ and */ .


: (% 17 5)
-> 2
: (% -17 5)  # Sign is that of the first argument
-> -2
: (% 5 2)
-> 1
: (% 15 10)
-> 5
: (% 15 10 2)  # (% 15 10) -> 5, then (% 5 2) -> 1
-> 1




(%@ 'cnt|sym 'any 'any ..) -> any


Convenience function for a common use case of native. (%@ "fun" ...) is
equivalent to (native "@" "fun" ...).


: (%@ "getenv" 'S "TERM")  # Same as (sys "TERM")
-> "xterm"
: (%@ "symlink" 'I "file" "link")
-> 0
: (%@ "isatty" 'I 0)
-> 1
: (round (%@ "cos" 1.0  3.1415926535897932))
-> "1.000"
: (use Tim
   (%@ "time" NIL '(Tim (8 B . 8)))  # time_t 8   # Get time_t structure
   (%@ "localtime" '(I . 9) (cons NIL (8) Tim)) ) # Read local time
-> (43 19 14 6 10 120 5 310 0)  # 14:19:43, Nov 6th, 2020




(& 'num ..) -> num


Returns the bitwise AND of all num arguments. When
one of the arguments evaluates to NIL, it is returned immediately.
See also |, x| and bit?.


: (& 6 3)
-> 2
: (& 7 3 1)
-> 1




(* 'num ..) -> num


Returns the product of all num arguments. When one of the
arguments evaluates to NIL, it is returned immediately. See also
/, */, + and
-.


: (* 1 2 3)
-> 6
: (* 5 3 2 2)
-> 60




(** 'num1 'num2) -> num


Integer exponentiation: Returns num1 to the power of
num2.


: (** 2 3)
-> 8
: (** 100 100)
-> 10000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000




(*/ 'num1 ['num2 ..] 'num3) -> num


Returns the product of num1 and all following num2
arguments, divided by the num3 argument. The result is rounded to
the nearest integer value. When one of the arguments evaluates to
NIL, it is returned immediately. Note that */ is
especially useful for fixed point arithmetic, by multiplying with (or dividing
by) the scale factor. See also *,
/, +, - and
sqrt.


: (*/ 3 4 2)
-> 6
: (*/ 1234 2 10)
-> 247
: (*/ 100 6)
-> 17

: (scl 2)
-> 2  # 0.02
: (format (*/ 3.0 1.5 1.0) *Scl)
-> "4.50"

: (scl 20)
-> 20  # 0.00000000000000000020
: (format (*/ 9.9 9.789 9.56789 `(* 1.0 1.0)) *Scl)
-> "927.23474457900000000000"





(+ 'num ..) -> num


Returns the sum of all num arguments. When one of the arguments
evaluates to NIL, it is returned immediately. See also inc, -,
*, / and */.


: (+ 1 2 3)
-> 6




(++ var) -> any


Pops the first element (CAR) from the stack in var. (++
Lst) is equivalent to (pop 'Lst). See also pop.





(- 'num ..) -> num


Returns the difference of the first num argument and all
following arguments. If only a single argument is given, it is negated. When one
of the arguments evaluates to NIL, it is returned immediately. See
also dec, +, *,
/ and */.


: (- 7)
-> -7
: (- 7 2 1)
-> 4




(-> any [cnt]) -> any


Searches for the value of any (typically a Pilog variable, or an expression of variables) at top
level (or level cnt) in the current environment. See also prove and unify.


: (? (append (1 2 3) (4 5 6) @X) (^ @ (println 'X '= (-> @X))))
X = (1 2 3 4 5 6)
 @X=(1 2 3 4 5 6)
-> NIL




(/ 'num ..) -> num


Returns the first num argument successively divided by all
following arguments. When one of the arguments evaluates to NIL, it
is returned immediately. See also *,
*/, %, + and
-.


: (/ 12 3)
-> 4
: (/ 60 -3 2 2)
-> -5




(: sym|0 [sym1|cnt ..]) -> any


Fetches a value any from the properties (or value) of a symbol,
or from a list, by applying the get
algorithm to This and the following arguments. Used typically in
methods or with bodies. (:
..) is equivalent to (; This ..). See also ;, =: and
::.


: (put 'X 'a 1)
-> 1
: (with 'X (: a))
-> 1




(:: sym [sym1|cnt .. sym2]) -> var


Fetches a property for a property key sym or sym2
from a symbol. That symbol is This (if no other arguments are
given), or a symbol found by applying the get algorithm to This and the
following arguments. The property (the cons pair, not just its value) is
returned, suitable for direct (destructive) manipulations with functions
expecting a var argument. Used typically in methods or with bodies. See also =:, prop and :.


: (with 'X (=: cnt 0) (inc (:: cnt)) (: cnt))
-> 1




(; 'sym1|lst [sym2|cnt ..]) -> any


Fetches a value any from the properties of a symbol, or from a
list, by applying the get algorithm to
sym1|lst and the following arguments. See also :, =: and
::.


: (put 'A 'a 1)
-> 1
: (put 'A 'b 'B)
-> B
: (put 'B 'c 7)
-> 7
: (; 'A a)
-> 1
: (; 'A b c)
-> 7




(< 'any ..) -> flg


Returns T when all arguments any are in strictly
increasing order. See also Comparing.


: (< 3 4)
-> T
: (< 'a 'b 'c)
-> T
: (< 999 'a)
-> T




(<= 'any ..) -> flg


Returns T when all arguments any are in strictly
non-decreasing order. See also Comparing.


: (<= 3 3)
-> T
: (<= 1 2 3)
-> T
: (<= "abc" "abc" "def")
-> T




(<> 'any ..) -> flg


Returns T when not all any arguments are equal
(structure equality). (<> 'any ..) is equivalent to
(not (= 'any ..)). See also Comparing.


: (<> 'a 'b)
-> T
: (<> 'a 'b 'b)
-> T
: (<> 'a 'a 'a)
-> NIL




(= 'any ..) -> flg


Returns T when all any arguments are equal
(structure equality). See also Comparing.


: (= 6 (* 1 2 3))
-> T
: (= "a" "a")
-> T
: (== "a" "a")
-> T
: (= (1 (2) 3) (1 (2) 3))
-> T




(=0 'any) -> 0 | NIL


Returns 0 when any is a number with value zero.
See also n0, lt0, le0, ge0, gt0 and =1.


: (=0 (- 6 3 2 1))
-> 0
: (=0 'a)
-> NIL




(=1 'any) -> 1 | NIL


Returns 1 when any is a number with value one.
See also =0.


: (=1 (- 6 3 2))
-> 1
: (=1 'a)
-> NIL




(=: sym|0 [sym1|cnt ..] 'any) -> any


Stores a new value any for a property key (or in the symbol
value for zero) in a symbol, or in a list. That symbol is This (if
no other arguments are given), or a symbol found by applying the get algorithm to This and the
following arguments. If the final destination is a list, the value is stored in
the CDR of an asoqed element (if the
key argument is a symbol), or the n'th element (if the key is a number). Used
typically in methods or with bodies.
See also put, : and ::.


: (with 'X (=: a 1) (=: b 2))
-> 2
: (get 'X 'a)
-> 1
: (get 'X 'b)
-> 2




(== 'any ..) -> flg


Returns T when all any arguments are the same
(pointer equality). See also n== and Comparing.


: (== 'a 'a)
-> T
: (== 'NIL NIL (val NIL) (car NIL) (cdr NIL))
-> T
: (== (1 2 3) (1 2 3))
-> NIL




(====) -> NIL


Close the current transient scope by clearing the transient index. All
transient symbols become hidden and inaccessible by the reader.
See also extern and intern.


: (setq S "abc")           # Read "abc"
-> "abc"
: (== S "abc")             # Read again, get the same symbol
-> T
: (====)                   # Close scope
-> NIL
: (== S "abc")             # Read again, get another symbol
-> NIL




(=T 'any) -> flg


Returns T when any is the symbol T.
(=T X) is equivalent to (== T X). See also nT.


: (=T 0)
-> NIL
: (=T "T")
-> NIL
: (=T T)
-> T




(> 'any ..) -> flg


Returns T when all arguments any are in strictly
decreasing order. See also Comparing.


: (> 4 3)
-> T
: (> 'A 999)
-> T




(>= 'any ..) -> flg


Returns T when all arguments any are in strictly
non-increasing order. See also Comparing.


: (>= 'A 999)
-> T
: (>= 3 2 2 1)
-> T




(>> 'cnt 'num) -> num


Shifts right the num argument by cnt
bit-positions. If cnt is negative, a corresponding left shift is
performed. See also rev.


: (>> 1 8)
-> 4
: (>> 3 16)
-> 2
: (>> -3 16)
-> 128
: (>> -1 -16)
-> -32




(? [sym ..] [pat 'any ..] . lst) -> flg


Top-level function for interactive Pilog
queries. ? is a non-evaluating front-end to the query function. It displays each result, waits
for console input, and terminates when ESC is pressed. If a preceding list of
(non-pattern-) symbols is given, they will be taken as rules to be traced by
prove. The list of variable/value
pairs is passed to goal for an initial
Pilog environment. See also pilog and
solve.


: (? (append (a b c) (d e f) @X))
 @X=(a b c d e f)
-> NIL

: (? (append @X @Y (a b c)))
 @X=NIL @Y=(a b c)
 @X=(a) @Y=(b c)
 @X=(a b) @Y=(c)
 @X=(a b c) @Y=NIL
-> NIL

: (? (append @X @Y (a b c)))
 @X=NIL @Y=(a b c)                     # ESC was pressed
-> NIL

: (? append (append @X @Y (a b c)))    # Trace 'append'
1 (append NIL (a b c) (a b c))
 @X=NIL @Y=(a b c)
2 (append (a . @X) @Y (a b c))
1 (append NIL (b c) (b c))
 @X=(a) @Y=(b c).                      # Stopped
-> NIL




@


Holds the result of the last top level expression in the current
read-eval-print loop, or the result of the conditional expression during the
evaluation of flow functions (see @
Result). When @ is used as a formal parameter in lambda expressions, it denotes a variable number of
evaluated arguments.




@@


Holds the result of the second last top level expression in the current
read-eval-print loop (see @ Result).
Some functions store a secondary return value in @@.




@@@


Holds the result of the third last top level expression in the current
read-eval-print loop (see @ Result).




^


Holds the currently executed expression during a breakpoint or an error. See
also debug, !, e and
*Dbg.


: (* (+ 3 4) (/ 7 0))
!? (/ 7 0)
Div/0
? ^
-> (/ 7 0)




(| 'num ..) -> num


Returns the bitwise OR of all num arguments. When
one of the arguments evaluates to NIL, it is returned immediately.
See also x|, & and bit?.


: (| 1 2)
-> 3
: (| 1 2 4 8)
-> 15








pil21/doc/doc.css0000644000000000000000000000074314515173473010735 0ustar  /* 22oct23 Software Lab. Alexander Burger
 * 06dec12jk
 */

html {
   background-color: #ddd;
}

body {
   margin: auto;
   max-width: 50em;
   border: 1px solid #bbb;
   background-color: white;
   padding: 2em 7% 4em 10%;
}

h5 {
   font-size: 95%;
   margin-bottom: 1em;
}

dt {
   margin: 0.4em -2em 0 0;
   font-weight: 600;
   color: #444;
}

dd {
   margin-top: 0.3em;
   margin-bottom: 0.4em;
}

code, pre {
   color: rgb(0%,40%,0%);
}

dt code {
   word-spacing: -0.04em;
}
pil21/src/Makefile0000644000000000000000000000430214732221513011121 0ustar  # 23dec24 Software Lab. Alexander Burger

.SILENT:

CC = clang
PIL = ../pil  # pil
ASM = opt -O2  # llvm-as
LLC = llc
LINK = llvm-link
SHARED = -shared
STRIP = strip

LLVM = $(shell llvm-config --version | cut -d. -f1)
ifeq ($(shell test $(LLVM) -ge 15 -a $(LLVM) -lt 17; echo $$?), 0)
	ASM += -opaque-pointers
endif

OS = $(shell uname)
CPU = $(shell uname -m)

BIN = ../bin
LIB = ../lib

INC = lib/llvm.l vers.l defs.l glob.l dec.l
SRC = main.l gc.l big.l sym.l io.l db.l apply.l flow.l subr.l

all: $(LIB)/sysdefs $(BIN)/picolisp $(LIB)/ext.so $(LIB)/ht.so $(BIN)/balance $(BIN)/ssl $(BIN)/httpGate

# System definitions
$(LIB)/sysdefs: sysdefs.c
	$(CC) -w -D_OS='"$(OS)"' -D_CPU='"$(CPU)"' sysdefs.c  &&  ./a.out > $(LIB)/sysdefs  &&  rm ./a.out

# Base system
$(BIN)/picolisp: picolisp.bc
	mkdir -p $(BIN) $(LIB)
	$(LLC) picolisp.bc -relocation-model=pic -o picolisp.s
	$(CC) picolisp.s -o $(BIN)/picolisp -rdynamic -lc -lutil -lm -ldl `pkg-config --libs readline libffi`
	$(STRIP) $(BIN)/picolisp

picolisp.bc: base.bc lib.bc
	$(LINK) -o picolisp.bc base.bc lib.bc

base.bc: base.ll
	$(ASM) -o base.bc base.ll

base.ll: $(INC) $(SRC)
	$(PIL) lib/llvm.l main.l -bye > base.ll
	mv base.map $(LIB)/map

lib.bc: pico.h lib.c
	$(CC) -O3 -w -c -o lib.bc -D_OS='"$(OS)"' -D_CPU='"$(CPU)"' `pkg-config --cflags libffi` -emit-llvm lib.c

# Extension libraries
$(LIB)/ext.so: ext.bc
	$(LLC) ext.bc -relocation-model=pic -o ext.s
	$(CC) ext.s -o $(LIB)/ext.so $(SHARED)
	$(STRIP) $(LIB)/ext.so

ext.bc: ext.ll
	$(ASM) -o ext.bc ext.ll

ext.ll: $(INC) ext.l
	$(PIL) lib/llvm.l ext.l -bye > ext.ll

$(LIB)/ht.so: ht.bc
	$(LLC) ht.bc -relocation-model=pic -o ht.s
	$(CC) ht.s -o $(LIB)/ht.so $(SHARED)
	$(STRIP) $(LIB)/ht.so

ht.bc: ht.ll
	$(ASM) -o ht.bc ht.ll

ht.ll: $(INC) ht.l
	$(PIL) lib/llvm.l ht.l -bye > ht.ll

# Tools
$(BIN)/balance: balance.c
	$(CC) -O3 -w -o $(BIN)/balance balance.c
	$(STRIP) $(BIN)/balance

# Gate
$(BIN)/ssl: ssl.c
	$(CC) -O3 -w -o $(BIN)/ssl ssl.c -lssl -lcrypto
	$(STRIP) $(BIN)/ssl

$(BIN)/httpGate: httpGate.c
	$(CC) -O3 -w -o $(BIN)/httpGate httpGate.c -lssl -lcrypto
	$(STRIP) $(BIN)/httpGate

# Clean up
clean:
	rm -f *.ll *.bc *.s

clean2: clean
	rm -f $(LIB)/sysdefs $(BIN)/balance $(BIN)/ssl $(BIN)/httpGate
pil21/src/sysdefs.c0000644000000000000000000000455314231204025011306 0ustar  // 24apr22 Software Lab. Alexander Burger

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

static void ttl(char *nm) {
   printf("\n[%s]\n", nm);
}

static void num(char *sym, long val) {
   printf("%s\t%ld\n", sym, val);
}

static void str(char *sym, char *val) {
   printf("%s\t\"%s\"\n", sym, val);
}

int main(void) {
   struct winsize term;
   struct sockaddr_in6 addr;
   struct addrinfo ai;

   printf("# %s\n", __VERSION__);
   printf("# %s\n", _OS);
   printf("# %s\n", _CPU);

   ttl("errno");
   num("EINTR", EINTR);
   num("EAGAIN", EAGAIN);
   num("EACCES", EACCES);

   ttl("stdio");
   num("BUFSIZ", BUFSIZ);

   ttl("unistd");
   num("PIPE_BUF", PIPE_BUF);
   num("PATH_MAX", PATH_MAX);

   ttl("terminal");
   num("TIOCGWINSZ", TIOCGWINSZ);
   num("TIOCSWINSZ", TIOCSWINSZ);
   num("winsize", sizeof(struct winsize));
   num("ws_row", (char*)&term.ws_row - (char*)&term);
   num("ws_col", (char*)&term.ws_col - (char*)&term);

   ttl("networking");
   num("SOCK_STREAM", SOCK_STREAM);
   num("SOCK_DGRAM", SOCK_DGRAM);
   num("AF_INET6", AF_INET6);
   num("SOL_SOCKET", SOL_SOCKET);
   num("SO_REUSEADDR", SO_REUSEADDR);
   num("IPPROTO_IPV6", IPPROTO_IPV6);
   num("IPV6_V6ONLY", IPV6_V6ONLY);
   num("INET6_ADDRSTRLEN", INET6_ADDRSTRLEN);
   num("sockaddr_in6", sizeof(struct sockaddr_in6));
   num("sin6_family",  (char*)&addr.sin6_family - (char*)&addr);
   num("sin6_addr", (char*)&addr.sin6_addr - (char*)&addr);
   num("sin6_port", (char*)&addr.sin6_port - (char*)&addr);
   num("NI_MAXHOST", NI_MAXHOST);
   num("NI_NAMEREQD", NI_NAMEREQD);
   num("addrinfo", sizeof(struct addrinfo));
   num("ai_family", (char*)&ai.ai_family - (char*)&ai);
   num("ai_socktype", (char*)&ai.ai_socktype - (char*)&ai);
   num("socklen_t", sizeof(socklen_t));
   num("ai_addrlen", (char*)&ai.ai_addrlen - (char*)&ai);
   num("ai_addr", (char*)&ai.ai_addr - (char*)&ai);
   num("ai_next", (char*)&ai.ai_next - (char*)&ai);
   num("AF_UNSPEC", AF_UNSPEC);

   return 0;
}
pil21/src/lib/llvm.l0000644000000000000000000013477214643544460011407 0ustar  # 10jul24 Software Lab. Alexander Burger

### PicoLisp LLVM frontend ###
(zap 'llvm) (symbols 'llvm 'pico)

(local) (@ @@ @@@ cross void null i1 i1* i1** i8 i8* i8** i8*** i16 i16* i16**
i32 i32* i32** i64 i64* i64** any YES NO ZERO -ZERO ONE SymTab begin end $ ?
short equ global var str const globals array table symTab inline tailcall define
struct $Nil $T $Link drop)

(import pico llvm symbols local T NIL load use setq prog */ ** >> char hex)


### Cross-compiler private ###
(symbols 'cross 'llvm 'pico)

(import any inc dec ++ shift)

(local) (*Map *Map2 putMap *Shared *Strings *Ssa *Lbl *Log *Curr *Exit *Bind
*Phi *Call *Ret log asm ssa phi +phi br label +lbl +bind type func ptr pointee
store A B C I L M N P Q V X Y Exe Prg Typ Sym Ret Args Ext Table Body Var Val
Lst Lbl Flg Skip True False Beg End Safe *Safe)

(off *Map *Map2)

(de *Err
   (and *Dbg (symbols '(cross llvm pico))) )

(de *Call . "call")

(de putMap (Sym N)
   (let F (file)
      (idx '*Map
         (def (name Sym)
            (cons
               (+ (cddr F) (or N 0))
               (pack (car F) (cadr F)) ) )
         T ) )
   Sym )

(local) de

(pico~de de Prg
   (def (putMap (car Prg)) (cdr Prg)) )

# Constant primitives
(de void . void)
(de null . null)

(de NO . `(def "0" 'i1))  # Booleans
(de YES . `(def "1" 'i1))
(de ZERO . `(def "2" 'any))  # Short number '0'
(de -ZERO . `(def "10" 'any))  # Placeholder '-0'
(de ONE . `(def "18" 'any))  # Short number '1'

# Generate LLVM-IR
(de begin (Name Flg . pico~@)
   (off *Strings)
   (prinl "source_filename = \"" Name ".l\"")
   (prinl)
   (prinl "declare {i64, i1} @llvm.uadd.with.overflow.i64(i64, i64)")
   (prinl "declare {i64, i1} @llvm.usub.with.overflow.i64(i64, i64)")
   (prinl "declare i64 @llvm.fshl.i64(i64, i64, i64)")
   (prinl "declare i64 @llvm.fshr.i64(i64, i64, i64)")
   (prinl "declare void @llvm.memcpy.p0i8.p0i8.i64(i8*, i8*, i64, i1)")
   (prinl "declare void @llvm.memset.p0i8.i64(i8*, i8, i64, i1)")
   (prinl "declare i8* @llvm.stacksave()")
   (prinl "declare void @llvm.stackrestore(i8*)")
   (prinl)
   (let *Shared Flg
      (pass load) ) )

(de *C-Defs
   (~(chop "const ") @A " " @Sym "[" @Z)
   (~(chop "const ") @A " " @Sym " " @Z)
   (~(chop "struct ") @A " " "*" @Sym ";" @Z)
   (~(chop "struct ") @A " " @Sym ";" @Z)
   (~(chop "void *") @Sym "(" @Z)
   (~(chop "void ") @Sym "(" @Z)
   (~(chop "char *") @Sym "(" @Z)
   (~(chop "int ") @Sym ";" @Z)
   (~(chop "int ") @Sym "(" @Z)
   (~(chop "int32_t ") @Sym "(" @Z)
   (~(chop "int64_t ") @Sym "(" @Z)
   (~(chop "uint64_t ") @Sym ";" @Z)
   (~(chop "uint64_t ") @Sym "(" @Z)
   (~(chop "jmp_buf ") @Sym ";" @Z)
   (~(chop "ffi *") @Sym "(" @Z) )

(de end (Map . pico~@)
   (prinl)
   (for L *Strings
      (prinl (caddr L) " = " (cdddr L)) )
   (when Map
      (out Map
         (for Sym (idx '*Map)
            (let X (val Sym)
               (prinl "llvm~" Sym " (" (car X) " \"@src/" (cdr X) "\" llvm pico)") ) )
         (while (args)
            (let (F (next)  N 1)
               (use (@A @Sym @Z)
                  (in F
                     (until (eof)
                        (let L (circ (line))
                           (when (find match *C-Defs L)
                              (prinl "llvm~" @Sym " (" N " \"@src/" F "\" llvm pico)") ) )
                        (inc 'N) ) ) ) ) )
         (for Sym (idx '*Map2)
            (let X (val (car (idx '*Map (val Sym))))
               (prinl "pico~" Sym " (" (car X) " \"@src/" (cdr X) "\" llvm pico)") ) ) ) ) )

(de log (A)
   (let? L
      (chop
         (or A
            (and *Log
               (symbols '(llvm pico cross) (sym (up 2))) ) ) )
      (and (nth L 65) (con pico~@ "..."))
      (link (cons NIL L)) ) )

(de asm Lst
   (for L (cddr Lst)
      (def (putMap (car L))
         (bind (car Lst)
            (mapc set (car Lst) (cdr L))
            (cons (caadr Lst)
               '(log)
               (let (@ '@  @@ '@@  @@@ '@@@)
                  (fill (cdadr Lst)) ) ) ) ) ) )

(de ssa (N . pico~@)
   (link
      (cons
         (pack "%" N)
         (pass pack) ) ) )

(de phi (Lbl Var)
   (let? Val (val Var)
      (if (asoq Lbl *Phi)
         (let L pico~@
            (if (asoq Var L)
               (conc pico~@ (list (cons *Curr Val)))
               (con L
                  (cons
                     (list Var NIL (cons *Curr Val))
                     (cdr L) ) ) ) )
         (queue '*Phi
            (list Lbl (list Var NIL (cons *Curr Val))) ) ) ) )

(de +phi (Lbl)
   (let M NIL
      (for Var *Bind
         (unless (memq Var M)
            (phi Lbl Var)
            (push 'M Var) ) ) )
   Lbl )

(de br (A B C)
   (link
      (if B
         (pack "br i1 " A ", label %$" (+phi B) ", label %$" (+phi C))
         (pack "br label %$" (+phi A)) ) ) )

(de label (N)
   (for L (cdr (asoq (link (setq *Curr N)) *Phi))
      (when
         (or
            (not (name (car L)))
            (memq (car L) *Bind) )
         (let Typ
            (or
               (pick
                  '((X)
                     (and (sym? (cdr X)) (val (cdr X))) )
                  (cddr L) )
               'i64 )
            (cond
               ((== void Typ) void)
               ((fully
                     '((X)
                        (cond
                           ((=T (cdr X)))
                           ((num? (cdr X))
                              (memq Typ '(i8 i16 i32 i64 any)) )
                           (T
                              (== (type Typ) (type (val (cdr X)))) ) ) )
                     (cddr L) )
                  (set
                     (car L)  # Var
                     (set
                        (cdr L)  # Ssa
                        (def (pack "%" (inc '*Ssa)) Typ) ) ) )
               (T void) ) ) ) ) )

(de +lbl ()
   (inc '*Lbl) )

(de +bind (Lst Var)
   (when
      (fish
         '((X)
            (when (pair X)
               (or
                  (and
                     (memq (car X) '(llvm~inc llvm~dec))
                     (pair (cadr X))
                     (== 'quote (caadr X))
                     (== Var (cdadr X)) )
                  (and
                     (memq (car X) '(llvm~setq llvm~++ llvm~shift))
                     (for (L (cdr X)  L  (cddr L))
                        (T (== Var (car L)) T) ) )
                  (and
                     (== (car X) 'llvm~xchg)
                     (or
                        (and (== 'quote (caadr X)) (== Var (cdadr X)))
                        (and (== 'quote (caaddr X)) (== Var (cdaddr X))) ) )
                  (and
                     (sym? (car X))
                     (memq Var (; X 1 phi)) ) ) ) )
         Lst )
      (push '*Bind Var) ) )

(de type (Typ)
   (cond
      ((== 'any Typ) 'i64)
      ((== null Typ) 'i8*)
      ((pair Typ) (func pico~@))
      (T Typ) ) )

(de func (Lst)
   (pack
      (type (car Lst))
      "("
      (glue "," (mapcar type (cdr Lst)))
      ")*" ) )

(de ptr (Typ)
   (or
      (pair Typ)
      (if (== 'any Typ)
         Typ
         (intern (pack Typ "*")) ) ) )

(de pointee (Typ)
   (if (== 'any Typ)
      Typ
      (intern (head -1 (chop Typ))) ) )

(de store (X P Ofs)
   (nond
      ((memq (val P) '(i64 any))
         (when (num? X)
            (setq X (def (format X) (pointee (val P)))) )
         (ifn Ofs
            (link
               (pack "store " (type (val X)) " " X ", "
                  (type (val P)) (and (pair (val P)) "*")
                  " " P ) )
            (ssa (inc '*Ssa) "getelementptr "
               (type (val X)) ", "
               (type (val P)) (and (pair (val P)) "*")
               " " P ", i32 " Ofs )
            (link
               (pack "store " (type (val X)) " " X ", "
                  (type (val P)) (and (pair (val P)) "*")
                  " %" *Ssa ) ) ) )
      ((pre? "@" P)
         (ssa (inc '*Ssa) "inttoptr i64 " P " to i64*")
         (when Ofs
            (ssa (inc '*Ssa) "getelementptr i64, i64* %" (dec *Ssa) ", i32 " Ofs) )
         (link (pack "store i64 " X ", i64* %" *Ssa)) )
      (NIL
         (link (pack "store i64 " X ", i64* " P)) ) )
   X )

(de $ (Str)
   (if (assoc Str *Strings)
      (cadr pico~@)
      (let
         (Sym (pack "@$" (inc (length *Strings)))
            Arr (pack "[" (inc (size Str)) " x i8]")
            Val (def (pack "bitcast (" Arr "* " Sym " to i8*)") 'i8*) )
         (push '*Strings
            (cons Str Val Sym
               (pack
                  (make
                     (link "private constant " Arr " c\"")
                     (for C (chop Str)
                        (if (or (> " " C) (sub? C "\""))
                           (link "\\" (pad 2 (hex (char C))))
                           (link C) ) )
                     (link "\\00\"") ) ) ) )
         Val ) ) )

(de short (N)
   (| 2 (>> -4 N)) )

(de equ Lst
   (while Lst
      (set (putMap (++ Lst)) (eval (++ Lst))) ) )

(de global (Sym Typ Val)
   (prin
      "@" Sym " = "
      (unless (and Val (not *Shared)) "external ")
      "global " (type Typ) )
   (and Val (putMap Sym))
   (cond
      (*Shared)
      ((pre? "_" Val) (prin " @" pico~@))
      ((pre? "$" Val)
         (if (; Val offset)
            (prin
               " ptrtoint (i8* getelementptr (i8, i8* bitcast (["
               (; Val table length)
               " x i64]* @"
               (; Val table)
               " to i8*), i32 "
               pico~@
               ") to i64)" )
            (prin " ptrtoint ("
               (if (== 'any Typ) 'i64 Typ)
               "* @" pico~@ " to "
               (if (== 'any Typ) 'i64 Typ)
               ")" ) ) )
      (Val (prin " " pico~@)) )
   (prinl)
   (def Sym (def (pack "@" Sym) (ptr Typ))) )

(de var Lst
   (global
      (++ Lst)
      (if (cdr Lst) (++ Lst) 'any)
      (eval (car Lst)) ) )

(de str Lst
   (let ((Sym Val) Lst  Arr (pack "[" (inc (size Val)) " x i8]"))
      (def (putMap Sym)
         (def (pack "bitcast (" Arr "* @" Sym " to i8*)") 'i8*) )
      (prin "@" Sym " = constant " Arr " c\"")
      (for C (chop Val)
         (if (or (> " " C) (sub? C "\"\\"))
            (prin "\\" (pad 2 (hex (char C))))
            (prin C) ) )
      (prinl "\\00\"") ) )

(de const (Val)
   (cond
      ((pre? "_" Val)
         (prin
            "  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast "
            (if (pre? "__" Val) "(i64(i64,i64)*" "(i64(i64)*")
            " @"
            pico~@
            " to i8*), i32 2) to i64)" ) )
      ((pre? "$" Val)
         (if (; Val offset)
            (prin
               "  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (["
               (; Val table length)
               " x i64]* @"
               (; Val table)
               " to i8*), i32 "
               pico~@
               ") to i64)" )
            (prin Val) ) )
      (T
         (prin "  i64 " (eval Val)) ) ) )

(de array Lst
   (let
      (Sym (++ Lst)
         Typ (++ Lst)
         Len (if (pair Lst) (length Lst) (eval Lst)) )
      (def (putMap Sym)
         (def
            (pack
               "bitcast (["
               Len " x " (setq Typ (type Typ))
               "]* @" Sym " to " (ptr Typ) ")" )
            (ptr Typ) ) )
      (prin
         "@" Sym " = " (when *Shared "external ")
         "global [" Len " x " Typ "]" )
      (cond
         (*Shared (prinl))
         ((atom Lst) (prinl " zeroinitializer"))
         (T
            (prinl *Shared " [")
            (for (I . X) Lst
               (prinl
                  "  " Typ " " (eval X)
                  (unless (== I Len) ",") ) )
            (prinl "]") ) ) ) )

(de table Args
   (let
      (Table (++ Args)
         I 0
         @N (* 8 (put Table 'length (length Args)))
         @S (caar Args) )
      (def (putMap Table)
         (curry (@N @S) A
            (if A @N (i8* @S)) ) )
      (prinl
         "@" Table " = " (when *Shared "external ")
         "global [" (; Table length) " x i64]" (unless *Shared " [") )
      (for (I . Lst) Args
         (let Typ (if (caddr Lst) (cadr Lst) 'any)
            (let? Sym (car Lst)
               (put (putMap Sym I) 'table Table)
               (put Sym 'offset (* 8 (dec I)))
               (def Sym
                  (def
                     (pack
                        (if (== 'any Typ)
                           "ptrtoint (i8* getelementptr (i8, i8* bitcast (["
                           "bitcast (i8* getelementptr (i8, i8* bitcast ([" )
                        (; Table length)
                        " x i64]* @"
                        Table
                        " to i8*), i32 "
                        (; Sym offset)
                        ") to "
                        (type Typ)
                        (unless (== 'any Typ) "*")
                        ")" )
                     (ptr Typ) ) ) )
            (unless *Shared
               (nond
                  ((caddr Lst) (const (cadr Lst)))
                  ((pair Typ)
                     (if (sub? "*" Typ)
                        (prin "  i64 ptrtoint" " (" (cadr Lst) " " (caddr Lst) " to i64)")
                        (prin "  i64 " (caddr Lst)) ) )
                  (NIL
                     (prin
                        "  i64 ptrtoint ("
                        (func pico~@)
                        (if (== null (caddr Lst)) " " " @")
                        (caddr Lst)
                        " to i64)" ) ) )
               (prinl (unless (== Lst (last Args)) ",")) ) ) ) )
   (unless *Shared
      (prinl "], align 8") ) )

(de symTab Args
   (let (Table 'SymTab  I 0)
      (put Table 'length
         (sum
            '((L)
               (if (> (length (cadr L)) 7) 4 2) )
            Args ) )
      (prinl
         "@" Table " = " (when *Shared "external ")
         "global [" (; Table length) " x i64]" (unless *Shared " [") )
      (for (J . Lst) Args
         (let? Sym (car Lst)
            (put (putMap Sym J) 'table Table)
            (put Sym 'offset (+ I (or (cadddr Lst) 8)))
            (def Sym
               (def
                  (pack
                     "ptrtoint (i8* getelementptr (i8, i8* bitcast ([" (; Table length) " x i64]* @"
                     Table
                     " to i8*), i32 "
                     (; Sym offset)
                     ") to i64)" )
                  'any ) ) )
         (unless *Shared
            (let Name
               (when (str? (cadr Lst))
                  (prinl "  ; # [" I "] " pico~@)
                  (let L (chop pico~@)
                     (make
                        (when (nth L 8)  # Max 15 ASCII characters
                           (let (D 0  N 0)
                              (do 8
                                 (setq
                                    N (| N (>> D (char (++ L))))
                                    D (- D 8) ) )
                              (link N) ) )
                        (let (D 0  N 0)
                           (while L
                              (setq
                                 N (| N (>> D (char (++ L))))
                                 D (- D 8) ) )
                           (link (short N)) ) ) ) )
               (nond  # Name
                  (Name
                     (const (cadr Lst))
                     (prinl ",") )
                  ((cdr Name)
                     (prinl "  i64 " (car Name) ",") )
                  (NIL
                     (prinl
                        "  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([" (; Table length) " x i64]* @"
                        Table
                        " to i8*), i32 "
                        (+ I 16 4)
                        ") to i64)," ) ) )
               (const (caddr Lst))  # Value
               (and
                  (cadr Lst)
                  (pre? "_" (caddr Lst))
                  (idx '*Map2 (def (cadr Lst) (caddr Lst)) T) )
               (when (cdr Name)  # Long name
                  (prinl ",")
                  (inc 'I 16)
                  (prinl "  i64 " (car Name) ",")
                  (prin "  i64 " (cadr Name)) ) )
            (prinl (unless (== Lst (last Args)) ",")) )
         (inc 'I 16) ) )
   (unless *Shared
      (prinl "], align 16") ) )

(de inline Lst
   (let L (and (lst? (car Lst)) (++ Lst))
      (put
         (def (putMap (++ Lst))
            (let ((@Args . @Body) Lst)
               (bind
                  (mapcar
                     '((X) (cons X (name X)))
                     @Args )
                  (setq
                     @Body (fill @Body @Args)
                     @Args (mapcar val @Args) ) )
               (fill
                  '(@Args
                     (log)
                     (let *Log NIL
                        (let *Bind NIL
                           (for Var '@Args
                              (+bind '@Body Var) )
                           . @Body ) ) ) ) ) )
         'phi
         L ) ) )

(de tailcall Prg
   (let *Call "tail call"
      (run Prg) ) )

(de define (Ext Ret Sym Args Body)
   (and Body (prinl))
   (setq *Ssa -1)
   (off *Bind *Phi *Safe)
   (bind (and Body (mapcar fin Args))
      (with Sym
         (setq *Ret
            (if Ret
               (type Ret)
               (=: noreturn T)
               void ) )
         (cond
            (Ext (prin "declare " *Ret " @" Sym "("))
            (Body
               (putMap Sym)
               (prin "define " *Ret " @" Sym "(") ) )
         (when
            (=: args
               (replace
                  (ifn Body
                     Args
                     (mapcar
                        '((A)
                           (+bind Body (fin A))
                           (set
                              (set (fin A) (pack "%" (inc '*Ssa)))
                              (if (atom A) 'any (car A)) ) )
                        Args ) )
                  'any 'i64 ) )
            (=: sign (cons *Ret (: args)))
            (when (or Ext Body)
               (prin (car (: args)))
               (for A (cdr (: args))
                  (prin ", " A) ) ) )
         (cond
            (Ext (prinl ")"))
            (Body (prinl ") align 8 {")) )
         (def This
            (list 'pico~@
               (make
                  (link 'let 'A
                     (list 'mapcar
                        ''((Typ) (pack Typ " " (next)))
                        (lit (: args)) ) )
                  (link '(log))
                  (let L
                     (list
                        '*Call " " (lit *Ret) " @" (lit Sym)
                        "(" '(glue ", " A) ")" )
                     (link
                        (if (== void *Ret)
                           (list 'link (cons 'pack L))
                           (cons 'ssa '(inc '*Ssa) L) ) ) )
                  (if (: noreturn)
                     (link '(link "unreachable") NIL)
                     (link
                        (or
                           (== void *Ret)
                           (list 'def '(pack "%" *Ssa) (lit Ret)) ) ) ) ) ) ) )
      (when Body
         (let (*Lbl 1  *Log T)
            (for X
               (make
                  (label *Lbl)
                  (let? R (run Body)
                     (and *Safe (drop *Safe))
                     (if (== void *Ret)
                        (link "ret void")
                        (link (pack "ret " *Ret " " R)) ) ) )
               (cond
                  ((num? X)
                     (prinl "$" X ":")
                     (for L (cdr (asoq X *Phi))
                        (when (cadr L)
                           (prin
                              "  " (cadr L) " = phi "
                              (type (val (cadr L)))
                              " [" (cdaddr L) ", %$" (caaddr L) "]" )
                           (for X (cdddr L)
                              (prin ", [" (cdr X) ", %$" (car X) "]") )
                           (prinl " ; # " (or (name (car L)) "->")) ) ) )
                  ((atom X) (prinl "  " X))
                  ((not (car X)) (prinl "; # " (cdr X)))
                  (T (prinl "  " (car X) " = " (cdr X))) ) ) )
         (prinl "}") ) ) )

(de struct Lst
   (def (putMap (car Lst))
      (let
         (@N 0
            @L
            (mapcar
               '((X)
                  (prog1
                     (cons (car X) @N (cddr X))
                     (inc '@N (eval (cadr X))) ) )
               (cdr Lst) ) )
         (curry (@N @L) (@P)
            (if (=T @P)
               @N
               (curry (@P) Args
                  (log)
                  (let *Log NIL
                     (nond
                        (Args '@P)
                        ((or
                              (asoq (car Args) '@L)
                              (and
                                 (pair (car Args))
                                 (asoq (car pico~@) '@L) ) )
                           (quit "Bad struct item" (car Args)) )
                        (NIL
                           (let P (llvm~ofs '@P (cadr pico~@))
                              (let Q ((ptr (caddr pico~@)) P)
                                 (if (atom (car Args))
                                    (if (cadr Args)
                                       (llvm~set Q (eval pico~@ 1 '(*Log)))
                                       (llvm~val Q) )
                                    (ifn (cdar Args)
                                       P
                                       (let A (cadar Args)
                                          (setq P
                                             (llvm~ofs P
                                                (if (sym? A) (; A offset) (eval A 1 '(*Log))) ) ) )
                                       (ifn (cddar Args)
                                          P
                                          (let Q ((ptr (caddar Args)) P)
                                             (if (cadr Args)
                                                (llvm~set Q (eval pico~@ 1 '(*Log)))
                                                (llvm~val Q) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) )


### Cross compiler overridden ###
(symbols '(cross pico llvm))

(de llvm~de Lst
   (define
      (or
         (and (=T (car Lst)) (++ Lst))
         (and
            *Shared
            (not ((if (lst? (cadr Lst)) cddr cdddr) Lst)) ) )
      (if (lst? (cadr Lst)) 'any (++ Lst))
      (car Lst)
      (cadr Lst)
      (cddr Lst) ) )

(de llvm~evBool (Exe)
   (let X (eval Exe)
      (cond
         ((num? X) (if (=0 X) NO YES))
         ((== 'i1 (val X)) X)
         (T
            (let *Log NIL
               (llvm~n0 X) ) ) ) ) )

# Type casts
(asm ()
   ((X)
      (if (num? X)
         (def (format X) 'i8)
         (let V (type (val X))
            (casq V
               ((i16 i32 i64 any) (ssa (inc '*Ssa) "trunc " V " " X " to i8"))
               (T (quit "Bad type" V)) ) )
         (def (pack "%" *Ssa) 'i8) ) )
   (llvm~i8) )

(asm ()
   ((X)
      (if (num? X)
         (def (format X) 'i16)
         (let V (type (val X))
            (casq V
               ((i1 i8) (ssa (inc '*Ssa) "zext " V " " X " to i16"))
               ((i64 any) (ssa (inc '*Ssa) "trunc " V " " X " to i16"))
               (T (quit "Bad type" V)) ) )
         (def (pack "%" *Ssa) 'i16) ) )
   (llvm~i16) )

(asm ()
   ((X)
      (if (num? X)
         (def (format X) 'i32)
         (let V (type (val X))
            (casq V
               ((i1 i8) (ssa (inc '*Ssa) "zext " V " " X " to i32"))
               ((i64 any) (ssa (inc '*Ssa) "trunc " V " " X " to i32"))
               (T (quit "Bad type" V)) ) )
         (def (pack "%" *Ssa) 'i32) ) )
   (llvm~i32) )

(asm ()
   ((X)
      (let V (val X)
         (if (== 'any V)
            (def (name X) 'i64)
            (casq V
               ((i1 i8) (ssa (inc '*Ssa) "zext " V " " X " to i64"))
               ((i16 i32) (ssa (inc '*Ssa) "sext " V " " X " to i64"))
               ((i1* i8* i8** i16* i16** i32* i32** i64* i64**)
                  (ssa (inc '*Ssa) "ptrtoint " V " " X " to i64") )
               (T (quit "Bad type" V)) )
            (def (pack "%" *Ssa) 'i64) ) ) )
   (llvm~i64) )

(asm (@Typ)
   ((X)
      (let V (val X)
         (cond
            ((pair V)
               (ssa (inc '*Ssa) "bitcast " (func V) "* " X " to " '@Typ)
               (def (pack "%" *Ssa) '@Typ) )
            ((memq V '(i64 any))
               (ssa (inc '*Ssa) "inttoptr i64 " X " to " '@Typ)
               (def (pack "%" *Ssa) '@Typ) )
            ((== null V)
               (ssa (inc '*Ssa) "inttoptr i64 0 to " '@Typ)
               (def (pack "%" *Ssa) '@Typ) )
            ((sub? "*" V)
               (if (== V '@Typ)
                  X
                  (ssa (inc '*Ssa) "bitcast " V " " X " to " '@Typ)
                  (def (pack "%" *Ssa) '@Typ) ) )
            (T (quit "Bad type" V)) ) ) )
   (llvm~i1* llvm~i1*)
   (llvm~i8* llvm~i8*)
   (llvm~i8** llvm~i8**)
   (llvm~i16* llvm~i16*)
   (llvm~i32* llvm~i32*)
   (llvm~i64* llvm~i64*) )

(asm ()
   ((X)
      (if (num? X)
         (def (format X) 'any)
         (let V (val X)
            (cond
               ((pre? "@$" X)
                  (ssa (inc '*Ssa) "ptrtoint i64* " X " to i64") )
               ((== 'i64 V)
                  (def (name X) 'any) )
               ((memq V '(i1* i8* i16* i32* i64*))
                  (ssa (inc '*Ssa) "ptrtoint " V " " X " to i64") )
               (T (quit "Bad type" V)) )
            (def (pack "%" *Ssa) 'any) ) ) )
   (llvm~any) )

(asm ()
   (Args
      (if (pair (car Args))
         (def (pack "@" (cadr Args)) @)
         (i8*
            (def (pack "@" (car Args))
               (func (; Args 1 sign)) ) ) ) )
   (llvm~fun) )

(asm (@Tag)
   ((X)
      (let V (val X)
         (casq V
            ((i64 any)
               (ssa (inc '*Ssa) "add i64 " X ", " @Tag)
               (def (pack "%" *Ssa) 'any) )
            ((i1* i8* i64*)
               (ssa (inc '*Ssa) "ptrtoint " V " " X " to i64")
               (ssa (inc '*Ssa) "add i64 %" (dec *Ssa) ", " @Tag)
               (ssa (inc '*Ssa) "inttoptr i64 %" (dec *Ssa) " to " V)
               (def (pack "%" *Ssa) V) )
            (T (quit "Bad type" V)) ) ) )
   (llvm~big 4)
   (llvm~dig -4)
   (llvm~tail -8) )

# Type checks
(asm (@Tag @Pred)
   ((X)
      (setq llvm~@ X)
      (ssa (inc '*Ssa) "and i64 " X ", " @Tag)
      (ssa (inc '*Ssa) "icmp " @Pred " i64 %" (dec *Ssa) ", 0")
      (def (pack "%" *Ssa) 'i1) )
   (llvm~cnt? 2 "ne")
   (llvm~big? 4 "ne")
   (llvm~num? 6 "ne")
   (llvm~sym? 8 "ne")
   (llvm~sign? 8 "ne")
   (llvm~atom 15 "ne")
   (llvm~pair 15 "eq") )

(asm ()
   ((X)
      (setq llvm~@ X)
      (ssa (inc '*Ssa) "xor i64 " X ", 8")
      (ssa (inc '*Ssa) "and i64 %" (dec *Ssa) ", 14")
      (ssa (inc '*Ssa) "icmp eq i64 %" (dec *Ssa) ", 0")
      (def (pack "%" *Ssa) 'i1) )
   (llvm~symb?) )

(asm ()
   ((X)
      (ssa (inc '*Ssa) "icmp eq i1 " X ", 0")
      (def (pack "%" *Ssa) 'i1) )
   (llvm~not) )

(asm (@Sym)
   ((X)
      (setq llvm~@ X)
      (ssa (inc '*Ssa) "icmp eq i64 " X ", " @Sym)
      (def (pack "%" *Ssa) 'i1) )
   (llvm~nil? $Nil)
   (llvm~t? $T) )

# Comparisons
(asm (@Pred)
   ((X Y)
      (setq llvm~@ X)
      (ssa (inc '*Ssa) "icmp " @Pred " "
         (type (val (if (sym? X) X Y)))
         " " X ", " Y )
      (def (pack "%" *Ssa) 'i1) )
   (llvm~== "eq")
   (llvm~<> "ne") )

(asm (@Pred1 @Pred2)
   ((X Y)
      (setq llvm~@ X)
      (let V (type (val (if (sym? X) X Y)))
         (ssa (inc '*Ssa) "icmp "
            (if (== 'i32 V) @Pred1 @Pred2)
            " " V " " X ", " Y ) )
      (def (pack "%" *Ssa) 'i1) )
   (llvm~> "sgt" "ugt")
   (llvm~>= "sge" "uge")
   (llvm~< "slt" "ult")
   (llvm~<= "sle" "ule") )

(asm (@Pred)
   ((X)
      (setq llvm~@ X)
      (ssa (inc '*Ssa) "icmp " @Pred " "
         (type (val X)) " " X ", "
         (if (sub? "*" (val X)) null 0) )
      (def (pack "%" *Ssa) 'i1) )
   (llvm~=0 "eq")
   (llvm~n0 "ne") )

(asm (@Pred)
   ((X)
      (setq llvm~@ X)
      (ssa (inc '*Ssa) "icmp " @Pred
         " " (type (val X)) " " X ", 0" )
      (def (pack "%" *Ssa) 'i1) )
   (llvm~gt0 "sgt")
   (llvm~ge0 "sge")
   (llvm~le0 "sle")
   (llvm~lt0 "slt") )

# Arithmetics
(asm (@Op1 @Op2 @Sgn)
   ((X . @)
      (cond
         ((num? X) (pass @Op1 X))
         ((args)
            (let V (val X)
               (for (Y (next)  Y  (next))
                  (casq V
                     ((i8 i32 i64 any)
                        (when (and (sym? Y) (== 'i1 (val Y)))
                           (ssa (inc '*Ssa) "zext i1 " Y " to i64")
                           (setq Y (pack "%" *Ssa)) )
                        (ssa (inc '*Ssa) @Op2 " " (type V) " " X ", " Y) )
                     ((i1* i1** i8* i8** i8*** i32* i32** i64* i64**)
                        (let Typ (pointee V)
                           (if (num? Y)
                              (ssa (inc '*Ssa) "getelementptr " Typ ", " V " " X ", i32 " @Sgn Y)
                              (ssa (inc '*Ssa) "ptrtoint " V " " X " to i64")
                              (ssa (inc '*Ssa) "ptrtoint " (val Y) " " Y " to i64")
                              (ssa (inc '*Ssa) @Op2 " i64 %" (- *Ssa 2) ", %" (dec *Ssa))
                              (setq V 'i64) ) ) )
                     (T (quit "Bad type" V)) )
                  (setq X (def (pack "%" *Ssa) V)) ) ) )
         (T
            (ssa (inc '*Ssa) @Op2 " " (type (val X)) " 0, " X)
            (def (pack "%" *Ssa) (val X)) ) ) )
   (llvm~+ + "add")
   (llvm~- - "sub" "-") )

(asm (@Op)
   ((X Y C)
      (when (and (sym? Y) (== 'i1 (val Y)))
         (ssa (inc '*Ssa) "zext i1 " Y " to i64")
         (setq Y (pack "%" *Ssa)) )
      (ssa (inc '*Ssa) "call {i64, i1} @llvm.u" @Op ".with.overflow.i64(i64 " X ", i64 " Y ")")
      (ssa (inc '*Ssa) "extractvalue {i64, i1} %" (dec *Ssa) ", 1")
      (ssa (inc '*Ssa) "extractvalue {i64, i1} %" (- *Ssa 2) ", 0")
      (when C
         (ssa (inc '*Ssa) "zext i1 " C " to i64")
         (ssa (inc '*Ssa) "call {i64, i1} @llvm.u" @Op ".with.overflow.i64(i64 %" (- *Ssa 2) ", i64 %" (dec *Ssa) ")")
         (ssa (inc '*Ssa) "extractvalue {i64, i1} %" (dec *Ssa) ", 1")
         (ssa (inc '*Ssa) "or i1 %" (- *Ssa 5) ", %" (dec *Ssa))
         (ssa (inc '*Ssa) "extractvalue {i64, i1} %" (- *Ssa 3) ", 0") )
      (setq llvm~@@ (def (pack "%" (dec *Ssa)) 'i1))
      (def (pack "%" *Ssa) 'i64) )
   (llvm~add "add")
   (llvm~sub "sub") )

(asm (@Op1 @Op2 @Sgn)
   ((X Y)
      (if (num? X)
         (if Y (@Op1 X @) (@Op1 X))
         (default Y 1)
         (let
            (Typ (if (num? Y) 'i32 (type (val Y)))
               Z (or (pre? "%" X) (val X))
               V (val Z) )
            (casq V
               ((i8 i32 i64 any)
                  (ssa (inc '*Ssa) @Op2 " " (type V) " " Z ", " Y) )
               ((i1* i1** i8* i8** i8*** i16* i16** i32* i32** i64* i64**)
                  (ssa (inc '*Ssa) "getelementptr " (pointee V) ", " V " " Z ", " Typ " " @Sgn Y) )
               (T (quit "Bad type" V)) )
            (prog1
               (def (pack "%" *Ssa) V)
               (unless (pre? "%" X)
                  (set X @) ) ) ) ) )
   (llvm~inc inc "add")
   (llvm~dec dec "sub" "-") )

(asm (@Op1 @Op2)
   ((X Y)
      (if (and (num? X) (num? Y))
         (@Op1 X Y)
         (let V (type (val (if (sym? X) X Y)))
            (ssa (inc '*Ssa) @Op2 " " V " " X ", " Y)
            (def (pack "%" *Ssa) V) ) ) )
   (llvm~* * "mul")
   (llvm~/ / "udiv")
   (llvm~% % "urem")
   (llvm~& & "and")
   (llvm~| | "or")
   (llvm~x| x| "xor") )

(asm ()
   ((X Y)
      (unless (num? X)
         (ssa (inc '*Ssa) "zext i64 " X " to i128")
         (setq X (pack "%" *Ssa)) )
      (ssa (inc '*Ssa) "zext i64 " Y " to i128")
      (ssa (inc '*Ssa) "mul i128 " X ", %" (dec *Ssa))
      (ssa (inc '*Ssa) "lshr i128 %" (dec *Ssa) ", 64")
      (ssa (inc '*Ssa) "trunc i128 %" (dec *Ssa) " to i64")
      (setq llvm~@@@ (def (pack "%" *Ssa) 'i64))
      (ssa (inc '*Ssa) "trunc i128 %" (- *Ssa 3) " to i64")
      (def (pack "%" *Ssa) 'i64) )
   (llvm~mul) )

(asm ()
   ((X Y Z)
      (ssa (inc '*Ssa) "zext i64 " X " to i128")
      (ssa (inc '*Ssa) "shl i128 %" (dec *Ssa) ", 64")
      (ssa (inc '*Ssa) "zext i64 " Y " to i128")
      (ssa (setq Y (inc '*Ssa)) "or i128 %" (- *Ssa 2) ", %" (dec *Ssa))
      (unless (num? Z)
         (ssa (inc '*Ssa) "zext i64 " Z " to i128")
         (setq Z (pack "%" *Ssa)) )
      (ssa (inc '*Ssa) "urem i128 %" Y ", " Z)
      (ssa (inc '*Ssa) "trunc i128 %" (dec *Ssa) " to i64")
      (setq llvm~@@@ (def (pack "%" *Ssa) 'i64))
      (ssa (inc '*Ssa) "udiv i128 %" Y ", " Z)
      (ssa (inc '*Ssa) "trunc i128 %" (dec *Ssa) " to i64")
      (def (pack "%" *Ssa) 'i64) )
   (llvm~div) )

(asm (@Op @Op2)
   ((X Y Z)
      (when (num? X)
         (setq X (def (format X) 'i64)) )
      (ifn Z
         (let V (type (val X))
            (ssa (inc '*Ssa) @Op " " V " " X ", " Y)
            (def (pack "%" *Ssa) V) )
         (ssa (inc '*Ssa) "call "
            "i64 @llvm." @Op2 ".i64("
            "i64 " X ", "
            "i64 " Y ", "
            "i64 " Z ")" )
         (def (pack "%" *Ssa) 'i64) ) )
   (llvm~shl "shl" "fshl")
   (llvm~shr "lshr" "fshr") )

# Memory access
(asm ()
   ((X Y)
      (if (=0 Y)
         X
         (casq (val X)
            (any
               (if (num? Y)
                  (ssa (inc '*Ssa) "add i64 " X ", " (* 8 Y))
                  (if (== 'i64 (val Y))
                     (ssa (inc '*Ssa) "shl i64 " Y ", 3")
                     (ssa (inc '*Ssa) "zext " (val Y) " " Y " to i64")
                     (ssa (inc '*Ssa) "shl i64 %" (dec *Ssa) ", 3") )
                  (ssa (inc '*Ssa) "add i64 " X ", %" (dec *Ssa)) ) )
            ((i1* i1** i8* i8** i8*** i32* i32** i64* i64**)
               (ssa (inc '*Ssa) "getelementptr " (pointee (val X)) ", "
                  (val X) " " X ", "
                  (if (num? Y) 'i32 (val Y)) " " Y ) )
            (T (quit "Bad type" (val X))) )
         (def (pack "%" *Ssa) (val X)) ) )
   (llvm~ofs) )

(asm ()
   ((X)
      (ssa (inc '*Ssa) "inttoptr i64 " X " to i64*")
      (ssa (inc '*Ssa) "load i64, i64* %" (dec *Ssa))
      (def (pack "%" *Ssa) 'any) )
   (llvm~car) )

(asm ()
   ((X)
      (ssa (inc '*Ssa) "inttoptr i64 " X " to i64*")
      (ssa (inc '*Ssa) "getelementptr i64, i64* %" (dec *Ssa) ", i32 1")
      (ssa (inc '*Ssa) "load i64, i64* %" (dec *Ssa))
      (def (pack "%" *Ssa) 'any) )
   (llvm~cdr) )

(asm ()
   (Args
      (ssa (inc '*Ssa) "inttoptr i64 " (val (car Args)) " to i64*")
      (ssa (inc '*Ssa) "load i64, i64* %" (dec *Ssa))
      (let P *Ssa
         (ssa (inc '*Ssa) "getelementptr i64, i64* %" (- *Ssa 2) ", i32 1")
         (ssa (inc '*Ssa) "load i64, i64* %" (dec *Ssa))
         (set (car Args) (def (pack "%" *Ssa) 'any))
         (def (pack "%" P) 'any) ) )
   (llvm~++) )

(asm ()
   (Args
      (ssa (inc '*Ssa) "inttoptr i64 " (val (car Args)) " to i64*")
      (ssa (inc '*Ssa) "getelementptr i64, i64* %" (dec *Ssa) ", i32 1")
      (ssa (inc '*Ssa) "load i64, i64* %" (dec *Ssa))
      (set (car Args) (def (pack "%" *Ssa) 'any)) )
   (llvm~shift) )

(asm ()
   (@
      (let (X (next)  Ofs)
         (when (num? X)
            (setq Ofs (dec X)  X (next)) )
         (casq (val X)
            (any
               (if (pre? "@" X)
                  (ssa (inc '*Ssa) "load " "i64, i64* " X)
                  (ssa (inc '*Ssa) "inttoptr i64 " X " to i64*")
                  (when Ofs
                     (ssa (inc '*Ssa) "getelementptr i64, i64* %" (dec *Ssa) ", i32 " Ofs) )
                  (ssa (inc '*Ssa) "load " "i64, i64* %" (dec *Ssa)) )
               (def (pack "%" *Ssa) 'any) )
            ((i1* i1** i8* i8** i8*** i16* i16** i32* i32** i64* i64**)
               (let Typ (pointee (val X))
                  (ifn Ofs
                     (ssa (inc '*Ssa) "load " Typ ", " (val X) " " X)
                     (ssa (inc '*Ssa) "getelementptr " Typ ", " (val X) " " X ", i32 " Ofs)
                     (ssa (inc '*Ssa) "load " Typ ", " (val X) " %" (dec *Ssa)) )
                  (def (pack "%" *Ssa) Typ) ) )
            (T (quit "Bad type" (val X))) ) ) )
   (llvm~val) )

(asm ()
   ((X)
      (let Typ (pointee (val X))
         (ssa (inc '*Ssa) "load volatile " Typ ", " (val X) " " X)
         (def (pack "%" *Ssa) Typ) ) )
   (llvm~volatile) )

(asm ()
   (Args
      (while Args
         (let (A (eval (++ Args) 1)  B (eval (++ Args) 1))
            (ifn (num? A)
               (store B A)
               (store (eval (++ Args) 1) B (dec A)) ) ) ) )
   (llvm~set) )

(asm ()
   ((X Y)
      (ifn (pre? "%" X)
         (xchg X Y)
         (ssa (inc '*Ssa) "inttoptr i64 " X " to i64*")
         (ssa (inc '*Ssa) "load " "i64, i64* %" (dec *Ssa))
         (ssa (inc '*Ssa) "inttoptr i64 " Y " to i64*")
         (ssa (inc '*Ssa) "load " "i64, i64* %" (dec *Ssa))
         (link (pack "store i64 %" *Ssa ", i64* %" (- *Ssa 3)))
         (link (pack "store i64 %" (- *Ssa 2) ", i64* %" (dec *Ssa)))
         (def (pack "%" (- *Ssa 2)) 'any) ) )
   (llvm~xchg) )

(asm ()
   ((X Y Z Flg)
      (link
         (pack
            "call void @llvm.memcpy.p0i8.p0i8.i64(i8* "
            (and Flg "align 8 ") X
            ", " 'i8* " " Y
            ", i64 " Z
            ", i1 0)" ) ) )
   (llvm~memcpy) )

(asm ()
   ((X Y Z Flg)
      (link
         (pack
            "call void @llvm.memset.p0i8.i64(i8* "
            (and Flg "align 8 ") X
            ", " 'i8 " " Y
            ", i64 " Z
            ", i1 0)" ) ) )
   (llvm~memset) )

(asm ()
   (Lst
      (use *Bind
         (let (X (++ Lst)  Safe *Safe)
            (prog1
               (if (pair X)
                  (recur ()
                     (let (Var (++ X)  Val (eval (++ X)))
                        (and (atom Val) (+bind Lst Var))
                        (bind Var
                           (set Var Val)
                           (if X (recurse) (run Lst)) ) ) )
                  (let Val (eval (++ Lst))
                     (and (atom Val) (+bind Lst X))
                     (bind X
                        (set X Val)
                        (run Lst) ) ) )
               (when (and @ *Safe (not Safe))
                  (drop *Safe)
                  (off *Safe) ) ) ) ) )
   (llvm~let) )

# Stack operations
(asm ()
   ((P)
      (if P
         (prog
            (link (pack "call void @llvm.stackrestore(i8* " P ")"))
            P )
         (ssa (inc '*Ssa) "call i8* @llvm.stacksave()")
         (def (pack "%" *Ssa) 'i8*) ) )
   (llvm~stack) )

(asm (@Typ @Ptr @Flg)
   ((N)
      (ssa (inc '*Ssa) "alloca " '@Typ ", "
         (if (num? N) 'i64 (val N))
         " " N
         (and @Flg ", align 8") )
      (def (pack "%" *Ssa) '@Ptr) )
   (llvm~b8 i8 i8*)
   (llvm~b8+ i8 i8* T)
   (llvm~b8* i8* i8**)
   (llvm~b32 i32 i32*)
   (llvm~b64 i64 i64*) )

(asm ()
   (@
      (let
         (Lst (rest)
            Typ
            (or
               (pick
                  '((X)
                     (cond
                        ((num? X) 'i64)
                        (X (val X)) ) )
                  Lst )
               'any ) )
         (ssa (inc '*Ssa) "alloca "
            (type Typ) ", i64 " (length Lst)
            (and (cdr Lst) ", align 16") )
         (when (== 'any Typ)
            (ssa (inc '*Ssa) "ptrtoint i64* %" (dec *Ssa) " to i64") )
         (let P (def (pack "%" *Ssa) (ptr Typ))
            (for (I . Y) Lst
               (when Y
                  (if (=1 I)
                     (store Y P)
                     (if (== 'any Typ)
                        (ssa (inc '*Ssa) "add i64 " P ", " (* 8 (dec I)))
                        (ssa (inc '*Ssa) "getelementptr "
                           (type Typ) ", " (val P) " " P ", i32 " (dec I) ) )
                     (store Y (def (pack "%" *Ssa) (val P))) ) ) )
            P ) ) )
   (llvm~push) )

# Flow
(asm ()
   ((Fun X Y)
      (ssa (inc '*Ssa) "and i64 " Fun ", -3")
      (ssa (inc '*Ssa) "inttoptr i64 %" (dec *Ssa) " to i64(i64,i64)*")
      (ssa (inc '*Ssa) "call i64 %" (dec *Ssa) "(i64 " X "," "i64 " Y ")")
      (def (pack "%" *Ssa) 'any) )
   (llvm~subr) )

(asm (@Val1 @Val2 @Lbl1 @Lbl2)
   (Prg
      (let (End (+lbl)  Var (box))
         (for Exe Prg
            (if (== Exe (last Prg))
               (when (set Var (evBool (car Prg)))
                  (phi End Var)
                  (br End) )
               (let (Flg (evBool (++ Prg))  Skip (+lbl))
                  (set Var @Val1)
                  (phi End Var)
                  (br Flg @Lbl1 @Lbl2)
                  (label Skip) ) ) )
         (label End) ) )
   (llvm~and NO YES Skip End)
   (llvm~or YES NO End Skip) )

(asm ()
   (Prg
      (prog1
         (setq llvm~@ (eval (++ Prg)))
         (run Prg) ) )
   (llvm~prog1) )

(asm ()
   (Prg
      (prog2
         (eval (++ Prg))
         (setq llvm~@ (eval (++ Prg)))
         (run Prg) ) )
   (llvm~prog2) )

(asm (@Lbl1 @Lbl2)
   (Prg
      (let (Flg (evBool (++ Prg))  Var (box)  Body (+lbl)  Skip (+lbl)  End (+lbl))
         (br Flg @Lbl1 @Lbl2)
         (label Body)
         (use llvm~@
            (when (set Var (eval (++ Prg)))
               (phi End Var)
               (br End) )
            (label Skip) )
         (use llvm~@
            (when (set Var (run Prg))
               (phi End Var)
               (br End) ) )
         (label End) ) )
   (llvm~if Body Skip)
   (llvm~ifn Skip Body) )

(asm (@Lbl1 @Lbl2)
   (Prg
      (let (Flg (evBool (++ Prg))  Body (+lbl)  End (+lbl))
         (br Flg @Lbl1 @Lbl2)
         (label Body)
         (use llvm~@
            (and (run Prg) (br End)) )
         (label End) )
      T )
   (llvm~when Body End)
   (llvm~unless End Body) )

(asm (@Flg @Lbl1 @Lbl2 @Lbl3 @Lbl4 @Lbl5 @Lbl6)
   (Lst
      (let (Var (box)  End (+lbl)  Flg)
         (for Prg Lst
            (if (== @Flg (car Prg))
               (use llvm~@
                  (when (set Var (run (cdr Prg)))
                     (phi End Var)
                     (br End) ) )
               (setq Flg (evBool (++ Prg)))
               (let Skip (+lbl)
                  (if Prg
                     (let Body (+lbl)
                        (br Flg @Lbl1 @Lbl2)
                        (label Body)
                        (use llvm~@
                           (when (set Var (run Prg))
                              (phi End Var)
                              (br End) ) ) )
                     (br Flg @Lbl3 @Lbl4) )
                  (label Skip) ) ) )
         (if (== @Flg (car (last Lst)))
            (label End)
            (set Var 0)
            (phi End Var)
            (br End)
            (label End)
            T ) ) )
   (llvm~cond T Body Skip End Skip Body End)
   (llvm~nond NIL Skip Body Skip End End Body) )

(asm ()
   (Lst
      (let
         (Var (box)
            True (+lbl)
            Flg (asoq T Lst)
            End (if Flg (+lbl) True)
            X (setq llvm~@ (eval (++ Lst))) )
         (link
            (pack
               "switch " (type (val X)) " " X
               ", label %$" (+phi True) " [" ) )
         (let Lbl
            (extract
               '((Prg)
                  (unless (=T (car Prg))
                     (let Y (eval (car Prg))
                        (prog1
                           (+lbl)
                           (link
                              (pack
                                 "  " (type (val X)) " " Y
                                 ", label %$" (+phi @) ) ) ) ) ) )
               Lst )
            (link "]")
            (for Prg Lst
               (label (if (=T (++ Prg)) True (++ Lbl)))
               (use llvm~@
                  (when (set Var (if Prg (run @) 0))
                     (and Flg (phi End Var))
                     (br End) ) ) ) )
         (label End) ) )
   (llvm~case) )

(asm ()
   (Prg
      (let (Flg (evBool (++ Prg))  False (+lbl))
         (default *Exit (cons (+lbl) (box)))
         (if Prg
            (let True (+lbl)
               (br Flg True False)
               (label True)
               (use llvm~@
                  (let? X (run Prg)
                     (when (cdr *Exit)
                        (set @ X)
                        (phi (car *Exit) @) )
                     (br (car *Exit)) ) ) )
            (when (cdr *Exit)
               (set @ 0)
               (phi (car *Exit) @) )
            (br Flg (car *Exit) False) )
         (label False) )
      T )
   (llvm~?) )

(asm (@Lbl1 @Lbl2)
   (Prg
      (let Beg (+lbl)
         (br Beg)
         (label Beg)
         (let (Flg (evBool (++ Prg))  Body (+lbl)  *Exit (cons (+lbl)))
            (br Flg @Lbl1 @Lbl2)
            (label Body)
            (use llvm~@
               (and (run Prg) (br Beg)) )
            (label (car *Exit)) ) )
      T )
   (llvm~while Body (car *Exit))
   (llvm~until (car *Exit) Body) )

(asm ()
   (Prg
      (let (Beg (+lbl)  *Exit)
         (br Beg)
         (label Beg)
         (and (run Prg) (br Beg))
         (cond
            (*Exit (label (car *Exit)))
            ((fish
                  '((X)
                     (and
                        (== 'llvm~goto (car (pair X)))
                        (not (memq (- (cadr X)) (made))) ) )
                  Prg )
               (label (+lbl)) ) ) ) )
   (llvm~loop) )

(asm ()
   ((Fun . @)
      (let
         (L (val Fun)
            F (func L)
            A
            (mapcar
               '((Typ) (pack Typ " " (next)))
               (cdr L) ) )
         (ssa (inc '*Ssa) "load " F ", " F "* " Fun)
         (let S
            (pack *Call " "
               (car L) " " (pack "%" *Ssa)
               "(" (glue ", " A) ")" )
            (if (== void (car L))
               (link S)
               (ssa (inc '*Ssa) S)
               (def (pack "%" *Ssa) (car L)) ) ) ) )
   (llvm~call) )

(asm ()
   ((Lbl . Prg)
      (br (- Lbl))
      (label (- Lbl))
      (run Prg) )
   (llvm~:) )

(asm ()
   ((Lbl) (br (- Lbl)) NIL)
   (llvm~goto) )

(asm ()
   ((X)
      (and *Safe (drop *Safe))
      (if (== void *Ret)
         (link "ret void")
         (link (pack "ret " *Ret " " X)) )
      NIL )
   (llvm~ret) )


### Composite ###
(symbols '(llvm cross pico))

(local) (link drop pop save save2 safe)

(cross~de link (P Top)
   (log)
   (pico~let *Log NIL
      (pico~when (pico~== 'i64* (pico~val P))
         (setq P (any P)) )
      (pico~when Top
         (default *Safe P) )
      (set 2 P (val $Link))
      (set $Link P) ) )

(cross~de drop (P . Prg)
   (log)
   (pico~let *Log NIL
      (pico~when (pico~== 'i64* (pico~val P))
         (setq P (any P)) )
      (pico~if Prg
         (prog1
            (pico~let *Log T
               (run pico~@) )
            (set $Link (cdr P)) )
         (set $Link (cdr P)) ) ) )

(cross~de pop (P)
   (log)
   (pico~let *Log NIL
      (prog1
         (val P)
         (set $Link (cdr P)) ) ) )

(cross~de save (X . Prg)
   (log)
   (pico~let (*Log NIL  Safe *Safe  P (push X (val $Link)))
      (default *Safe P)
      (set $Link P)
      (pico~if Prg
         (prog1
            (pico~let *Log T
               (run pico~@) )
            (pico~when pico~@
               (log "drop")
               (drop P)
               (setq *Safe Safe) ) )
         X ) ) )

(cross~de save2 (X Y . Prg)
   (log)
   (pico~let (*Log NIL  Safe *Safe  P (push X (val $Link)))
      (default *Safe P)
      (set $Link (push Y P))
      (pico~if Prg
         (prog1
            (pico~let *Log T
               (run pico~@) )
            (pico~when pico~@
               (log "drop")
               (drop P)
               (setq *Safe Safe) ) )
         Y ) ) )

(cross~de safe (V)
   (log)
   (pico~let *Log NIL
      (store V *Safe) ) )
pil21/src/main.l0000644000000000000000000016472114767173715010620 0ustar  # 21mar25 Software Lab. Alexander Burger

(symbols '(llvm))

(begin "base" NIL
   "vers.l" "defs.l" "glob.l" "dec.l" )

(local) (execAt runAt wrnl dbg)

(de execAt (Prg)
   (let At (save (val $At))
      (exec Prg)
      (set $At At) ) )

(de runAt (Prg)
   (let At (save (val $At))
      (prog1
         (run Prg)
         (set $At At) ) ) )

(de wrnl ()
   (write 1 ($ "\n") 1) )

(de dbg ((i64 . N) X)
   (let (Out (val $OutFile)  Put (val (i8** $Put)))
      (set
         $OutFile (val 3 (val $OutFiles))  # Stderr
         $Put (fun (void i8) _putStdout) )
      (outWord N)
      (when X
         (space)
         (print X) )
      (newline)
      (set (i8** $Put) Put  $OutFile Out) )
   X )


(local) (put get popInFiles popOutFiles popErrFiles
popCtlFiles)

(de void put (any any any))
(de any get (any any))
(de void popInFiles ())
(de void popOutFiles ())
(de void popErrFiles ())
(de void popCtlFiles ())

(local) (stop unwind)

# Stop coroutine
(de void stop ((i8* . Crt))
   (let Crt: (coroutine Crt)
      (when (symb? (Crt: tag))
         (put @ ZERO $Nil) )
      (Crt: tag 0)  # Set unused
      (Crt: lim (val $CrtFree))  # Link into free list
      (set $CrtFree Crt) ) )

# Unwind stack
(de void unwind ((i8* . Catch))
   (let (Ca (val $Catch)  Bnd (val $Bind))
      (while Ca
         (let Ca: (caFrame Ca)
            (while (and Bnd (<> Bnd (Ca: (env $Bind any))))
               (set (val 2 Bnd) (val Bnd))  # Restore values
               (setq Bnd (val 3 Bnd)) )
            (while
               (and
                  (val $CtlFrames)
                  (<> @ (Ca: (env $CtlFrames i8*))) )
               (popCtlFiles) )
            (while
               (and
                  (val $ErrFrames)
                  (<> @ (Ca: (env $ErrFrames i8*))) )
               (popErrFiles) )
            (until
               (or
                  (== (val $OutFrames) (val $Stdout))
                  (== (val $OutFrames) (Ca: (env $OutFrames i8*))) )
               (popOutFiles) )
            (until
               (or
                  (== (val $InFrames) (val $Stdin))
                  (== (val $InFrames) (Ca: (env $InFrames i8*))) )
               (popInFiles) )
            (let (Src (val $Current)  Dst (Ca: co))
               (unless Dst
                  (setq Dst (val $Coroutines)) )
               (unless (== Src Dst)
                  (stop Src)
                  (let Crt: (coroutine (set $Current Dst))
                     (set $StkLimit (+ (Crt: lim) 1024))
                     (set $At (Crt: at))
                     (Crt: at 0) ) ) )  # Running
            (getCaEnv (Ca:))
            (eval (Ca: fin))  # Evaluate 'finally' expression
            (set $Catch (Ca: link))
            (when (== Ca Catch)
               (ret) )
            (setq Ca (Ca: link)) ) )
      (while Bnd
         (set (val 2 Bnd) (val Bnd))  # Restore values
         (setq Bnd (val 3 Bnd)) )
      (set $Bind 0)
      (while (val $CtlFrames)
         (popCtlFiles) )
      (while (val $ErrFrames)
         (popErrFiles) )
      (until (== (val $OutFrames) (val $Stdout))
         (popOutFiles) )
      (until (== (val $InFrames) (val $Stdin))
         (popInFiles) )
      (let (Src (val $Current)  Dst (val $Coroutines))
         (unless (== Src Dst)
            (stop Src)
            (let Crt: (coroutine (set $Current Dst))
               (set $StkLimit (+ (Crt: lim) 1024))
               (getCrtEnv (Crt:))
               (set $At (Crt: at))
               (Crt: at 0) ) ) ) ) )  # Running

# Exit
(local) (giveup bye execErr)

(de NIL giveup ((i8* . Msg))
   (stderrMsg ($ "Give up: %s\n") Msg)
   (setCooked)
   (exit 1) )

(de NIL bye ((i32 . N))
   (unless (val $InBye)
      (set $InBye YES)
      (unwind null)
      (exec (val $Bye)) )
   (when (nil? (val $PPid))
      (flushAll) )
   (setCooked)
   (exit N) )

(de NIL execErr ((i8* . Cmd))
   (stderrMsg ($ "%s: Can't exec\n") Cmd)
   (exit 127) )

# Memory
(local) (alloc heapAlloc)

(de i8* alloc ((i8* . Ptr) (i64 . Siz))
   (unless (realloc Ptr Siz)   # Reallocate pointer
      (giveup ($ "No memory")) )
   @ )

(de void heapAlloc ()
   (let
      (H (any (alloc null (* 8 (inc HEAP))))
         P (ofs H HEAP)
         A (val $Avail) )
      (set P (val $Heaps)  $Heaps H)
      (loop
         (set (setq P (ofs P -2)) A)  # Link avail
         (? (== (setq A P) H)) )
      (set $Avail A) ) )

# Signals
(local) (sig sigTerm sighandler)

(de void sig ((i32 . N))
   (if (val $TtyPid)
      (kill @ N)
      (set $Signal (+ (val $Signal) 1))
      (let P (ofs $Signal (gSignal N))
         (set P (+ (val P) 1)) ) ) )

(de void sigTerm ((i32 . N))
   (if (val $TtyPid)
      (kill @ N)
      (set $Signal (+ (val $Signal) 1))
      (let P (ofs $Signal (gSignal (val SIGTERM Sig)))
         (set P (+ (val P) 1)) ) ) )

(de void sighandler (Exe)
   (unless (val $Protect)
      (set $Protect 1)
      (let P T
         (loop
            (cond
               ((val (setq P (ofs $Signal SIGIO)))
                  (set P (dec @))
                  (set $Signal (dec (val $Signal)))
                  (execAt (val $Sigio)) )
               ((val (setq P (ofs $Signal SIGUSR1)))
                  (set P (dec @))
                  (set $Signal (dec (val $Signal)))
                  (execAt (val $Sig1)) )
               ((val (setq P (ofs $Signal SIGUSR2)))
                  (set P (dec @))
                  (set $Signal (dec (val $Signal)))
                  (execAt (val $Sig2)) )
               ((val (setq P (ofs $Signal SIGALRM)))
                  (set P (dec @))
                  (set $Signal (dec (val $Signal)))
                  (execAt (val $Alarm)) )
               ((val (setq P (ofs $Signal SIGHUP)))
                  (set P (dec @))
                  (set $Signal (dec (val $Signal)))
                  (execAt (val $Hup)) )
               ((val (setq P (ofs $Signal SIGINT)))
                  (set P (dec @))
                  (set $Signal (dec (val $Signal)))
                  (unless (val $PRepl)  # Not child of REPL process?
                     (wrnl)
                     (rlSigBeg)
                     (brkLoad (if Exe @ $Nil))
                     (rlSigEnd) ) )
               ((val (setq P (ofs $Signal SIGWINCH)))
                  (set P (dec @))
                  (set $Signal (dec (val $Signal)))
                  (execAt (val $Winch)) )
               ((val (setq P (ofs $Signal SIGTSTP)))
                  (set P (dec @))
                  (set $Signal (dec (val $Signal)))
                  (rlSigBeg)
                  (execAt (val $TStp1))  # Run 'TStp1'
                  (stopTerm)  # Stop
                  (iSignal (val SIGTSTP Sig) (fun sig))  # Set signal again
                  (execAt (val $TStp2))  # Run 'TStp2'
                  (rlSigEnd) )
               ((val (setq P (ofs $Signal SIGTERM)))
                  (if (nil? (run (val $Term)))
                     (let
                        (Cld (val $Child)  # Iterate children
                            any
(de _Tty (Exe)
   (pushOutFile
      (b8+ (ioFrame T))
      (val 3 (val $OutFiles))  #  # Stderr
      0 )
   (prog2
      (rlHide)
      (run (cdr Exe))
      (rlShow)
      (popOutFiles) ) )

# (prompt 'any . prg) -> any
(de _Prompt (Exe)
   (let (X (cdr Exe)  Nm (xName (evSym X)))
      (prog2
         (set $LinePrmt (set $ContPrmt (bufString Nm (b8 (bufSize Nm)))))
         (run (cdr X))
         (set $LinePrmt (set $ContPrmt null)) ) ) )

# (raw ['flg]) -> flg
(de _Raw (Exe)
   (let X (cdr Exe)
      (cond
         ((atom X)
            (if (val Termio) $T $Nil) )
         ((nil? (eval (car X))) (setCooked) @)
         (T (setRaw) @) ) ) )

# (alarm 'cnt . prg) -> cnt
(de _Alarm (Exe)
   (let X (cdr Exe)
      (prog1
         (cnt (i64 (alarm (i32 (evCnt Exe X)))))
         (set $Alarm (cdr X)) ) ) )

# (sigio 'cnt . prg) -> cnt
(de _Sigio (Exe)
   (let (X (cdr Exe)  Fd (evCnt Exe X))
      (set $Sigio (cdr X))
      (fcntlSetOwn (i32 Fd) (i32 (int (val $Pid))))
      (cnt Fd) ) )

# (kids) -> lst
(de _Kids (Exe)
   (let
      (X $Nil
         Cld (val $Child)  # Iterate children
          any
(de _Protect (Exe)
   (let X (cdr Exe)
      (prog2
         (set $Protect (+ (val $Protect) 1))
         (run X)
         (set $Protect (- (val $Protect) 1)) ) ) )

# (heap 'flg) -> cnt
(de _Heap (Exe)
   (if (nil? (eval (cadr Exe)))
      (let (N 1  P (val $Heaps))
         (while (setq P (val (ofs P HEAP)))
            (inc 'N) )
         (cnt N) )
      (let (N 0  P (val $Avail))
         (while P
            (inc 'N)
            (setq P (car P)) )
         (cnt (shr N (- 20 4))) ) ) )  # Divide by CELLS (1M/16)

# (stack ['cnt ['cnt]]) -> cnt | (.. (any . cnt) . cnt)
(de _Stack (Exe)
   (let (X (cdr Exe)  Crt (val $Coroutines))
      (if (or (atom X) (and Crt ((coroutine Crt) nxt)))
         (let R (cnt (shr (val $StkSize) 10))
            (while Crt
               (let Crt: (coroutine Crt)
                  (when (Crt: tag)  # In use
                     (let P (Crt: lim)
                        (while (== 7 (val P))
                           (inc 'P) )
                        (setq R
                           (cons2
                              (Crt: tag)
                              (cnt (shr (- P (Crt: lim)) 10))
                              R ) ) ) )
                  (setq Crt (Crt: nxt)) ) )
            R )
         (let N (evCnt Exe X)
            (set $StkSize (shl N 10))
            (when (pair (shift X))
               (set $StkSizeT (shl (evCnt Exe X) 10)) )
            (when Crt
               (let (Siz (val $StkSizeT)  Stk (stack))
                  (memset
                     ((coroutine Crt) lim (stack (ofs Stk (- Siz))))
                     7 (- Siz 256) T )
                  (stack Stk) ) )
            (cnt N) ) ) ) )

# Date and time
(local) (tmDate tmTime)

(de tmDate ((i64 . Y) (i64 . M) (i64 . D))
   (if
      (and
         (gt0 Y)
         (gt0 M)
         (>= 12 M)
         (gt0 D)
         (or
            (>= (i64 (val (ofs $Month M))) D)
            (and
               (== D 29)
               (== M 2)
               (=0 (% Y 4))
               (or (% Y 100) (=0 (% Y 400))) ) ) )
      (let N (/ (+ (* Y 12) M -3) 12)
         (cnt
            (-
               (+
                  (/
                     (+ (* Y 4404) (* M 367) -1094)
                     12 )
                  (/ N 4)
                  (/ N 400)
                  D )
               (* 2 N)
               (/ N 100) ) ) )
      $Nil ) )

(de tmTime ((i64 . H) (i64 . M) (i64 . S))
   (if
      (and
         (ge0 H)
         (ge0 M)
         (> 60 M)
         (ge0 S)
         (> 60 S) )
      (cnt (+ (* H 3600) (* M 60) S))
      $Nil ) )

# (date ['T]) -> dat
# (date 'dat) -> (y m d)
# (date 'y 'm 'd) -> dat | NIL
# (date '(y m d)) -> dat | NIL
(de _Date (Exe)
   (let X (cdr Exe)
      (cond
         ((atom X)
            (let N (getDate)
               (tmDate
                  (& N (hex "FFFF"))
                  (& (shr N 16) (hex "FF"))
                  (& (shr N 24) (hex "FF")) ) ) )
         ((t? (eval (car X)))
            (let N (getGmDate)
               (tmDate
                  (& N (hex "FFFF"))
                  (& (shr N 16) (hex "FF"))
                  (& (shr N 24) (hex "FF")) ) ) )
         ((nil? @) @)
         ((pair @)
            (let L @
               (tmDate
                  (xCnt Exe (++ L))
                  (xCnt Exe (++ L))
                  (xCnt Exe (car L)) ) ) )
         (T
            (let N @
               (cond
                  ((pair (shift X))
                     (tmDate
                        (xCnt Exe N)
                        (evCnt Exe X)
                        (evCnt Exe (cdr X)) ) )
                  ((lt0 (setq N (xCnt Exe N))) $Nil)
                  (T
                     (let Y (/ (- (* N 100) 20) 3652425)
                        (setq
                           N (+ N (- Y (/ Y 4)))
                           Y (/ (- (* N 100) 20) 36525)
                           N (* (- N (/ (* Y 36525) 100)) 10) )
                        (let
                           (M (/ (- N 5) 306)
                              D (/ (+ N (* M -306) 5) 10) )
                           (if (> 10 M)
                              (inc 'M 3)
                              (inc 'Y)
                              (dec 'M 9) )
                           (cons (cnt Y)
                              (cons (cnt M)
                                 (cons (cnt D) $Nil) ) ) ) ) ) ) ) ) ) ) )

# (time ['T]) -> tim
# (time 'tim) -> (h m s)
# (time 'h 'm ['s]) -> tim | NIL
# (time '(h m [s])) -> tim | NIL
(de _Time (Exe)
   (let X (cdr Exe)
      (cond
         ((atom X) (cnt (getTime)))
         ((t? (eval (car X)))
            (if (lt0 (getGmTime)) $Nil (cnt @)) )
         ((nil? @) @)
         ((pair @)
            (let L @
               (tmTime
                  (xCnt Exe (++ L))
                  (xCnt Exe (++ L))
                  (if (pair L)
                     (xCnt Exe (car L))
                     0 ) ) ) )
         (T
            (let N @
               (cond
                  ((pair (shift X))
                     (tmTime
                        (xCnt Exe N)
                        (evCnt Exe X)
                        (if (pair (shift X)) (evCnt Exe X) 0) ) )
                  ((lt0 (setq N (xCnt Exe N))) $Nil)
                  (T
                     (cons (cnt (/ N 3600))
                        (cons (cnt (% (/ N 60) 60))
                           (cons (cnt (% N 60)) $Nil) ) ) ) ) ) ) ) ) )

# (usec ['flg]) -> num
(de _Usec (Exe)
   (cnt
      (if (nil? (eval (cadr Exe)))
         (- (getUsec YES) (val $USec))
         (getUsec NO) ) ) )

# (rt cnt . prg) -> any
(de _Rt (Exe)
   (let (X (cdr Exe)  Rt (val $Rt)  U (getUsec YES))
      (prog1
         (run (cdr X))
         (let D (- (- (getUsec YES) U) (- (val $Rt) Rt))
            (set
               $Rt (+ D (val $Rt))
               X (+ (car X) (shl D 4)) ) ) ) ) )

# Try to load dynamic library
(local) sharedLib

(de i1 sharedLib (Sym)
   (let
      (Nm (xName Sym)
         S (bufString Nm (b8 (bufSize Nm)))
         P (strchr S (char ":")) )
      (and
         P
         (<> P S)
         (val 2 P)
         (let N (val $PilLen)
            (set P 0)
            (let (Len (strlen S)  Q (b8 (+ N Len (+ 4 3 1))))
               (if (strchr S (char "/"))
                  (strcpy Q S)
                  (when N
                     (memcpy Q (val $PilHome) N) )
                  (strcpy (ofs Q N) ($ "lib/"))
                  (strcpy (ofs Q (+ N 4)) S)
                  (setq Len (+ Len N 4)) )
               (strcpy (ofs Q Len) ($ ".so"))
               (and
                  (dlOpen Q)
                  (dlsym @ (inc P))
                  (prog
                     (set Sym (| (i64 @) 2))
                     YES ) ) ) ) ) ) )

(load "gc.l" "big.l" "sym.l")

(local) dirString

(de i8* dirString (Nm (i8* . P))
   (let S (pathString Nm P)
      (if (val P) P ($ ".")) ) )

# Comparisons
(local) (equalBig equal compare)

(inline equalBig (X Y)
   (loop
      (? (<> (val (dig X)) (val (dig Y))) NO)
      (?
         (==
            (setq X (val (big X)))
            (setq Y (val (big Y))) )
         YES )
      (? (cnt? X) NO)
      (? (cnt? Y) NO) ) )

(de i1 equal (X Y)
   (cond
      ((== X Y) YES)
      ((cnt? X) NO)
      ((big? X)
         (if (cnt? Y)
            NO
            (when (sign? X)
               (unless (sign? Y)
                  (ret NO) )
               (setq X (pos X)  Y (pos Y)) )
            (equalBig X Y) ) )
      ((sym? X)
         (cond
            ((num? Y) NO)
            ((pair Y) NO)
            ((sym? (val (tail X))) NO)
            ((== ZERO (setq X (name @))) NO)
            ((sym? (val (tail Y))) NO)
            ((== ZERO (setq Y (name @))) NO)
            ((== X Y) YES)
            ((cnt? X) NO)
            ((cnt? Y) NO)
            (T (equalBig X Y)) ) )
      ((atom Y) NO)
      (T
         (stkChk 0)
         (let (A X  B Y)
            (prog1
               (loop
                  (? (not (equal (car X) (& (car Y) -2)))
                     NO)
                  (? (atom (cdr X))
                     (equal (cdr X) (cdr Y)) )
                  (? (atom (cdr Y)) NO)
                  (set X (| (val X) 1))  # Mark
                  (shift X)
                  (shift Y)
                  (? (& (val X) 1)  # Detected circularity
                     (prog1
                        (loop
                           (? (== A X)
                              (if (== B Y)
                                 (loop
                                    (shift A)
                                    (? (== (shift B) Y) (== A X))
                                    (? (== A X) YES) )
                                 NO ) )
                           (? (== B Y) NO)
                           (set A (& (val A) -2))  # Unmark
                           (shift A)
                           (shift B) )
                        (set A (& (val A) -2))  # Unmark
                        (shift A) ) ) )
               (until (== A X)
                  (set A (& (val A) -2))  # Unmark
                  (shift A) ) ) ) ) ) )

(de i64 compare (X Y)
   (cond
      ((== X Y) 0)
      ((nil? X) -1)
      ((t? X) +1)
      ((num? X)
         (cond
            ((num? Y) (cmpNum X Y))
            ((nil? Y) +1)
            (T -1) ) )
      ((sym? X)
         (cond
            ((or (num? Y) (nil? Y)) +1)
            ((or (pair Y) (t? Y)) -1)
            (T
               (let
                  (NmX (name (& (val (tail X)) -9))
                     NmY (name (& (val (tail Y)) -9)) )
                  (cond
                     ((== ZERO NmX)
                        (nond
                           ((== ZERO NmY) -1)
                           ((> X Y) -1)
                           (NIL +1) ) )
                     ((== ZERO NmY) +1)
                     (T
                        (loop
                           (let
                              (A
                                 (if (cnt? NmX)
                                    (prog1
                                       (shr (shl (name NmX) 2) 6)  # Clear status bits
                                       (setq NmX 0) )
                                    (prog1
                                       (val (dig NmX))  # Next digit
                                       (setq NmX (val (big NmX))) ) )
                                 B
                                 (if (cnt? NmY)
                                    (prog1
                                       (shr (shl (name NmY) 2) 6)  # Clear status bits
                                       (setq NmY 0) )
                                    (prog1
                                       (val (dig NmY))  # Next digit
                                       (setq NmY (val (big NmY))) ) ) )
                              (loop
                                 (when (- (& A 255) (& B 255))
                                    (ret (if (gt0 @) +1 -1)) )
                                 (? (=0 (setq A (shr A 8)))
                                    (when (setq B (shr B 8))
                                       (ret -1) )
                                    (unless NmX
                                       (ret (if NmY -1 0)) )
                                    (unless NmY
                                       (ret +1) ) )
                                 (unless (setq B (shr B 8))
                                    (ret +1) ) ) ) ) ) ) ) ) ) )
      ((atom Y) (if (t? Y) -1 +1))
      (T
         (stkChk 0)
         (let (A X  B Y)
            (loop
               (? (compare (car X) (car Y)) @)
               (? (atom (shift X))
                  (compare X (cdr Y)) )
               (? (atom (shift Y))
                  (if (t? Y) -1 +1) )
               (? (== X A)
                  (if (== Y B) 0 -1) )
               (? (== Y B) 1)
               (sigChk 0) ) ) ) ) )

# Evaluation
(local) (undefined evExpr evList)

(de NIL undefined (Fun Exe)
   (err Exe Fun ($ "Undefined") null) )

# Apply EXPR to CDR of list
(de evExpr (Exe Lst)
   (stkChk Exe)
   (let
      (X (cdr Lst)  # Arguments
         Y (car Exe)  # Parameters
         P (set $Bind (push (val $At) $At (val $Bind) Lst)) )  # [[@] @ LINK Expr]
      (while (pair Y)
         (let (V (eval (++ X))  Z (++ Y))  # Evaluate next argument
            (if (atom Z)
               (set $Bind
                  (setq P (push V (needChkVar Exe Z) P)) )  # [val sym LINK]
               (loop
                  (set $Bind
                     (setq P
                        (push  # [val sym LINK]
                           (if (pair V) (++ V) $Nil)
                           (needChkVar Exe (++ Z))
                           P ) ) )
                  (? (atom Z)) )
               (unless (nil? Z)
                  (set $Bind
                     (setq P (push V (needChkVar Exe Z) P)) ) ) ) ) )  # [val sym LINK]
      (prog1
         (if (== Y $At)  # VarArgs
            (if (pair X)
               (let (L (push NIL (eval (car X)) NIL)  Q L)
                  (link (ofs L 1))
                  (while (pair (shift X))
                     (setq L
                        (set L (push NIL (eval (car X)) NIL)) )
                     (link (ofs L 1)) )
                  (let Next (val $Next)
                     (set L $Nil  $Next Q)
                     (loop
                        (let Sym (val 2 P)
                           (xchg Sym P)  # Exchange symbol value
                           (? (== $At Sym))
                           (setq P (val 3 P)) ) )
                     (prog1
                        (run (cdr Exe))  # Run body
                        (set $Next Next)
                        (drop (ofs Q 1)) ) ) )
               (let Next (val $Next)
                  (set $Next $Nil)
                  (loop
                     (let Sym (val 2 P)
                        (xchg Sym P)  # Exchange symbol value
                        (? (== $At Sym))
                        (setq P (val 3 P)) ) )
                  (prog1
                     (run (cdr Exe))  # Run body
                     (set $Next Next) ) ) )
            (unless (nil? Y)
               (needChkVar Exe Y)
               (set
                  $Bind (push (val Y) Y P)  # Last parameter
                  Y X ) )  # Set to unevaluated argument(s)
            (loop
               (let Sym (val 2 P)
                  (xchg Sym P)  # Exchange symbol value
                  (? (== $At Sym))
                  (setq P (val 3 P)) ) )
            (run (cdr Exe)) )  # Run body
         (setq P (val $Bind))
         (loop
            (let Sym (val 2 P)
               (set Sym (val P))  # Restore values
               (? (== $At Sym))
               (setq P (val 3 P)) ) )
         (set $Bind (val 3 P)) ) ) )

(de evList (Exe)
   (let Fun (car Exe)
      (cond
         ((num? Fun) Exe)  # Number: Return list
         ((sym? Fun)  # Symbol: Find function
            (loop
               (sigChk Exe)
               (let V (val Fun)  # Get VAL
                  (? (num? V) (subr V Exe Fun))
                  (? (pair V) (evExpr V Exe))
                  (? (== V (val V))
                     (if (sharedLib Fun)
                        (subr (val Fun) Exe Fun)
                        (undefined Fun Exe) ) )
                  (setq Fun V) ) ) )
         (T  # List: Evaluate
            (stkChk Exe)
            (let F (save (evList Fun))  # Save computed function
               (loop
                  (sigChk Exe)
                  (? (num? F) (subr F Exe Fun))
                  (? (pair F) (evExpr F Exe))
                  (let V (val F)
                     (? (== V (val V))
                        (if (sharedLib F)
                           (subr (val F) Exe F)
                           (undefined F Exe) ) )
                     (setq Fun F  F V) ) ) ) ) ) ) )

(load "io.l" "db.l" "apply.l" "flow.l" "subr.l")

# (quit ['any ['any]])
(de _Quit (Exe)
   (let
      (X (cdr Exe)
         Nm (xName (evSym X))
         Msg (bufString Nm (b8 (bufSize Nm))) )
      (err 0
         (if (atom (shift X))
            0
            (eval (car X)) )
         ($ "%s")
         Msg ) ) )

# (sys 'any ['any]) -> sym
(de _Sys (Exe)
   (let
      (X (cdr Exe)
         Nm (xName (evSym X))
         S (bufString Nm (b8 (bufSize Nm))) )
      (if (atom (shift X))
         (mkStr (getenv S))
         (let (Y (evSym X)  Nm2 (xName Y))
            (if
               (setenv S
                  (bufString Nm2 (b8 (bufSize Nm2)))
                  1 )
               $Nil
               Y ) ) ) ) )

# (pwd) -> sym
(de _Pwd (Exe)
   (let P (getcwd null 0)
      (if P
         (prog1 (mkStr P) (free P))
         $Nil ) ) )

# (cd 'any) -> sym
(de _Cd (Exe)
   (let
      (Nm (xName (evSym (cdr Exe)))
         P (getcwd null 0) )
      (if P
         (prog1
            (if (lt0 (chdir (dirString Nm (b8 (pathSize Nm)))))
               $Nil
               (mkStr P) )
            (free P) )
         $Nil ) ) )

# (ctty 'pid) -> pid
# (ctty 'any) -> any | NIL
(de _Ctty (Exe)
   (let X (eval (cadr Exe))
      (cond
         ((cnt? X)
            (set $TtyPid (i32 (int @)))
            X )
         ((nil? X)
            (let Pty (b32 2)  # Master + Slave
               (when (lt0 (openpty Pty (ofs Pty 1) null null null))
                  (err Exe 0 ($ "Can't open PTY: %s") (strErrno)) )
               (cond
                  ((lt0 (fork)) (forkErr Exe))
                  ((=0 @)  # Master in child
                     (close (val 2 Pty))
                     (let (Fd (val Pty)  Poll (b64 2)  Buf (b8 BUFSIZ))
                        (loop
                           (pollIn 0 Poll)
                           (pollIn Fd (ofs Poll 1))
                           (if (lt0 (poll Poll 2 -1))
                              (? (<> (gErrno) EINTR))
                              (when (readyIn Poll)
                                 (let N (read 0 Buf BUFSIZ)
                                    (? (le0 N))
                                    (write Fd Buf N) ) )
                              (when (readyIn (ofs Poll 1))
                                 (let N (read Fd Buf BUFSIZ)
                                    (? (le0 N))
                                    (write 1 Buf N) ) ) ) )
                        (exit 0) ) ) )
               # Slave in parent
               (close (val Pty))
               (login_tty (val 2 Pty)) )
            (signal (val SIGINT Sig) (val SigIgn))
            ((inFile (val (val $InFiles))) tty YES)
            ((outFile (val 2 (val $OutFiles))) tty YES)
            ((outFile (val 3 (val $OutFiles))) tty YES)
            (set Tio (=0 (tcgetattr 0 OrgTermio)))  # Init terminal I/O
            $T )
         (T
            (let Nm (xName (xSym X))
               (if (reopenTty (bufString Nm (b8 (bufSize Nm))))
                  (let
                     (In: (inFile (val (val $InFiles)))  # Stdin
                        Out: (outFile (val 2 (val $OutFiles))) )  # Stdout
                     (In: chr 0)
                     (In: ix (In: cnt 0))
                     (In: tty YES)
                     (set Tio (=0 (tcgetattr 0 OrgTermio)))  # Save terminal I/O
                     (Out: ix 0)
                     (Out: tty YES)
                     ((outFile (val 3 (val $OutFiles))) tty YES)  # Stderr
                     X )
                  $Nil ) ) ) ) ) )

# (cmd ['any]) -> sym
(de _Cmd (Exe)
   (if (nil? (evSym (cdr Exe)))
      (mkStr (val $AV0))
      (bufString (xName @) (val $AV0))
      @ ) )

# (dir ['any] ['flg]) -> lst
(de _Dir (Exe)
   (let X (cdr Exe)
      (if
         (getDir
            (let Nm (xName (evSym X))
               (dirString Nm (b8 (pathSize Nm))) ) )
         (let (P @  F (eval (car (shift X))))
            (when (nil? F)
               (while (== (val P) (char "."))
                  (unless (setq P (getDir null))
                     (ret $Nil) ) ) )
            (let (Y (cons (mkStr P) $Nil)  R (save Y))
               (while (setq P (getDir null))
                  (unless (and (nil? F) (== (val P) (char ".")))
                     (setq Y (set 2 Y (cons (mkStr P) $Nil))) ) )
               R ) )
         $Nil ) ) )

# (info 'any ['flg]) -> (cnt|flg dat . tim)
(de _Info (Exe)
   (let
      (X (cdr Exe)
         Nm (xName (set $At2 (evSym X)))
         Size (b64 1) )
      (if
         (lt0
            (fileInfo
               (nil? (eval (car (shift X))))
               (== ZERO @)
               (dirString Nm (b8 (pathSize Nm)))
               Size ) )
         $Nil
         (let N @
            (cons
               (case (& N 3)
                  (1 $T)
                  (2 $Nil)
                  (T (box64 (val Size))) )
               (cons
                  (tmDate
                     (& (setq N (shr N 2)) (hex "FFFF"))
                     (& (setq N (shr N 16)) (hex "FF"))
                     (& (setq N (shr N 8)) (hex "FF")) )
                  (cnt (shr N 8)) ) ) ) ) ) )

# (file) -> (sym1 sym2 . num) | NIL
(de _File (Exe)
   (let In: (inFile (val $InFile))
      (ifn (and (In:) (In: name))
         $Nil
         (let
            (N (cnt (i64 (In: src)))
               S (In: name)
               P (strrchr S (char "/")) )
            (if P
               (let X (save (mkStrE S (inc 'P)))
                  (cons X (cons (mkStr P) N)) )
               (cons $Nil (cons (mkStr S) N)) ) ) ) ) )

# (argv [var ..] [. sym]) -> lst|sym
(de _Argv (Exe)
   (let (X (cdr Exe)  A (val $AV)  P (val A))
      (when
         (and
            P
            (== (val P) (char "-"))
            (=0 (val 2 P)) )  # Single-dash argument
         (inc 'A) )  # Skip "-"
      (if (nil? X)  # No args
         (if (setq P (val A))
            (let (Y (cons (mkStr P) $Nil)  R (save Y))
               (while (setq P (val (inc 'A)))
                  (setq Y (set 2 Y (cons (mkStr P) $Nil))) )
               R )
            $Nil )
         (loop
            (? (atom X)
               (set (needChkVar Exe X)
                  (if (setq P (val A))
                     (let (Y (cons (mkStr P) $Nil)  R Y)
                        (save R
                           (while (setq P (val (inc 'A)))
                              (setq Y (set 2 Y (cons (mkStr P) $Nil))) ) )
                        R )
                     $Nil ) ) )
            (let Y
               (ifn (setq P (val A))
                  $Nil
                  (inc 'A)
                  (mkStr P) )
               (set (needChkVar Exe (++ X)) Y)
               (? (nil? X) Y) ) ) ) ) )

# (opt) -> sym
(de _Opt (Exe)
   (let (A (val $AV)  P (val A))
      (if
         (or
            (=0 P)
            (and
               (== (val P) (char "-"))
               (=0 (val 2 P)) ) )
         $Nil
         (set $AV (inc A))
         (mkStr P) ) ) )

# (errno) -> cnt
(de _Errno (Exe)
   (cnt (i64 (nErrno))) )

# Native calls
(local) (fetchChar natBuf natErr natRetFloat natRetDouble natRetBuf ffi)

(de i32 fetchChar ((i8** . Ptr))
   (let (P (val Ptr)  C (i32 (val P)))
      (prog2
         (inc 'P)
         (cond
            ((>= 127 C) C)  # Single byte
            ((== C (hex "FF")) (i32 TOP))  # Infinite
            (T
               (|
                  (shl
                     (ifn (& C (hex "20"))
                        (& C (hex "1F"))
                        (|
                           (shl
                              (ifn (& C (hex "10"))
                                 (& C (hex "0F"))
                                 (|
                                    (shl (& C (hex "7")) 6)
                                    (&
                                       (i32 (prog1 (val P) (inc 'P)))
                                       (hex "3F") ) ) )
                              6 )
                           (&
                              (i32 (prog1 (val P) (inc 'P)))
                              (hex "3F") ) ) )
                     6 )
                  (&
                     (i32 (prog1 (val P) (inc 'P)))
                     (hex "3F") ) ) ) )
         (set Ptr P) ) ) )

(de i64 natBuf (Val (i8* . Ptr))
   (if (atom Val)  # Byte or unsigned
      (if (sign? Val)  # Unsigned 32 bit
         (let P (i32* Ptr)
            (set P (i32 (int Val)))
            4 )
         (set Ptr (i8 (int Val)))
         1 )
      (let X (++ Val)  # 'num', 'sym' or [-]1.0
         (if (cnt? Val)  # 'cnt' or 'lst'
            (let Siz (int Val)
               (cond
                  ((num? X)  # (num . cnt)
                     (let N
                        (if (cnt? X)
                           (int @)
                           (val (dig @)) )
                        (when (sign? X)
                           (setq N (- N)) )
                        (case Siz
                           (1 (set Ptr (i8 N)))
                           (2 (set (i16* Ptr) (i16 N)))
                           (4 (set (i32* Ptr) (i32 N)))
                           (T (set (i64* Ptr) N)) ) ) )
                  ((nil? X) (set Ptr (i8 0)))
                  ((sym? X)  # (sym . cnt)
                     (setq X (name (val (tail X))))
                     (bufString X Ptr) ) )
               Siz )
            (let (N 0  Scl (int X))
               (if (sign? X)  # ([-]1.0 . lst)
                  (while (pair Val)
                     (bufFloat (++ Val) Scl Ptr)
                     (inc 'N 4)
                     (setq Ptr (ofs Ptr 4)) )
                  (while (pair Val)
                     (bufDouble (++ Val) Scl Ptr)
                     (inc 'N 8)
                     (setq Ptr (ofs Ptr 8)) ) )
               N ) ) ) ) )

(de NIL natErr (Spec)
   (err 0 Spec ($ "Bad result spec") null) )

(de natRetFloat ((i32 . Val) (i64 . Scl))
   (let R (boxFloat Val Scl)
      (unless R
         (let X (setq R (save (boxNum (val Fdigit))))
            (until (boxFlt)
               (setq X (set (big X) (boxNum (val Fdigit)))) )
            (set (big X) @) ) )
      (if (val Fsign) (neg R) R) ) )

(de natRetDouble ((i64 . Val) (i64 . Scl))
   (let R (boxDouble Val Scl)
      (unless R
         (let X (setq R (save (boxNum (val Fdigit))))
            (until (boxDbl)
               (setq X (set (big X) (boxNum (val Fdigit)))) )
            (set (big X) @) ) )
      (if (val Fsign) (neg R) R) ) )

(de natRetBuf (Spec (i8** . Ptr))
   (cond
      ((t? Spec)  # 'T' Direct Lisp value
         (let P (i64* (val Ptr))
            (set Ptr (i8* (inc P)))
            (val P) ) )
      ((== Spec $N)  # 'N' Number (signed 64 bit)
         (let P (i64* (val Ptr))
            (set Ptr (i8* (inc P)))
            (box (val P)) ) )
      ((== Spec $P)  # 'P' Pointer (unsigned 64 bit)
         (let P (i64* (val Ptr))
            (set Ptr (i8* (inc P)))
            (box64 (val P)) ) )
      ((== Spec $I)  # 'I' Integer (signed 32 bit)
         (if
            (ge0
               (let P (i32* (val Ptr))
                  (set Ptr (i8* (inc P)))
                  (val P) ) )
            (cnt (i64 @))
            (sign (cnt (i64 (- @)))) ) )
      ((== Spec $C)  # 'C' Character (UTF-8, 1-4 bytes)
         (if (fetchChar Ptr) (mkChar @) $Nil) )
      ((== Spec $W)  # 'W' Word (signed 16 bit)
         (if
            (ge0
               (let P (i16* (val Ptr))
                  (set Ptr (i8* (inc P)))
                  (val P) ) )
            (cnt (i64 @))
            (sign (cnt (i64 (- @)))) ) )
      ((== Spec $B)  # 'B' Byte (unsigned 8 bit)
         (let P (val Ptr)
            (set Ptr (inc P))
            (cnt (i64 (val P))) ) )
      ((== Spec $S)  # 'S' String (UTF-8)
         (let P (i8** (val Ptr))
            (set Ptr (i8* (inc P)))
            (mkStr (val P)) ) )
      ((cnt? Spec)  # [+-]1.0 Scaled fixpoint number
         (if (sign? Spec)
            (natRetFloat
               (let P (i32* (val Ptr))
                  (set Ptr (i8* (inc P)))
                  (val P) )
               (int Spec) )
            (natRetDouble
               (let P (i64* (val Ptr))
                  (set Ptr (i8* (inc P)))
                  (val P) )
               (int Spec) ) ) )
      ((pair Spec)  # Arrary or structure
         (let (S (++ Spec)  R (natRetBuf S Ptr))
            (unless (and (nil? R) (== S $C))
               (let X (setq R (save (cons R $Nil)))
                  (loop
                     (? (cnt? Spec)  # (sym . cnt)
                        (let C (int Spec)
                           (while (dec 'C)
                              (let Y (natRetBuf S Ptr)
                                 (? (and (nil? Y) (== S $C)))
                                 (setq X (set 2 X (cons Y $Nil))) ) ) ) )
                     (? (atom Spec))
                     (let Y (natRetBuf (setq S (++ Spec)) Ptr)
                        (? (and (nil? Y) (== S $C)))
                        (setq X (set 2 X (cons Y $Nil))) ) ) ) )
            R ) )
      (T (natErr Spec)) ) )

(de ffi (Exe (i8* . Lib) Fun Args)
   (let
      (Spec (car Args)
         Val
         (ffiCall
            (cond
               ((cnt? Fun) (i8* (int Fun)))
               ((big? Fun) (i8* (val (dig Fun))))
               ((pair Fun) (argErr Exe Fun))
               (T
                  (let Nm (xName Fun)
                     (unless (ffiPrep Lib (bufString Nm (b8 (bufSize Nm))) Args)
                        (err Exe 0 ($ "Bad ffi") null) )
                     (set Fun (box64 (i64 @)))
                     @ ) ) )
            (cdr Args) ) )
      (cond
         ((nil? Spec) $Nil)
         ((== Spec $T) Val)  # 'T' Direct Lisp value
         ((== Spec $N) (box Val))  # 'N' Number (signed 64 bit)
         ((== Spec $P) (box64 Val))  # 'P' Pointer (unsigned 64 bit)
         ((== Spec $I)  # 'I' Integer (signed 32 bit)
            (if (ge0 (i32 Val))
               (cnt (i64 @))
               (sign (cnt (i64 (- @)))) ) )
         ((== Spec $C)  # 'C' Character (UTF-8, 1-4 bytes)
            (if (i32 Val) (mkChar @) $Nil) )
         ((== Spec $W)  # 'W' Word (signed 16 bit)
            (if (ge0 (i16 Val))
               (cnt (i64 @))
               (sign (cnt (i64 (- @)))) ) )
         ((== Spec $B)  # 'B' Byte (unsigned 8 bit)
            (cnt (i64 (i8 Val))) )
         ((== Spec $S)  # 'S' String (UTF-8)
            (mkStr (i8* Val)) )
         ((cnt? Spec)  # [+-]1.0 Scaled fixpoint number
            (if (sign? Spec)
               (natRetFloat (i32 Val) (int Spec))
               (natRetDouble Val (int Spec)) ) )
         ((and (pair Spec) Val)  # Arrary or structure
            (let
               (Ptr (i8** (push Val))
                  S (++ Spec)
                  R (natRetBuf S Ptr) )
               (unless (and (nil? R) (== S $C))
                  (let X (setq R (save (cons R $Nil)))
                     (loop
                        (? (cnt? Spec)  # (sym . cnt)
                           (let C (int Spec)
                              (while (dec 'C)
                                 (let Y (natRetBuf S Ptr)
                                    (? (and (nil? Y) (== S $C)))
                                    (setq X (set 2 X (cons Y $Nil))) ) ) ) )
                        (? (atom Spec))
                        (let Y (natRetBuf (setq S (++ Spec)) Ptr)
                           (? (and (nil? Y) (== S $C)))
                           (setq X (set 2 X (cons Y $Nil))) ) ) ) )
               R ) )
         (T (natErr Spec)) ) ) )

# (%@ 'cnt2|sym2 'any 'any ..) -> any
(de _Nat (Exe)
   (let
      (X (cdr Exe)
         Fun (save (eval (++ X)))  # Eval function 'cnt2|sym2'
         Args (save (cons (eval (++ X)) $Nil))
         L Args )  # [ret args]
      (while (pair X)
         (let Z (push (save (eval (++ X))) $Nil)  # [argN next]
            (set 2 L Z)
            (setq L Z) ) )
      (tailcall (ffi Exe null Fun Args)) ) )

# (native 'cnt1|sym1 'cnt2|sym2 'any 'any ..) -> any
(de _Native (Exe)
   (let
      (X (cdr Exe)
         Y (eval (++ X))  # Eval library 'cnt1|sym1'
         Lib
         (cond
            ((cnt? Y) (i8* (int Y)))
            ((big? Y) (i8* (val (dig Y))))
            ((pair Y) (argErr Exe Y))
            ((== (xName Y) (| 2 (>> -4 (char "@"))))
               (set Y ZERO)
               null )  # RTLD_DEFAULT
            (T
               (unless (dlOpen (pathString @ (b8 (pathSize @))))
                  (err Exe Y ($ "[DLL] %s") (dlerror)) )
               (set Y (box64 (i64 @)))
               @ ) )
         Fun (save (eval (++ X)))  # Eval function 'cnt2|sym2'
         Args (save (cons (eval (++ X)) $Nil))
         L Args )  # [ret args]
      (while (pair X)
         (let Z (push (save (eval (++ X))) $Nil)  # [argN next]
            (set 2 L Z)
            (setq L Z) ) )
      (tailcall (ffi Exe Lib Fun Args)) ) )

# (struct 'num 'any 'any ..) -> any
(de _Struct (Exe)
   (let
      (X (cdr Exe)
         N  # Native value (pointer or scalar)
         (if (cnt? (needNum Exe (eval (++ X))))
            (int @)
            (val (dig @)) )
         P (i8* N)
         Y (save (eval (car X))) )  # Result specification
      (while (pair (shift X))
         (setq P
            (ofs P (natBuf (eval (car X)) P)) ) )
      (cond
         ((nil? Y) @)
         ((== Y $S) (mkStr (i8* N)))
         (T (natRetBuf Y (i8** (push N)))) ) ) )

# Lisp callbacks
(local) cbl

(de cbl (Fun A B C D E)
   (let Exe (push NIL NIL ZERO Fun)  # [car cdr name fun]
      (set Exe (ofs Exe 3))
      (let P (set 2 Exe (push NIL NIL ZERO (box A)))
         (set P (ofs P 3))
         (setq P
            (set 2 P (push NIL NIL ZERO (box B))) )
         (set P (ofs P 3))
         (setq P
            (set 2 P (push NIL NIL ZERO (box C))) )
         (set P (ofs P 3))
         (setq P
            (set 2 P (push NIL NIL ZERO (box D))) )
         (set P (ofs P 3))
         (setq P
            (set 2 P (push NIL $Nil ZERO (box E))) )
         (set P (ofs P 3)) )
      (xCnt 0 (evList Exe)) ) )

(de _Cb1 (A B C D E)
   (cbl (val 2 $Lisp) A B C D E) )

(de _Cb2 (A B C D E)
   (cbl (val 4 $Lisp) A B C D E) )

(de _Cb3 (A B C D E)
   (cbl (val 6 $Lisp) A B C D E) )

(de _Cb4 (A B C D E)
   (cbl (val 8 $Lisp) A B C D E) )

(de _Cb5 (A B C D E)
   (cbl (val 10 $Lisp) A B C D E) )

(de _Cb6 (A B C D E)
   (cbl (val 12 $Lisp) A B C D E) )

(de _Cb7 (A B C D E)
   (cbl (val 14 $Lisp) A B C D E) )

(de _Cb8 (A B C D E)
   (cbl (val 16 $Lisp) A B C D E) )

(de _Cb9 (A B C D E)
   (cbl (val 18 $Lisp) A B C D E) )

(de _Cb10 (A B C D E)
   (cbl (val 20 $Lisp) A B C D E) )

(de _Cb11 (A B C D E)
   (cbl (val 22 $Lisp) A B C D E) )

(de _Cb12 (A B C D E)
   (cbl (val 24 $Lisp) A B C D E) )

(de _Cb13 (A B C D E)
   (cbl (val 26 $Lisp) A B C D E) )

(de _Cb14 (A B C D E)
   (cbl (val 28 $Lisp) A B C D E) )

(de _Cb15 (A B C D E)
   (cbl (val 30 $Lisp) A B C D E) )

(de _Cb16 (A B C D E)
   (cbl (val 32 $Lisp) A B C D E) )

(de _Cb17 (A B C D E)
   (cbl (val 34 $Lisp) A B C D E) )

(de _Cb18 (A B C D E)
   (cbl (val 36 $Lisp) A B C D E) )

(de _Cb19 (A B C D E)
   (cbl (val 38 $Lisp) A B C D E) )

(de _Cb20 (A B C D E)
   (cbl (val 40 $Lisp) A B C D E) )

(de _Cb21 (A B C D E)
   (cbl (val 42 $Lisp) A B C D E) )

(de _Cb22 (A B C D E)
   (cbl (val 44 $Lisp) A B C D E) )

(de _Cb23 (A B C D E)
   (cbl (val 46 $Lisp) A B C D E) )

(de _Cb24 (A B C D E)
   (cbl (val 48 $Lisp) A B C D E) )

# (lisp 'sym ['fun]) -> num
(de _Lisp (Exe)
   (let (X (cdr Exe)  Y (evSym X))
      (let (P $Lisp  Q (i8** (cbFuns)))
         (loop  # Search for tag 'sym'
            (? (== Y (val P)))  # Found
            (setq P (ofs P 2)  Q (ofs Q 1))
            (? (> P $LispEnd)  # Not found
               (setq P $Lisp  Q (i8** (cbFuns)))
               (until (nil? (val 2 P))  # Search for empty slot
                  (setq P (ofs P 2)  Q (ofs Q 1))
                  (when (> P $LispEnd)
                     (err Exe 0 ($ "Too many callbacks") null) ) )
               (set P Y) ) )
         (set 2 P (eval (cadr X)))  # Eval 'fun'
         (box64 (i64 (val Q))) ) ) )

# (args) -> flg
(de _Args (Exe)
   (if (pair (val $Next)) $T $Nil) )

# (next) -> any
(de _Next (Exe)
   (let X (val $Next)
      (set $Next (car X))
      (cdr X) ) )

# (arg 'cnt) -> any
(de _Arg (Exe)
   (if (le0 (evCnt Exe (cdr Exe)))
      $Nil
      (let (N @  X (val $Next))
         (while (gt0 (dec 'N))
            (setq X (car X)) )
         (cdr X) ) ) )

# (rest) -> lst
(de _Rest (Exe)
   (let X (val $Next)
      (if (atom X)
         X
         (let (Y (cons (cdr X) $Nil)  R (save Y))
            (while (pair (setq X (car X)))
               (setq Y (set 2 Y (cons (cdr X) $Nil))) )
            R ) ) ) )

# (adr 'var) -> num
# (adr 'num) -> var
(de _Adr (Exe)
   (cond
      ((cnt? (eval (cadr Exe))) (int @))  # Make 'var'
      ((big? @) (val (dig @)))
      (T (box64 @)) ) )  # Make 'num'

# (byte 'num ['cnt]) -> cnt
(de _Byte (Exe)
   (let
      (X (cdr Exe)
         P
         (i8*
            (if (cnt? (needNum Exe (eval (++ X))))
               (int @)
               (val (dig @)) ) ) )
      (if (atom X)
         (cnt (i64 (val P)))
         (let
            (Y (needCnt Exe (eval (car X)))
               N (int @) )
            (set P
               (i8 (if (sign? Y) (- N) N)) )
            Y ) ) ) )

# (env ['lst] | ['sym 'val] ..) -> lst
(de _Env (Exe)
   (let (X (cdr Exe)  R (save $Nil))
      (if (atom X)
         (let Bnd (val $Bind)
            (while Bnd
               (let (S (val 2 Bnd)  Y R)
                  (loop
                     (? (atom Y)
                        (setq R
                           (safe (cons (cons S (val S)) R)) ) )  # (sym . val)
                     (? (== S (caar Y)))
                     (shift Y) ) )
               (setq Bnd (val 3 Bnd)) ) )
         (let Y (link (push $Nil NIL))
            (loop
               (let Z (set Y (eval (++ X)))  # Eval 'lst' or 'sym'
                  (nond
                     ((atom Z)
                        (loop
                           (let V (++ Z)
                              (setq R
                                 (safe
                                    (cons
                                       (if (pair V)
                                          (cons (car V) (cdr V))
                                          (cons V (val V)) )
                                       R ) ) ) )
                           (? (atom Z)) ) )
                     ((nil? Z)
                        (setq R
                           (safe (cons (cons Z (eval (++ X))) R)) ) ) ) )
                  (? (atom X)) ) ) )
      R ) )

# (trail ['flg]) -> lst
(de _Trail (Exe)
   (let
      (F (not (nil? (eval (cadr Exe))))
         Bnd (val $Bind)
         R $Nil )
      (while Bnd
         (let S (val 2 Bnd)
            (cond
               ((== S $At)
                  (when (val 4 Bnd)
                     (setq R (cons @ R)) ) )  # Expr
               (F
                  (setq R (cons S (cons (val S) R)))
                  (set S (val Bnd)) ) ) )
         (setq Bnd (val 3 Bnd)) )
      (let X R
         (until (atom X)
            (when (atom (++ X))
               (set @ (++ X)) ) ) )
      R ) )

# (up [cnt] sym ['val]) -> any
(de _Up (Exe)
   (let
      (X (cdr Exe)
         Y (car X)
         N 1
         Bnd (val $Bind) )
      (when (num? Y)
         (setq N (int Y)  Y (car (shift X))) )
      (if (nil? Y)
         (if N
            (loop
               (? (=0 Bnd) $Nil)
               (?
                  (and
                     (== $At (val 2 Bnd))
                     (=0 (dec 'N)) )
                  (if (val 4 Bnd) @ $Nil) )
               (setq Bnd (val 3 Bnd)) )
            $Nil )
         (let Z Y
            (when N
               (loop
                  (? (=0 Bnd))
                  (?
                     (and
                        (== Y (val 2 Bnd))
                        (prog
                           (setq Z Bnd)
                           (=0 (dec 'N)) ) ) )
                  (setq Bnd (val 3 Bnd)) ) )
            (if (atom (shift X))
               (val Z)
               (set Z (eval (car X))) ) ) ) ) )

# (history ['lst]) -> lst
(de _History (Exe)
   (let X (cdr Exe)
      (if (atom X)
         (let P (history_list)
            (if (and P (val P))
               (let
                  (Y (cons (mkStr (val (val P))) $Nil)
                     R (save Y)
                     I 0 )
                  (while (val (ofs P (inc 'I)))
                     (setq Y
                        (set 2 Y (cons (mkStr (val @)) $Nil)) ) )
                  R )
               $Nil ) )
         (let (Y (needLst Exe (eval (car X)))  Z Y)
            (clear_history)
            (while (pair Z)
               (let (Nm (xName (xSym (++ Z)))  Stk (stack))
                  (add_history (bufString Nm (b8 (bufSize Nm))) )
                  (stack Stk) ) )
            Y ) ) ) )

# (version ['flg]) -> lst
(de _Version (Exe)
   (when (nil? (eval (cadr Exe)))
      (outWord (int (val $Y)))
      (call $Put (char "."))
      (outWord (int (val $M)))
      (call $Put (char "."))
      (outWord (int (val $D)))
      (newline) )
   (cons (val $Y)
      (cons (val $M)
         (cons (val $D) $Nil) ) ) )

# Main entry point
(local) (main sigChld)

(de i32 main ((i32 . Ac) (i8** . Av))
   (set
      $AV0 (val Av)  # Save command
      $AV (setq Av (ofs Av 1))  # and argument vector
      $StkLimit (ulimStk) )
   # Check debug mode
   (let P (ofs Av (- Ac 2))
      (unless (strcmp (val P) ($ "+"))
         (set $Dbg $T  P null) ) )
   # Locate home directory
   (let P (val Av)  # First argument
      (when (and P (<> (val P) (char "-")))
         (let Q (strrchr P (char "/"))
            (unless
               (or
                  (=0 Q)
                  (and
                     (== Q (+ P 1))
                     (== (val P) (char ".")) ) )
               (let (N (+ (- Q P) 1)  H (malloc (+ N 1)))
                  (set $PilHome H  $PilLen N)
                  (memcpy H P N)
                  (set (ofs H N) 0) ) ) ) ) )
   (when (getenv ($ "HOME"))
      (set $UsrHome @  $UsrLen (strlen @)) )
   (heapAlloc)
   (let P $Nil  # Init internal symbols
      (loop
         (let Nm (val (tail P))
            (when (num? Nm)
               (intern P 0 @ (cdr $Pico) $Nil NO)
               (? (== P $LastSym))
               (when (big? Nm)  # Max 15 chars
                  (setq P (ofs P 2)) ) ) )
         (setq P (ofs P 2)) ) )
   # Initialize globals
   (set
      $OS (mkStr TgOS)
      $CPU (mkStr TgCPU)
      $Pid (cnt (i64 (getpid)))
      (tail $Db1) DB1  # Name of external root symbol '{1}'
      $Extern (cons $Db1 $Nil) )  # External symbol tree root node
   (pushOutFile (b8+ (ioFrame T)) (initOutFile 2) 0)  # Standard error
   (pushOutFile
      (set $Stdout (b8+ (ioFrame T)))
      (initOutFile 1)  # Standard output
      0 )
   (pushInFile
      (set $Stdin (b8+ (ioFrame T)))
      (initInFile 0 null)  # Standard input
      0 )
   (set Tio (=0 (tcgetattr 0 OrgTermio)))  # Save terminal I/O
   (sigUnblock 0)  # Set all signals to unblocked
   (iSignal (val SIGHUP Sig) (fun sig))
   (iSignal (val SIGUSR1 Sig) (fun sig))
   (iSignal (val SIGUSR2 Sig) (fun sig))
   (iSignal (val SIGALRM Sig) (fun sig))
   (iSignal (val SIGTERM Sig) (fun sig))
   (iSignal (val SIGWINCH Sig) (fun sig))
   (iSignal (val SIGIO Sig) (fun sig))
   (when (== (signal (val SIGTSTP Sig) (val SigIgn)) (val SigDfl))
      (iSignal (val SIGTSTP Sig) (fun sig)) )
   (iSignal (val SIGINT Sig) (fun sigTerm))
   (signal (val SIGCHLD Sig) (fun sigChld))
   (signal (val SIGPIPE Sig) (val SigIgn))
   (signal (val SIGTTIN Sig) (val SigIgn))
   (signal (val SIGTTOU Sig) (val SigIgn))
   (initReadline)
   (set $USec (getUsec YES))
   (unless (setjmp QuitRst)
      (loadAll 0) )  # Load arguments
   (unless (val $Repl)
      (set $Repl YES)
      (iSignal (val SIGINT Sig) (fun sig)) )
   (save -ZERO)
   (loop
      (let X (safe (stdRead ($ ": ")))
         (cond
            ((lt0 (val $Chr)) (bye 0))
            ((=0 (val $Chr))
               (unless (nil? X)
                  (stdEval X) ) )
            (T (eval X)) ) ) ) )

(end "base.map" "lib.c")
pil21/src/vers.l0000644000000000000000000000015214771741462010631 0ustar  # 29mar25 Software Lab. Alexander Burger

(symbols '(llvm))

(local) *Version

(pico~de *Version 25 3 29)
pil21/src/defs.l0000644000000000000000000000343413734400164010566 0ustar  # 28sep20 Software Lab. Alexander Burger

(symbols '(llvm))

# Constants
(local) (HEAP CELLS STACK TOP BUFSIZ DB1)

(equ
   HEAP (*/ 1024 1024 8)      # Heap size (number of pointers)
   CELLS (/ HEAP 2)           # Number of cells in a heap (65536)
   STACK (* 64 1024)          # Default coroutine stack size (64 kB)
   TOP (hex "110000")         # Character top
   BUFSIZ 4096                # I/O buffer size
   DB1 (hex "1A")             # Name of '{1}'
   292MY (dec (** 2 63)) )    # 292 million years

# PLIO Tokens
(local) (NIX BEG DOT END NUMBER INTERN TRANSIENT EXTERN)

(equ
   NIX 0        # NIL
   BEG 1        # Begin list
   DOT 2        # Dotted pair
   END 3        # End list
   NUMBER 0     # Number
   INTERN 1     # Internal symbol
   TRANSIENT 2  # Transient symbol
   EXTERN 3 )   # External symbol

# DB-I/O
(local) (BLK BLKSIZE BLKMASK BLKTAG)

(equ
   BLK 6        # Block address size
   BLKSIZE 64   # DB block unit size
   BLKMASK -64  # Block address mask
   BLKTAG 63 )  # Block tag mask

## Sync src/lib.c 'gSignal' and src/glob.l '$Signal'
(local) (SIGHUP SIGINT SIGUSR1 SIGUSR2 SIGPIPE SIGALRM SIGTERM SIGCHLD SIGCONT
SIGSTOP SIGTSTP SIGTTIN SIGTTOU SIGWINCH SIGIO)

(equ
   SIGHUP    1
   SIGINT    2
   SIGUSR1   3
   SIGUSR2   4
   SIGPIPE   5
   SIGALRM   6
   SIGTERM   7
   SIGCHLD   8
   SIGCONT   9
   SIGSTOP  10
   SIGTSTP  11
   SIGTTIN  12
   SIGTTOU  13
   SIGWINCH 14
   SIGIO    15 )

## Sync src/lib.c 'gErrno'
(local) (ENOENT EINTR EBADF EAGAIN EACCES EPIPE ECONNRESET)

(equ
   ENOENT     1      # No such file or directory
   EINTR      2      # Interrupted system call
   EBADF      3      # Bad file number
   EAGAIN     4      # Try again
   EACCES     5      # Permission denied
   EPIPE      6      # Broken pipe
   ECONNRESET 7 )    # Connection reset by peer
pil21/src/glob.l0000644000000000000000000004560614766774107010620 0ustar  # 20mar25 Software Lab. Alexander Burger

(symbols '(llvm))

(var $AV0 i8* null)                    # Command name
(var $AV i8** null)                    # Command line argument vector
(var $PilHome i8* null)                # Picolisp home directory
(var $PilLen i64 0)                    # $PilHome length
(var $UsrHome i8* null)                # User home directory
(var $UsrLen i64 0)                    # $UsrHome length
(var $Heaps 0)                         # Heap list
(var $Avail 0)                         # Avail list
(var $Extern 0)                        # External symbol tree
(var $ExtCnt i64 1)                    # External symbol count
(var $ExtSkip i64 0)                   # External tree skip
(var $Coroutines i8* null)             # Coroutines
(var $Current i8* null)                # Current coroutine
(var $CrtLast i8* null)                # Last Coroutine
(var $CrtFree i8* null)                # Coroutine free list link
(var $StkLimit i8* null)               # Stack limit: StackN-Size+1024
(var $StkSizeT i64 (* 4 STACK))        # Coroutine main stack segment size
(var $StkSize i64 STACK)               # Coroutine stack segment size
(var $Stdin i8* null)                  # Stdin frame
(var $Stdout i8* null)                 # Stdout frame
(var $LinePtr i8* null)                # Console line pointer
(var $LineBuf i8* null)                # Console line buffer
(var $LinePrmt i8* null)               # Console line prompt
(var $ReplPrmt i8* null)               # REPL console prompt
(var $ContPrmt i8* null)               # REPL continue prompt
(var $Ret 0)                           # Secondary return value
(var $TtyPid i32 0)                    # Terminal process ID
(var $InFDs i32 0)                     # Number of input files
(var $InFiles i8** null)               # Input files
(var $OutFiles i8** null)              # Output files
(var $IoCnt i32 0)                     # 'output' count
(var $IoIx i64 0)                      # 'output' index
(var $IoChar i64 0)                    # 'input' and 'output' char
(var $PutBin (void i8) null)           # Binary output function
(var $GetBin (i32) null)               # Binary input function
(var $OutFDs i32 0)                    # Number of ourput files
(var $Nfds i32 0)                      # Number of poll entries
(var $Poll i64* null)                  # Poll entries
(var $SeedL i64 0)                     # Random seed low
(var $SeedH i64 0)                     # Random seed high
(var $USec i64 0)                      # Startup microseconds
(var $Rt i64 0)                        # Real/Runtime [microseconds]
(var $Child i8* null)                  # Child array
(var $Children i32 0)                  # Number of children
(var $Slot i32 0)                      # Child index
(var $Spkr i32 0)                      # RPC loadspeaker
(var $Mic i32 0)                       # RPC microphone
(array $SpMiPipe i32 0 0)              # Speaker/microphone pipe
(var $Talking i32 0)                   # Active child
(var $Hear i32 0)                      # RPC listener
(var $Tell i32 0)                      # RPC broadcaster
(var $TellBuf i8* null)                # RPC buffer
(var $Ptr i8* null)                    # Byte buffer pointer
(var $End i8* null)                    # Buffer end pointer
(var $BufX i8* null)                   # Exchange buffer
(var $PtrX i8* null)                   # Exchange buffer pointer
(var $EndX i8* null)                   # Exchange end pointer
(var $ExtN i32 0)                      # External symbol offset
(var $Extn i32 0)
(var $StrP i64* null)                  # String status
(var $GcCount i64 CELLS)               # Collector count

# Database
(var $DbFiles i8* null)                # DB files
(var $DbFile i8* null)                 # DB file
(var $DBs i32 0)                       # Number of DB files
(var $MaxBlkSize i32 0)                # Maximum block size
(var $DbBlock i8* null)                # Block buffer
(var $BlkIndex i64 0)                  # Block index
(var $BlkLink i64 0)                   # Next block
(var $BlkPtr i8* null)                 # Block byte buffer pointer
(var $BlkEnd i8* null)                 # Block buffer end pointer
(var $DbJnl i8* null)                  # Journal file
(var $DbLog i8* null)                  # Transaction log file

# Signals
(array $Signal i32  # Sync src/lib.c 'gSignal'
   0    # Count
   0    # SIGHUP
   0    # SIGINT
   0    # SIGUSR1
   0    # SIGUSR2
   0    # SIGPIPE
   0    # SIGALRM
   0    # SIGTERM
   0    # SIGCHLD
   0    # SIGCONT
   0    # SIGSTOP
   0    # SIGTSTP
   0    # SIGTTIN
   0    # SIGTTOU
   0    # SIGWINCH
   0 )  # SIGIO

# Symbol Table
(symTab
   ($Nil "NIL" $Nil)          # NIL symbol
   (NIL $Nil 0)               # CDR of NIL as empty list
   ($Tilde "~" $Tilde)        # Tilde symbol
   ($PicoT $Nil $Nil 0)       # Pico trees
   ($Pico $Tilde $PicoT 0)    # Initial namespace
   ($pico "pico" $Pico)
   ($Pico1 $pico $Nil 0)
   ($PrivT $Nil $Nil 0)       # Private trees
   ($Priv $Tilde $PrivT 0)    # Private namespace
   ($priv "priv" $Priv)
   ($OS "*OS" 0)              # Operating system
   ($CPU "*CPU" 0)            # Processor
   ($Pid "*Pid" 0)            # Process ID
   ($PPid "*PPid" $Nil)       # Parent Process ID
   ($DB "*DB" $Nil)           # Database root
   ($Meth "meth" __Meth)      # Method template
   ($Quote "quote" _Quote)    # 'quote' function
   ($T "T" $T)  ### Sync src/pico.h 'T' (17*2+1) ###
   ($N "N" $Nil)
   ($C "C" $Nil)
   ($S "S" $Nil)
   ($B "B" $Nil)
   ($I "I" $Nil)
   ($P "P" $Nil)
   ($W "W" $Nil)
   ($Db1 0 $Nil)              # Database root symbol '{1}'
   ($Solo "*Solo" ZERO)
   ($At "@" $Nil)
   ($At2 "@@" $Nil)
   ($At3 "@@@" $Nil)
   ($This "This" $Nil)
   ($Prompt "*Prompt" $Nil)
   ($Zap "*Zap" $Nil)
   ($Ext "*Ext" $Nil)
   ($Scl "*Scl" ZERO)
   ($Rule "*Rule" $Nil)
   ($Class "*Class" $Nil)
   ($Run "*Run" $Nil)
   ($Hup "*Hup" $Nil)
   ($Sig1 "*Sig1" $Nil)
   ($Sig2 "*Sig2" $Nil)
   ($Winch "*Winch" $Nil)
   ($TStp1 "*TStp1" $Nil)
   ($TStp2 "*TStp2" $Nil)
   ($Term "*Term" $Nil)
   ($Up "\^" $Nil)
   ($Err "*Err" $Nil)
   ($Msg "*Msg" $Nil)
   ($Uni "*Uni" $Nil)
   ($Fork "*Fork" $Nil)
   ($Bye "*Bye" $Nil)
   ($Dbg "*Dbg" $Nil)
   ($Complete "complete" $Nil)
   ($Remark "remark" $Nil)
   # Garbage collection
   (NIL "gc" _Gc)
   # Arithmetics
   (NIL "format" _Format)
   (NIL "+" _Add)
   (NIL "-" _Sub)
   (NIL "inc" _Inc)
   (NIL "dec" _Dec)
   (NIL "*" _Mul)
   (NIL "*/" _MulDiv)
   (NIL "/" _Div)
   ($rem "%" _Rem)
   (NIL ">>" _Shr)
   (NIL "rev" _Rev)
   (NIL "lt0" _Lt0)
   (NIL "le0" _Le0)
   (NIL "ge0" _Ge0)
   (NIL "gt0" _Gt0)
   (NIL "abs" _Abs)
   (NIL "bit?"_BitQ)
   (NIL "&" _BitAnd)
   (NIL "|" _BitOr)
   (NIL "x|" _BitXor)
   (NIL "sqrt" _Sqrt)
   (NIL "seed" _Seed)
   (NIL "hash" _Hash)
   (NIL "rand" _Rand)
   # Symbol functions
   (NIL "name" _Name)
   (NIL "nsp" _Nsp)
   (NIL "sp?" _SpQ)
   (NIL "pat?" _PatQ)
   (NIL "fun?" _FunQ)
   (NIL "getd" _Getd)
   (NIL "all" _All)
   (NIL "symbols" _Symbols)
   (NIL "intern" _Intern)
   (NIL "====" _Hide)
   (NIL "box?" _BoxQ)
   (NIL "str?" _StrQ)
   (NIL "zap" _Zap)
   (NIL "chop" _Chop)
   (NIL "pack" _Pack)
   (NIL "glue" _Glue)
   (NIL "text" _Text)
   (NIL "pre?" _PreQ)
   (NIL "sub?" _SubQ)
   (NIL "val" _Val)
   (NIL "set" _Set)
   (NIL "setq" _Setq)
   (NIL "swap" _Swap)
   (NIL "xchg" _Xchg)
   (NIL "on" _On)
   (NIL "off" _Off)
   (NIL "onOff" _OnOff)
   (NIL "zero" _Zero)
   (NIL "one" _One)
   (NIL "default" _Default)
   (NIL "push" _Push)
   (NIL "push1" _Push1)
   (NIL "push1q" _Push1q)
   (NIL "pop" _Pop)
   (NIL "++" _Popq)
   (NIL "shift" _Shift)
   (NIL "cut" _Cut)
   (NIL "del" _Del)
   (NIL "queue" _Queue)
   (NIL "fifo" _Fifo)
   (NIL "rid" _Rid)
   (NIL "enum" _Enum)
   (NIL "enum?" _EnumQ)
   (NIL "idx" _Idx)
   (NIL "lup" _Lup)
   (NIL "put" _Put)
   (NIL "get" _Get)
   (NIL "prop" _Prop)
   (NIL ";" _Semicol)
   (NIL "=:" _SetCol)
   (NIL ":" _Col)
   (NIL "::" _PropCol)
   (NIL "putl" _Putl)
   (NIL "getl" _Getl)
   (NIL "wipe" _Wipe)
   (NIL "meta" _Meta)
   (NIL "low?" _LowQ)
   (NIL "upp?" _UppQ)
   (NIL "lowc" _Lowc)
   (NIL "uppc" _Uppc)
   (NIL "fold" _Fold)
   # Input/Output
   (NIL "path" _Path)
   (NIL "wait" _Wait)
   (NIL "sync" _Sync)
   (NIL "hear" _Hear)
   (NIL "tell" _Tell)
   (NIL "poll" _Poll)
   (NIL "read" _Read)
   (NIL "key" _Key)
   (NIL "peek" _Peek)
   (NIL "char" _Char)
   (NIL "skip" _Skip)
   (NIL "eol" _Eol)
   (NIL "eof" _Eof)
   (NIL "from" _From)
   (NIL "till" _Till)
   (NIL "line" _Line)
   (NIL "in" _In)
   (NIL "out" _Out)
   (NIL "err" _Err)
   (NIL "ctl" _Ctl)
   (NIL "input" _Input)
   (NIL "output" _Output)
   (NIL "fd" _Fd)
   (NIL "pipe" _Pipe)
   (NIL "open" _Open)
   (NIL "close" _Close)
   (NIL "echo" _Echo)
   (NIL "prin" _Prin)
   (NIL "prinl" _Prinl)
   (NIL "space" _Space)
   (NIL "print" _Print)
   (NIL "printsp" _Printsp)
   (NIL "println" _Println)
   (NIL "flush" _Flush)
   (NIL "rewind" _Rewind)
   (NIL "ext" _Ext)
   (NIL "plio" _Plio)
   (NIL "rd" _Rd)
   (NIL "pr" _Pr)
   (NIL "wr" _Wr)
   (NIL "any" _Any)
   (NIL "sym" _Sym)
   (NIL "str" _Str)
   (NIL "load" _Load)
   # Database
   (NIL "ext?" _ExtQ)
   (NIL "rollback" _Rollback)
   (NIL "extern" _Extern)
   (NIL "pool" _Pool)
   (NIL "pool2" _Pool2)
   (NIL "journal" _Journal)
   (NIL "id" _Id)
   (NIL "blk" _Blk)
   (NIL "seq" _Seq)
   (NIL "lieu" _Lieu)
   (NIL "lock" _Lock)
   (NIL "touch" _Touch)
   (NIL "commit" _Commit)
   (NIL "mark" _Mark)
   (NIL "free" _Free)
   (NIL "dbck" _Dbck)
   # Mapping
   (NIL "apply" _Apply)
   (NIL "pass" _Pass)
   (NIL "fun" _Fun)
   (NIL "maps" _Maps)
   (NIL "map" _Map)
   (NIL "mapc" _Mapc)
   (NIL "maplist" _Maplist)
   (NIL "mapcar" _Mapcar)
   (NIL "mapcon" _Mapcon)
   (NIL "mapcan" _Mapcan)
   (NIL "filter" _Filter)
   (NIL "extract" _Extract)
   (NIL "seek" _Seek)
   (NIL "find" _Find)
   (NIL "pick" _Pick)
   (NIL "fully" _Fully)
   (NIL "cnt" _Cnt)
   (NIL "sum" _Sum)
   (NIL "maxi" _Maxi)
   (NIL "mini" _Mini)
   (NIL "fish" _Fish)
   (NIL "by" _By)
   # Control flow
   (NIL "as" _As)
   (NIL "lit" _Lit)
   (NIL "eval" _Eval)
   (NIL "run" _Run)
   (NIL "def" _Def)
   (NIL "de" _De)
   (NIL "dm" _Dm)
   (NIL "box" _Box)
   (NIL "new" _New)
   (NIL "type" _Type)
   (NIL "isa" _Isa)
   (NIL "method" _Method)
   (NIL "send" _Send)
   (NIL "try" _Try)
   (NIL "super" _Super)
   (NIL "extra" _Extra)
   (NIL "and" _And)
   (NIL "or" _Or)
   (NIL "nand" _Nand)
   (NIL "nor" _Nor)
   (NIL "xor" _Xor)
   (NIL "bool" _Bool)
   (NIL "not" _Not)
   (NIL "nil" _Nil)
   (NIL "t" _T)
   (NIL "prog" _Prog)
   (NIL "prog1" _Prog1)
   (NIL "prog2" _Prog2)
   (NIL "if" _If)
   (NIL "ifn" _Ifn)
   (NIL "if2" _If2)
   (NIL "if@@" _IfAt2)
   (NIL "when" _When)
   (NIL "unless" _Unless)
   (NIL "cond" _Cond)
   (NIL "nond" _Nond)
   (NIL "case" _Case)
   (NIL "casq" _Casq)
   (NIL "state" _State)
   (NIL "while" _While)
   (NIL "until" _Until)
   (NIL "at" _At)
   (NIL "do" _Do)
   (NIL "loop" _Loop)
   (NIL "for" _For)
   (NIL "with" _With)
   (NIL "bind" _Bind)
   (NIL "job" _Job)
   (NIL "let" _Let)
   (NIL "let?" _LetQ)
   (NIL "use" _Use)
   (NIL "buf" _Buf)
   (NIL "tco" _Tco)
   (NIL "tc" _Tc)
   (NIL "catch" _Catch)
   (NIL "throw" _Throw)
   (NIL "finally" _Finally)
   (NIL "co" _Co)
   (NIL "yield" _Yield)
   (NIL "!" _Break)
   (NIL "e" _E)
   (NIL "$" _Trace)
   (NIL "exec" _Exec)
   (NIL "call" _Call)
   (NIL "ipid" _Ipid)
   (NIL "opid" _Opid)
   (NIL "kill" _Kill)
   (NIL "fork" _Fork)
   (NIL "detach" _Detach)
   (NIL "bye" _Bye)
   # List processing
   (NIL "car" _Car)
   (NIL "cdr" _Cdr)
   (NIL "caar" _Caar)
   (NIL "cadr" _Cadr)
   (NIL "cdar" _Cdar)
   (NIL "cddr" _Cddr)
   (NIL "caaar" _Caaar)
   (NIL "caadr" _Caadr)
   (NIL "cadar" _Cadar)
   (NIL "caddr" _Caddr)
   (NIL "cdaar" _Cdaar)
   (NIL "cdadr" _Cdadr)
   (NIL "cddar" _Cddar)
   (NIL "cdddr" _Cdddr)
   (NIL "caaaar" _Caaaar)
   (NIL "caaadr" _Caaadr)
   (NIL "caadar" _Caadar)
   (NIL "caaddr" _Caaddr)
   (NIL "cadaar" _Cadaar)
   (NIL "cadadr" _Cadadr)
   (NIL "caddar" _Caddar)
   (NIL "cadddr" _Cadddr)
   (NIL "cdaaar" _Cdaaar)
   (NIL "cdaadr" _Cdaadr)
   (NIL "cdadar" _Cdadar)
   (NIL "cdaddr" _Cdaddr)
   (NIL "cddaar" _Cddaar)
   (NIL "cddadr" _Cddadr)
   (NIL "cdddar" _Cdddar)
   (NIL "cddddr" _Cddddr)
   (NIL "nth" _Nth)
   (NIL "con" _Con)
   (NIL "cons" _Cons)
   (NIL "conc" _Conc)
   (NIL "circ" _Circ)
   (NIL "rot" _Rot)
   (NIL "list" _List)
   (NIL "need" _Need)
   (NIL "range" _Range)
   (NIL "full" _Full)
   (NIL "make" _Make)
   (NIL "made" _Made)
   (NIL "chain" _Chain)
   (NIL "link" _Link)
   (NIL "yoke" _Yoke)
   (NIL "copy" _Copy)
   (NIL "mix" _Mix)
   (NIL "append" _Append)
   (NIL "delete" _Delete)
   (NIL "delq" _Delq)
   (NIL "replace" _Replace)
   (NIL "insert" _Insert)
   (NIL "remove" _Remove)
   (NIL "place" _Place)
   (NIL "strip" _Strip)
   (NIL "split" _Split)
   (NIL "reverse" _Reverse)
   (NIL "flip" _Flip)
   (NIL "trim" _Trim)
   (NIL "clip" _Clip)
   (NIL "head" _Head)
   (NIL "tail" _Tail)
   (NIL "stem" _Stem)
   (NIL "fin" _Fin)
   (NIL "last" _Last)
   (NIL "==" _Eq)
   (NIL "n==" _Neq)
   (NIL "=" _Equal)
   (NIL "<>" _Nequal)
   (NIL "=0" _Eq0)
   (NIL "=1" _Eq1)
   (NIL "=T" _EqT)
   (NIL "n0" _Neq0)
   (NIL "nT" _NeqT)
   (NIL "<" _Lt)
   (NIL "<=" _Le)
   (NIL ">" _Gt)
   (NIL ">=" _Ge)
   (NIL "max" _Max)
   (NIL "min" _Min)
   (NIL "atom" _Atom)
   (NIL "pair" _Pair)
   (NIL "circ?" _CircQ)
   (NIL "lst?" _LstQ)
   (NIL "num?" _NumQ)
   (NIL "sym?" _SymQ)
   (NIL "flg?" _FlgQ)
   (NIL "member" _Member)
   (NIL "memq" _Memq)
   (NIL "mmeq" _Mmeq)
   (NIL "sect" _Sect)
   (NIL "diff" _Diff)
   (NIL "index" _Index)
   (NIL "offset" _Offset)
   (NIL "prior" _Prior)
   (NIL "length" _Length)
   (NIL "size" _Size)
   (NIL "bytes" _Bytes)
   (NIL "assoc" _Assoc)
   (NIL "rassoc" _Rassoc)
   (NIL "asoq" _Asoq)
   (NIL "rasoq" _Rasoq)
   (NIL "rank" _Rank)
   (NIL "match" _Match)
   (NIL "fill" _Fill)
   (NIL "prove" _Prove)
   (NIL "->" _Arrow)
   (NIL "unify" _Unify)
   (NIL "group" _Group)
   (NIL "sort" _Sort)
   # System functions
   (NIL "tty" _Tty)
   (NIL "prompt" _Prompt)
   (NIL "raw" _Raw)
   (NIL "alarm" _Alarm)
   (NIL "sigio" _Sigio)
   (NIL "kids" _Kids)
   (NIL "protect" _Protect)
   (NIL "heap" _Heap)
   (NIL "stack" _Stack)
   (NIL "byte" _Byte)
   (NIL "env" _Env)
   (NIL "date" _Date)
   (NIL "time" _Time)
   (NIL "usec" _Usec)
   (NIL "rt" _Rt)
   (NIL "quit" _Quit)
   (NIL "sys" _Sys)
   (NIL "pwd" _Pwd)
   (NIL "cd" _Cd)
   (NIL "ctty" _Ctty)
   (NIL "cmd" _Cmd)
   (NIL "dir" _Dir)
   (NIL "info" _Info)
   (NIL "file" _File)
   (NIL "argv" _Argv)
   (NIL "opt" _Opt)
   (NIL "errno" _Errno)
   (NIL "%@" _Nat)
   (NIL "native" _Native)
   (NIL "struct" _Struct)
   (NIL "lisp" _Lisp)
   (NIL "args" _Args)
   (NIL "next" _Next)
   (NIL "arg" _Arg)
   (NIL "rest" _Rest)
   (NIL "adr" _Adr)
   (NIL "trail" _Trail)
   (NIL "up" _Up)
   (NIL "history" _History)
   ($LastSym "version" _Version) )

# GC relevant data
(local) (gcData cbFuns)

(table gcData
   ($Intern $Pico1)     # Current namespaces of internal symbols
   ($Transient $Nil)    # Short transient names
   (NIL $Nil)           # Long transient names
   ($Alarm $Nil)        # Alarm handler
   ($Sigio $Nil)        # Sigio handler
   ($Lisp $Nil)         # Lisp callbacks: tag+fun
   (NIL $Nil)
   (NIL $Nil)           # 2
   (NIL $Nil)
   (NIL $Nil)           # 3
   (NIL $Nil)
   (NIL $Nil)           # 4
   (NIL $Nil)
   (NIL $Nil)           # 5
   (NIL $Nil)
   (NIL $Nil)           # 6
   (NIL $Nil)
   (NIL $Nil)           # 7
   (NIL $Nil)
   (NIL $Nil)           # 8
   (NIL $Nil)
   (NIL $Nil)           # 9
   (NIL $Nil)
   (NIL $Nil)           # 10
   (NIL $Nil)
   (NIL $Nil)           # 11
   (NIL $Nil)
   (NIL $Nil)           # 12
   (NIL $Nil)
   (NIL $Nil)           # 13
   (NIL $Nil)
   (NIL $Nil)           # 14
   (NIL $Nil)
   (NIL $Nil)           # 15
   (NIL $Nil)
   (NIL $Nil)           # 16
   (NIL $Nil)
   (NIL $Nil)           # 17
   (NIL $Nil)
   (NIL $Nil)           # 18
   (NIL $Nil)
   (NIL $Nil)           # 19
   (NIL $Nil)
   (NIL $Nil)           # 20
   (NIL $Nil)
   (NIL $Nil)           # 21
   (NIL $Nil)
   (NIL $Nil)           # 22
   (NIL $Nil)
   (NIL $Nil)           # 23
   (NIL $Nil)
   (NIL $Nil)           # 24
   ($LispEnd $Nil) )

(table cbFuns
   ($Cb (i64 i64 i64 i64 i64 i64) _Cb1)
   (NIL (i64 i64 i64 i64 i64 i64) _Cb2)
   (NIL (i64 i64 i64 i64 i64 i64) _Cb3)
   (NIL (i64 i64 i64 i64 i64 i64) _Cb4)
   (NIL (i64 i64 i64 i64 i64 i64) _Cb5)
   (NIL (i64 i64 i64 i64 i64 i64) _Cb6)
   (NIL (i64 i64 i64 i64 i64 i64) _Cb7)
   (NIL (i64 i64 i64 i64 i64 i64) _Cb8)
   (NIL (i64 i64 i64 i64 i64 i64) _Cb9)
   (NIL (i64 i64 i64 i64 i64 i64) _Cb10)
   (NIL (i64 i64 i64 i64 i64 i64) _Cb11)
   (NIL (i64 i64 i64 i64 i64 i64) _Cb12)
   (NIL (i64 i64 i64 i64 i64 i64) _Cb13)
   (NIL (i64 i64 i64 i64 i64 i64) _Cb14)
   (NIL (i64 i64 i64 i64 i64 i64) _Cb15)
   (NIL (i64 i64 i64 i64 i64 i64) _Cb16)
   (NIL (i64 i64 i64 i64 i64 i64) _Cb17)
   (NIL (i64 i64 i64 i64 i64 i64) _Cb18)
   (NIL (i64 i64 i64 i64 i64 i64) _Cb19)
   (NIL (i64 i64 i64 i64 i64 i64) _Cb20)
   (NIL (i64 i64 i64 i64 i64 i64) _Cb21)
   (NIL (i64 i64 i64 i64 i64 i64) _Cb22)
   (NIL (i64 i64 i64 i64 i64 i64) _Cb23)
   (NIL (i64 i64 i64 i64 i64 i64) _Cb24) )

# Environment
(local) env

(table env
   ($Link 0)                     # Link register
   ($Bind 0)                     # Bind frames
   ($Break 0)                    # Breakpoint
   ($NsLink 0)                   # Namespace list link
   ($Catch i8* null)             # Catch frames
   ($InFrames i8* null)          # Input frames
   ($OutFrames i8* null)         # Output frames
   ($ErrFrames i8* null)         # Error frames
   ($CtlFrames i8* null)         # Control frames
   ($InFile i8* null)            # Input file
   ($OutFile i8* null)           # Output file
   ($Put (void i8) null)         # Character output function
   ($Get (i32) null)             # Character input function
   ($Parser i64* null)           # String parser
   ($TcoPar $Nil)                # Tail call parameters
   ($TcoLnk 0)                   # Tail call link
   ($Next $Nil)                  # Next vararg
   ($Typ 0)                      # Method type
   ($Key 0)                      # Method key
   ($Make 0)                     # 'make' environment
   ($Yoke 0)
   ($Chr i32 0)                  # Single-char look ahead
   ($Protect i32 0)              # Signal protection
   ($Trace i32 0)                # Trace level
   ($EnvPad i32 0) )             # Pad to 64 bit

# Temporary cell
(array $Cell any
   $Nil
   $Nil )

# Version number
(table $Version
   ($Y (short (pico~car *Version)))
   ($M (short (pico~cadr *Version)))
   ($D (short (pico~caddr *Version))) )

# 'T' in PLIO format
(array $TBuf i8
   (+ INTERN 4)
   (char "T") )

# Bytes
(array $Month i8
   31 31 28 31 30 31 30 31 31 30 31 30 31 )

# Booleans
(var $Repl i1 NO)                # REPL flag
(var $PRepl i1 NO)               # Parent REPL
(var $Tc i1 NO)                  # Tail call
(var $Jam i1 NO)                 # Error jam
(var $InBye i1 NO)               # Exit status
(var $Sync i1 NO)                # Family IPC synchronization

# Strings
(str $Empty "")
(str $Delim " \t\n\r\"'(),[]`{}~")
pil21/src/dec.l0000644000000000000000000003163314643543131010404 0ustar  # 10jul24 Software Lab. Alexander Burger

(symbols '(llvm))

(local) (inFile outFile ioFrame ctFrame dbFile)

# I/O
(struct inFile
   (name 8 i8*)         # File name
   (fd 4 i32)           # File descriptor
   (chr 4 i32)          # Next character
   (line 4 i32)         # Current line number
   (src 4 i32)          # Source start line
   (ix 4 i32)           # Buffer index
   (cnt 4 i32)          # Buffer byte count
   (buf BUFSIZ i8)      # Buffer
   (tty 1 i1) )         # TTY flag

(struct outFile
   (fd 4 i32)           # File descriptor
   (ix 4 i32)           # Buffer index
   (buf BUFSIZ i8)      # Buffer
   (tty 1 i1) )         # TTY flag

(struct ioFrame
   (link 8 i8*)         # Frame link
   (file 8 i8*)         # File structure
   (fun 8 i8*)          # I/O function
   (pid 4 i32) )        # Process ID

(struct ioxFrame
   (link 8 i8*)         # Frame link
   (file 8 i8*)         # NULL
   (fun 8 i8*)          # I/O function
   (exe 8 any)          # Expression
   (chr 4 i32) )        # Saved $Chr

(struct ctFrame
   (link 8 i8*)         # Frame link
   (fd 4 i32) )         # File descriptor

(struct dbFile
   (fd 4 i32)           # File descriptor
   (db 4 i32)           # File number
   (sh 4 i32)           # Block shift
   (siz 4 i32)          # Block size (64 << sh)
   (mark 8 i8*)         # Mark bit vector
   (mrks 8 i64)         # Mark vector size
   (flu 8 i64)          # Free list use count
   (lck 1 i1)           # Lock flag
   (drt 1 i1)           # Dirty flag
   (pad 6 i8) )         # Padding

# Catch/throw
(local) caFrame

(struct caFrame
   (link 8 i8*)         # Frame link
   (tag 8 any)          # Catch tag
   (fin 8 any)          # 'finally' expression
   (co 8 i8*)           # Current coroutine
   (intrn 8 any)        # Internal symbols
   (trns1 8 any)        # Transient symbols
   (trns2 8 any)
   (priv1 8 any)        # Private symbols
   (priv2 8 any)
   (env (env T) i8)     # Saved environment
   (rst 0 i8) )         # Restart jmp_buf (JmpBufSize)

# Coroutines
(local) coroutine

(struct coroutine
   (tag 8 any)          # Coroutine tag
   (nxt 8 i8*)          # Next coroutine
   (org 8 i8*)          # Originator
   (otg 8 any)          # Originator tag
   (prg 8 any)          # Code body
   (lim 8 i8*)          # Stack limit / Free link
   (at 8 any)           # Saved [@]
   (lnk 8 any)          # Link marker
   (bnd 8 any)          # Bind marker
   (ca 8 i8*)           # Catch marker
   (in 8 i8*)           # InFrames marker
   (out 8 i8*)          # OutFrames marker
   (err 8 i8*)          # ErrFrames marker
   (ctl 8 i8*)          # CtlFrames marker
   (intrn 8 any)        # Internal symbols
   (trns1 8 any)        # Transient symbols
   (trns2 8 any)
   (priv1 8 any)        # Private symbols
   (priv2 8 any)
   (env (env T) i8)     # Saved environment
   (rst 0 i8) )         # Restart jmp_buf (JmpBufSize)

# Family IPC
(local) child

(struct child
   (buf 8 i8*)          # Buffer
   (ofs 4 i32)          # Buffer offset
   (cnt 4 i32)          # Buffer byte count
   (pid 4 i32)          # Process ID
   (hear 4 i32)         # Hear pipe
   (tell 4 i32)         # Tell pipe
   (pad 4 i8) )         # Padding

# libc
(local) (malloc realloc free fork getenv setenv getpid getpgrp setsid alarm
setpgid execvp isatty openpty login_tty tcgetattr tcgetpgrp tcsetpgrp read write
pread pwrite fread fwrite putc_unlocked getc_unlocked fopen fflush feof fclose
fileno fsync pipe memcmp strlen strcpy strdup strcmp strchr strrchr dlsym
dlerror dup dup2 close signal poll waitpid setjmp longjmp kill exit)

(de T i8* malloc (i64))
(de T i8* realloc (i8* i64))
(de T void free (i8*))
(de T i32 fork ())
(de T i8* getenv (i8*))
(de T i32 setenv (i8* i8* i32))
(de T i8* getcwd (i8* i64))
(de T i32 chdir (i8*))
(de T i32 getpid ())
(de T i32 getpgrp ())
(de T i32 setsid ())
(de T i32 alarm (i32))
(de T i32 setpgid (i32 i32))
(de T i32 execvp (i8* i8**))
(de T i32 isatty (i32))
(de T i32 openpty (i32* i32* i8* i8* i8*))
(de T i32 login_tty (i32))
(de T i32 tcgetattr (i32 i8*))
(de T i32 tcgetpgrp (i32))
(de T i32 tcsetpgrp (i32 i32))
(de T i64 read (i32 i8* i64))
(de T i64 write (i32 i8* i64))
(de T i64 pread (i32 i8* i64 i64))
(de T i64 pwrite (i32 i8* i64 i64))
(de T i32 fread (i8* i64 i64 i8*))
(de T i32 fwrite (i8* i64 i64 i8*))
(de T i32 putc_unlocked (i32 i8*))
(de T i32 getc_unlocked (i8*))
(de T i8* fopen (i8* i8*))
(de T i32 fflush (i8*))
(de T i32 feof (i8*))
(de T i32 fclose (i8*))
(de T i32 fileno (i8*))
(de T i32 fsync (i32))
(de T i32 pipe (i32*))
(de T i32 memcmp (i8* i8* i64))
(de T i64 strlen (i8*))
(de T i8* strcpy (i8* i8*))
(de T i8* strdup (i8*))
(de T i32 strcmp (i8* i8*))
(de T i8* strchr (i8* i32))
(de T i8* strrchr (i8* i32))
(de T i8* dlsym (i8* i8*))
(de T i8* dlerror ())
(de T i32 dup (i32))
(de T i32 dup2 (i32 i32))
(de T i32 close (i32))
(de T i8* signal (i32 i8*))
(de T i32 waitpid (i32 i32* i32))
(de T i32 poll (i64* i32 i64))
(de T i32 setjmp (i8*))
(de T NIL longjmp (i8* i32))
(de T i32 kill (i32 i32))
(de T NIL exit (i32))

# libreadline
(local) (add_history history_list clear_history)

(de T void add_history (i8*))
(de T i8*** history_list ())
(de T void clear_history ())

# Glue lib.c
(local) (TgOS TgCPU PipeBufSize)

(var TgOS i8 NIL)  # Target OS
(var TgCPU i8 NIL)  # Target CPU
(var PipeBufSize i32 NIL)  # PIPE_BUF
(var Fsign i1 NIL)  # Float conversion
(var Fdigit i64 NIL)

(local) (stderrMsg gPrintf strErrno openRd openWr openRdWr openRdWrExcl
openRdWrCreate openRdWrAppend openWrAppend fseekOfs fseek0 seek0 truncate0
socketPair fcntlCloExec fcntlSetFl nonBlocking fcntlSetOwn getDir)

(de T i8* stderrMsg (i8* i8*))
(de T void gPrintf (i8* i32 i8* i8*))
(de T i8* strErrno ())
(de T i32 openRd (i8*))
(de T i32 openWr (i8*))
(de T i32 openRdWr (i8*))
(de T i32 openRdWrExcl (i8*))
(de T i32 openRdWrCreate (i8*))
(de T i32 openRdWrAppend (i8*))
(de T i32 openWrAppend (i8*))
(de T i1 fseekOfs (i8* i32))
(de T i1 fseek0 (i8*))
(de T i1 seek0 (i32))
(de T i1 truncate0 (i32))
(de T i32 socketPair (i32*))
(de T i32 fcntlCloExec (i32))
(de T void fcntlSetFl (i32 i32))
(de T i32 nonBlocking (i32))
(de T void fcntlSetOwn(i32 i32))
(de T i8* getDir (i8*))

(local) (initReadline gReadline rlHide rlShow rlSigBeg rlSigEnd currentLine)

(de T void initReadline ())
(de T i8* gReadline (i8*))
(de T void rlHide ())
(de T void rlShow ())
(de T void rlSigBeg ())
(de T void rlSigEnd ())
(de T i8* currentLine ())

# Signals
(local) (Sig SigDfl SigIgn)

(var Sig i32 NIL)
(var SigDfl i8* NIL)
(var SigIgn i8* NIL)

(local) (gSignal sigUnblock iSignal sigChld waitWuntraced wifStopped)

(de T i32 gSignal (i32))
(de T void iSignal (i32 i8*))
(de T void sigUnblock (i32))
(de T void sigChld (i32))
(de T i32 waitWuntraced (i32 i32*))
(de T i32 wifStopped (i32*))

(local) (nErrno gErrno)

(de T i32 nErrno ())
(de T i32 gErrno ())

# Terminal
(local) (Tio OrgTermio Termio setRaw setCooked reopenTty)

(var Tio i1 NIL)
(var OrgTermio i8 NIL)
(var Termio i8* NIL)

(de T void stopTerm ())
(de T void setRaw ())
(de T void setCooked ())
(de T i1 reopenTty (i8*))

# System
(local) (getUsec getMsec getDate getGmDate getTime getGmTime ulimStk fileInfo)

(de T i64 getUsec (i1))
(de T i64 getMsec ())
(de T i64 getDate ())
(de T i64 getGmDate ())
(de T i64 getTime ())
(de T i64 getGmTime ())
(de T i8* ulimStk ())
(de T i64 fileInfo (i1 i1 i8* i64*))

# Polling
(local) (pollIn pollOut pollIgn gPoll readyIn readyOut)

(de T void pollIn (i32 i64*))
(de T void pollOut (i32 i64*))
(de T void pollIgn (i64*))
(de T i32 gPoll (i64* i32 i64))
(de T i1 readyIn (i64*))
(de T i1 readyOut (i64*))

# Locking
(local) (rdLock wrLock unLock getLock)

(de T i32 rdLock (i32 i64 i64 i1))
(de T i32 wrLock (i32 i64 i64 i1))
(de T i32 unLock (i32 i64 i64))
(de T i32 getLock (i32 i64 i64))

# Catch and Throw
(local) (JmpBufSize QuitRst)

(var JmpBufSize i64 NIL)  # sizeof(jmp_buf)
(var QuitRst i8 NIL)

# Native lib.c
(local) (dlOpen ffiPrep ffiCall)

(de T i8* dlOpen (i8*))
(de T i8* ffiPrep (i8* i8* i64))
(de T i64 ffiCall (i8* i64))

(local) (boxFloat boxFlt boxDouble boxDbl bufFloat bufDouble)

(de T i64 boxFloat (i32 i64))
(de T i64 boxFlt ())
(de T i64 boxDouble (i64 i64))
(de T i64 boxDbl ())
(de T void bufFloat (i64 i64 i8*))
(de T void bufDouble (i64 i64 i8*))

# Util
(local) chance

(de T i1 chance (i64))

# Case mappings lib.c
(local) (isLowc isUppc isLetterOrDigit toUpperCase toLowerCase)

(de T i1 isLowc (i32))
(de T i1 isUppc (i32))
(de T i1 isLetterOrDigit (i32))
(de T i32 toUpperCase (i32))
(de T i32 toLowerCase (i32))

### Forward references ###

# main.l
(local) (dbg equal compare evList)

(de dbg (i64 any))
(de i1 equal (any any))
(de i64 compare (any any))
(de evList (any))

# gc.l
(local) (cons cons2 cons3 consStr)

(de cons (any any))
(de cons2 (any any any))
(de cons3 (any any any any))
(de consStr (any))

# sym.l
(local) (bufSize bufString mkStr firstByte pack xSym subStr)

(de i64 bufSize (any))
(de i8* bufString (any i8*))
(de mkStr (i8*))
(de i8 firstByte (any))
(de void pack (any i64*))
(de i1 subStr (any any))

# io.l
(local) (flush flushAll newline space outWord outString print repl)

(de i1 flush (i8*))
(de void flushAll ())
(de void newline ())
(de void space ())
(de void outWord (i64))
(de void outString (i8*))
(de void print (any))
(de repl (any i8* any))

# db.l
(local) (dbFetch dbTouch dbZap)

(de void dbFetch (any any))
(de void dbTouch (any any))
(de void dbZap (any))

# flow.l
(local) (putSrc brkLoad)

(de void putSrc (any any))
(de brkLoad (any))

### Primitives ###
(local) (caar cadr cdar cddr int cnt sign sym name memq member length boxNum
box64 eval run)

(inline caar (X)
   (car (car X)) )

(inline cadr (X)
   (car (cdr X)) )

(inline cdar (X)
   (cdr (car X)) )

(inline cddr (X)
   (cdr (cdr X)) )

(inline int (X)
   (shr X 4) )

(inline cnt (X)
   (any (| (shl X 4) 2)) )

(inline sign (X)
   (any (| X 8)) )

(inline sym (X)
   (any (| X 8)) )

(inline name (Tail)
   (until (num? Tail)
      (shift Tail) )
   Tail )

(inline memq (X L)
   (use @
      (loop
         (? (atom L) NO)
         (? (== X (car L)) YES)
         (shift L) ) ) )

(inline member (X L)
   (use @
      (loop
         (? (atom L) NO)
         (? (equal X (car L)) YES)
         (shift L) ) ) )

(inline nth (N X)
   (use @
      (let C (int N)
         (while (dec 'C)
            (shift X) )
         (if (sign? N)
            (cdr X)
            (car X) ) ) ) )

(inline length (X)
   (use @
      (let N 0
         (while (pair X)
            (inc 'N)
            (shift X) )
         N ) ) )

(inline box64 (N)
   (use @
      (if (& N (hex "F000000000000000"))
         (boxNum N)
         (cnt N) ) ) )

(inline eval (X)
   (use @
      (cond
         ((num? X) X)
         ((sym? X) (val X))
         (T (evList X)) ) ) )

(inline exec (Prg)
   (use @
      (loop
         (when (pair (++ Prg))
            (evList @) )
         (? (atom Prg)) ) ) )

(inline run (Prg)
   (use @
      (loop
         (let X (++ Prg)
            (? (atom Prg) (eval X))
            (and (pair X) (evList X)) ) ) ) )

# Runtime checks
(local) (stkChk sigChk)

(inline stkChk (Exe)
   (when (> (val $StkLimit) (stack))
      (stkErr Exe) ) )

(inline sigChk (Exe)
   (when (volatile $Signal)
      (sighandler Exe) ) )

# Argument checks
(local) (needCnt needNum needSymb needPair needLst needVar chkVar needChkVar needNsp)

(inline needCnt (Exe X)
   (unless (cnt? X)
      (cntErr Exe X) )
   X )

(inline needNum (Exe X)
   (unless (num? X)
      (numErr Exe X) )
   X )

(inline needSymb (Exe X)
   (unless (symb? X)
      (symErr Exe X) )
   X )

(inline needPair (Exe X)
   (when (atom X)
      (pairErr Exe X) )
   X )

(inline needLst (Exe X)
   (unless (or (pair X) (nil? X))
      (lstErr Exe X) )
   X )

(inline needVar (Exe X)
   (when (num? X)
      (varErr Exe X) )
   X )

(inline chkVar (Exe X)
   (when (and (>= X $Nil) (>= $T X))
      (protErr Exe X) )
   X )

(inline needChkVar (Exe X)
   (when (num? X)
      (varErr Exe X) )
   (chkVar Exe X)
   X )

(inline needNsp (Exe X)
   (unless (and (pair (val X)) (== $Tilde (car @)))
      (symNspErr Exe X) )
   X )

# Copy environments
(inline putCaEnv (Ca)
   (let Ca: (caFrame Ca)
      (memcpy (Ca: (env)) (env) (env T) T)
      (Ca: intrn (val $Intern))
      (Ca: trns1 (val $Transient))
      (Ca: trns2 (val 2 $Transient))
      (Ca: priv1 (val $PrivT))
      (Ca: priv2 (val 2 $PrivT)) ) )

(inline getCaEnv (Ca)
   (let Ca: (caFrame Ca)
      (memcpy (env) (Ca: (env)) (env T) T)
      (set $Intern (Ca: intrn))
      (set $Transient (Ca: trns1))
      (set 2 $Transient (Ca: trns2))
      (set $PrivT (Ca: priv1))
      (set 2 $PrivT (Ca: priv2)) ) )

(inline putCrtEnv (Crt)
   (let Crt: (coroutine Crt)
      (memcpy (Crt: (env)) (env) (env T) T)
      (Crt: intrn (val $Intern))
      (Crt: trns1 (val $Transient))
      (Crt: trns2 (val 2 $Transient))
      (Crt: priv1 (val $PrivT))
      (Crt: priv2 (val 2 $PrivT)) ) )

(inline getCrtEnv (Crt)
   (let Crt: (coroutine Crt)
      (set $Intern (Crt: intrn))
      (set $Transient (Crt: trns1))
      (set 2 $Transient (Crt: trns2))
      (set $PrivT (Crt: priv1))
      (set 2 $PrivT (Crt: priv2)) ) )
pil21/src/gc.l0000644000000000000000000003257014635055057010251 0ustar  # 20jun24 Software Lab. Alexander Burger

(symbols '(llvm))

(local) (mark gc need3)

(de void mark (E)
   (let Tos 0  # Clear
      (loop
         (until (cnt? E)
            (let (P (any (& E -16))  Q (cdr P))  # Cell pointer
               (? (=0 (& Q 1)))  # Already marked
               (set 2 P (setq Q (& Q -2)))  # Mark cell
               (? (big? E)
                  (until (cnt? Q)
                     (let N (val (big Q))
                        (? (=0 (& N 1)))  # Already marked
                        (setq Q (set (big Q) (& N -2))) ) ) )  # Mark big digits
               (let X E  # Current item
                  (setq E (val P))  # Get CAR
                  (set P (| Tos 1))  # First visit
                  (setq Tos X) ) ) )  # TOS on previous
         (loop
            (let P (any (& Tos -16))  # TOS cell pointer
               (unless P  # Empty
                  (ret) )
               (let Q (val P)  # Up pointer
                  (? (& Q 1)  # Second visit
                     (set P E)  # Restore CAR
                     (setq E (cdr P))  # Get CDR
                     (set 2 P (& Q -2)) ) )  # Store up pointer
               (let X Tos
                  (setq Tos (cdr P))  # TOS up
                  (set 2 P E)  # Restore CDR
                  (setq E X) ) ) ) ) ) )  # Go up

(de void gc ()
   (set $DB $Nil)  # Cut off DB root
   # Prepare
   (let P $Nil  # Symbol table
      (set P (| (val P) 1))  # Set mark bit
      (setq P (ofs P 4))  # Skip NIL tail
      (loop
         (set P (| (val P) 1))  # Set mark bit
         (? (== P $LastSym))
         (setq P (ofs P 2)) ) )  # Next symbol
   (let P (val $Heaps)
      (loop
         (let C CELLS
            (loop
               (set 2 P (| (cdr P) 1))  # Set mark bit
               (setq P (ofs P 2))  # Next cell
               (? (=0 (dec 'C))) ) )
         (setq P (val P))  # Next heap
         (? (=0 P)) ) )
   # Mark
   (let P (any (gcData))  # Globals
      (loop
         (mark (val P))  # Mark
         (? (== P $LispEnd))
         (setq P (ofs P 1)) ) )  # Next global
   (let P (val $Link)  # Stack(s)
      (while P
         (mark (val P))  # Mark item
         (shift P) ) )
   (let P (val $Bind)  # Bind frames
      (while P
         (mark (val P))  # Mark saved value
         (mark (val 2 P))  # Mark symbol
         (setq P (val 3 P)) ) )
   (let Ca (val $Catch)  # Catch frames
      (while Ca
         (let Ca: (caFrame Ca)
            (when (Ca: tag)  # Mark 'tag'
               (mark @) )
            (mark (Ca: fin))  # Mark 'fin'
            (mark (Ca: intrn))
            (mark (Ca: trns1))
            (mark (Ca: trns2))
            (mark (Ca: priv1))
            (mark (Ca: priv2))
            (setq Ca (Ca: link)) ) ) )
   (let Crt (val $Coroutines)
      (while Crt
         (let Crt: (coroutine Crt)
            (when (Crt: tag)
               (mark (Crt: tag))
               (mark (Crt: otg))
               (mark (Crt: prg))
               (when (Crt: at)
                  (mark (Crt: at))
                  (mark (Crt: intrn))
                  (mark (Crt: trns1))
                  (mark (Crt: trns2))
                  (mark (Crt: priv1))
                  (mark (Crt: priv2))
                  (let P (Crt: (env $Link any))  # Stack(s)
                     (while P
                        (mark (val P))  # Mark item
                        (shift P) ) )
                  (let P (Crt: (env $Bind any))  # Bind frames
                     (while P
                        (mark (val P))  # Mark saved value
                        (mark (val 2 P))  # Mark symbol
                        (setq P (val 3 P)) ) )
                  (let Ca (Crt: (env $Catch i8*))
                     (while Ca
                        (let Ca: (caFrame Ca)
                           (when (Ca: tag)  # Mark 'tag'
                              (mark (Ca: tag)) )
                           (mark (Ca: fin))
                           (mark (Ca: intrn))
                           (mark (Ca: trns1))
                           (mark (Ca: trns2))
                           (mark (Ca: priv1))
                           (mark (Ca: priv2))
                           (setq Ca (Ca: link)) ) ) ) ) )
            (setq Crt (Crt: nxt)) ) ) )
   (let (Tos 0  P (val $Extern))  # Externals
      (loop
         (loop
            (let X (any (& (cdr P) -2))
               (set 2 P X)  # Clear mark bit
               (let Y (any (& (cdr X) -2))  # Right subtree
                  (set 2 X Y)  # Clear mark bit
                  (? (atom Y))
                  (let Z P  # Go right
                     (setq P Y)  # Invert tree
                     (set 2 X Tos)
                     (setq Tos Z) ) ) ) )
         (loop
            (let S (val P)  # Get external symbol
               (when (& (val S) 1)  # Not marked
                  (let Tail (val (tail S))
                     (unless (num? Tail)  # Has properties
                        (setq Tail (& Tail -10))  # Clear 'extern' tag and mark bit
                        (until (num? (shift Tail))  # Skip property
                           (setq Tail (& Tail -2)) ) )  # Clear mark bit
                     (add Tail Tail)  # Get carry
                     (when @@  # Dirty or deleted
                        (mark S) ) ) ) )
            (let X (cdr P)  # Left subtree
               (? (pair (car X))
                  (let Z P  # Go left
                     (setq P @)  # Invert tree
                     (set X Tos)
                     (setq Tos (| Z 8)) ) ) )  # First visit
            (loop
               (unless Tos
                  (goto 1) )
               (? (=0 (& Tos 8))  # Second visit
                  (let (X Tos  Y (cdr X))  # Nodes
                     (setq Tos (cdr Y))  # TOS on up link
                     (set 2 Y P)
                     (setq P X) ) )
               (setq Tos (& Tos -9))  # Clear visit bit
               (let (X Tos  Y (cdr X))  # Nodes
                  (setq Tos (car Y))
                  (set Y P)
                  (setq P X) ) ) ) ) )
   (: 1
      (when (val $DBs)
         (set $DB $Db1) )  # Restore DB root
      (when (& (val $Db1) 1)  # Not marked
         (set
            $Db1 $Nil  # Clear
            (tail $Db1) DB1 ) ) )  # Set to "not loaded"
   (let (Tos 0  P (val $Extern))  # Externals
      (: 2
         (loop
            (loop
               (let X (cdr P)  # Right subtree
                  (? (atom (cdr X)))
                  (let Z P  # Go right
                     (setq P @)  # Invert tree
                     (set 2 X Tos)
                     (setq Tos Z) ) ) )
            (loop
               (when (& (val (val P)) 1)  # External symbol not marked
                  (set $ExtCnt (- (val $ExtCnt) 1))  # Remove it
                  (let X (cdr P)
                     (when (atom X)  # No subtrees
                        (set 2 P (| X 1))  # Set mark bit again
                        (setq P X)  # Use NIL
                        (goto 4) )  # Already traversed
                     (when (atom (car X))  # No left branch
                        (set 2 P (| X 1))  # Set mark bit again
                        (setq P (cdr X))  # Use right branch
                        (set 2 X (| P 1))
                        (goto 4) )  # Already traversed
                     (when (atom (cdr X))  # No right branch
                        (set 2 P (| X 1))  # Set mark bit again
                        (setq P (car X))  # Use left branch
                        (set 2 X (| (cdr X) 1))
                        (goto 2) )
                     (let Y (cdr (shift X))  # X on right branch
                        (when (atom (car Y))  # No left sub-branches
                           (set
                              P (car X)  # Insert right sub-branch
                              2 (cdr P) (cdr Y) )
                           (goto 3) )
                        (setq Y (car Y))  # Left sub-branch
                        (loop
                           (? (atom (cadr Y))  # No more left branches
                              (set  # Insert left sub-branch
                                 P (car Y)
                                 (cdr X) (cddr Y) ) )
                           (setq X Y  Y @) ) ) ) )  # Go down left
               (: 3
                  (let X (cdr P)  # Left subtree
                     (? (pair (car X))
                        (let Z P  # Go left
                           (setq P @)  # Invert tree
                           (set X Tos)
                           (setq Tos (| Z 8)) ) ) ) )  # First visit
               (: 4
                  (loop
                     (unless Tos
                        (goto 5) )
                     (? (=0 (& Tos 8))  # Second visit
                        (let (X Tos  Y (cdr X))  # Nodes
                           (setq Tos (cdr Y))  # TOS on up link
                           (set 2 Y P)
                           (setq P X) ) )
                     (let (X (& Tos -9)  Y (cdr X))  # Clear visit bit
                        (setq Tos (car Y))
                        (set Y P)
                        (setq P X) ) ) ) ) ) )
      (: 5 (set $Extern P)) )
   # Sweep
   (let (Avail 0  Heap (val $Heaps)  Cnt (val $GcCount))
      (ifn Cnt
         (let H (any $Heaps)  # Try to free heaps
            (loop
               (let (A Avail  P (ofs Heap (- HEAP 2)))  # P on last cell in chunk
                  (setq Cnt CELLS)
                  (loop
                     (when (& (cdr P) 1)  # Free cell
                        (set P Avail)  # Link avail
                        (setq Avail P)
                        (dec 'Cnt) )
                     (? (== P Heap))
                     (setq P (ofs P -2)) )  # Back one cell
                  (if Cnt
                     (setq Heap (val (setq H (ofs Heap HEAP))))  # Next heap
                     (setq Avail A  Heap (val (inc HEAP) Heap))  # Reset avail list
                     (free (i8* (val H)))  # Free empty heap
                     (set H Heap) ) )  # Store next heap in list link
               (? (=0 Heap)) )
            (set $Avail Avail) )
         (loop
            (let P (ofs Heap (- HEAP 2))  # P on last cell in chunk
               (loop
                  (when (& (cdr P) 1)  # Free cell
                     (set P Avail)  # Link avail
                     (setq Avail P)
                     (dec 'Cnt) )
                  (? (== P Heap))
                  (setq P (ofs P -2)) ) )  # Back one cell
            (? (=0 (setq Heap (val (inc HEAP) Heap)))) )
         (set $Avail Avail)
         (while (ge0 Cnt)  # Ensure free cells
            (heapAlloc)
            (dec 'Cnt CELLS) ) ) ) )

(de void need3 ()
   (let P (val $Avail)
      (unless (and P (setq P (car P)) (car P))
         (gc) ) ) )

# (gc ['cnt [cnt2]]) -> cnt | NIL
(de _Gc (Exe)
   (let (X (cdr Exe)  Y (eval (car X)))  # MiBs
      (if (nil? Y)
         (gc)
         (set $GcCount (shl (xCnt Exe Y) 16))  # Multiply with CELLS
         (gc)
         (set $GcCount
            (if (atom (shift X))
               CELLS
               (shl (evCnt Exe X) 16) ) ) )  # New default
      Y ) )

# Cell allocation (consing)
(local) (cons cons2 cons3 consSym consStr consExt boxNum consNum box)

(de cons (Car Cdr)
   (let P (val $Avail)
      (unless P
         (save2 Car Cdr
            (gc) )
         (setq P (val $Avail)) )
      (set $Avail (car P))
      (set P Car)
      (set 2 P Cdr)
      P ) )

(de cons2 (Car1 Cdr1 Cdr2)
   (let P (val $Avail)
      (when P
         (let Q (val P)
            (when Q
               (set $Avail (car Q))
               (set P Car1)
               (set 2 P Cdr1)
               (set Q P)
               (set 2 Q Cdr2)
               (ret Q) ) ) ) )
   (save2 Car1 Cdr1
      (save Cdr2
         (gc) ) )
   (let (P (val $Avail)  Q (val P))
      (set $Avail (car Q))
      (set P Car1)
      (set 2 P Cdr1)
      (set Q P)
      (set 2 Q Cdr2)
      Q ) )

(de cons3 (Car1 Cdr1 Car2 Cdr2)
   (let P (val $Avail)
      (when P
         (let Q (val P)
            (when Q
               (let R (val Q)
                  (when R
                     (set $Avail (car R))
                     (set P Car1)
                     (set 2 P Cdr1)
                     (set Q Car2)
                     (set 2 Q Cdr2)
                     (set R P)
                     (set 2 R Q)
                     (ret R) ) ) ) ) ) )
   (save2 Car1 Cdr1
      (save2 Car2 Cdr2
         (gc) ) )
   (let (P (val $Avail)  Q (val P)  R (val Q))
      (set $Avail (car R))
      (set P Car1)
      (set 2 P Cdr1)
      (set Q Car2)
      (set 2 Q Cdr2)
      (set R P)
      (set 2 R Q)
      R ) )

(de consSym (Name Val)
   (let P (val $Avail)
      (unless P
         (if Val
            (save2 Name Val
               (gc) )
            (save Name
               (gc) ) )
         (setq P (val $Avail)) )
      (set $Avail (car P))
      (set P Name)
      (let S (sym P)
         (set S (if Val @ S))
         S ) ) )

(de consStr (Name)
   (if (== Name ZERO)
      $Nil
      (tailcall (consSym Name 0)) ) )

(de consExt (Name)
   (set $ExtCnt (+ (val $ExtCnt) 1))
   (tailcall (consSym (sign Name) $Nil)) )

(de boxNum (Dig)
   (let P (val $Avail)
      (unless P
         (gc)
         (setq P (val $Avail)) )
      (set $Avail (car P))
      (set P Dig)
      (set 2 P ZERO)
      (big P) ) )

(de consNum (Dig Big)
   (let P (val $Avail)
      (unless P
         (save Big
            (gc) )
         (setq P (val $Avail)) )
      (set $Avail (car P))
      (set P Dig)
      (set 2 P Big)
      (big P) ) )

(de box (N)
   (if (ge0 N)
      (box64 N)
      (sign (box64 (- N))) ) )
pil21/src/big.l0000644000000000000000000014651514717370570010427 0ustar  # 20nov24 Software Lab. Alexander Burger

(symbols '(llvm))

(local) (pos neg divErr)

(inline pos (N)
   (any (& N -9)) )

(inline neg (N)
   (if (== N ZERO)
      N
      (any (x| N 8)) ) )

(de NIL divErr (Exe)
   (err Exe 0 ($ "Div/0") null) )

### Bignum byte access ###
(local) (symByte symChar byteNum byteSym charSym)

(de i8 symByte ((i64* . P))  # [cnt name]
   (let C (val P)  # Get cnt
      (unless C  # New round
         (let Nm (val 2 P)
            (cond
               ((== Nm ZERO) (ret (i8 0)))  # Done
               ((cnt? Nm)  # Short
                  (setq C (int Nm))
                  (set 2 P ZERO) )
               (T  # Big: Next digit
                  (setq C (set P (val (dig Nm))))
                  (set 2 P (val (big Nm))) ) ) ) )
      (set P (shr C 8))
      (i8 C) ) )

(de i32 symChar ((i64* . P))  # [cnt name]
   (let C (i32 (symByte P))
      (cond
         ((>= 127 C) C)  # Single byte
         ((== C (hex "FF")) (i32 TOP))  # Infinite
         (T
            (|
               (shl
                  (ifn (& C (hex "20"))
                     (& C (hex "1F"))
                     (|
                        (shl
                           (ifn (& C (hex "10"))
                              (& C (hex "0F"))
                              (|
                                 (shl (& C (hex "7")) 6)
                                 (& (i32 (symByte P)) (hex "3F")) ) )
                           6 )
                        (& (i32 (symByte P)) (hex "3F")) ) )
                  6 )
               (& (i32 (symByte P)) (hex "3F")) ) ) ) ) )

(de void byteNum ((i8 . B) (i64* . P))  # [cnt last name link]
   (let (Cnt (val P)  Nm (val 3 P))
      (if (cnt? Nm)
         # xxxxx.xxxxxxx.xxxxxxx.xxxxxxx.xxxxxxx.xxxxxxx.xxxxxxx.xxxxxxS010
         #    59      51      43      35      27      19      11       3
         (cond
            ((== Cnt 67)  # Short full
               (set 3 P
                  (set 2 P
                     (consNum (shr Nm 3) (cnt (i64 B))) ) )
               (set P 12) )  # Next digit in bignum
            ((and (== Cnt 59) (>= B 32))  # Fit into 5 bits
               (set 3 P
                  (set 2 P
                     (boxNum
                        (| (shr Nm 3) (shl (i64 B) 56)) ) ) )
               (set P 4) )  # Start next digit in bignum
            (T
               (set
                  3 P (| Nm (shl (i64 B) Cnt))
                  P (+ Cnt 8) ) ) )
         (let (Q (val 2 P)  N (val (big Q)))
            (cond
               ((== Cnt 68)  # Last short full
                  (set 2 P
                     (set (big Q)
                        (consNum (int N) (cnt (i64 B))) ) )
                  (set P 12) )  # Next digit in bignum
               ((and (== Cnt 60) (>= B 16))  # Fit into 4 bits
                  (set 2 P
                     (set (big Q)
                        (boxNum
                           (| (int N) (shl (i64 B) 56)) ) ) )
                  (set P 4) )  # Start next digit in bignum
               (T
                  (set
                     (big Q) (| N (shl (i64 B) Cnt))
                     P (+ Cnt 8) ) ) ) ) ) ) )

(de void byteSym ((i8 . B) (i64* . P))  # [cnt last name link]
   (let (Cnt (val P)  Nm (val 3 P))
      (if (cnt? Nm)
         # 0000.xxxxxxx.xxxxxxx.xxxxxxx.xxxxxxx.xxxxxxx.xxxxxxx.xxxxxxx0010
         #   60      52      44      36      28      20      12       4
         (if (> 60 Cnt)  # Digit not full
            (set
               3 P (| Nm (shl (i64 B) Cnt))
               P (+ Cnt 8) )
            (set 3 P
               (set 2 P
                  (boxNum  # Make big
                     (| (int Nm) (shl (i64 B) 56)) ) ) )
            (set P 4) )  # Start new digit
         (let (Q (val 2 P)  N (val (big Q)))
            (if (> 60 Cnt)  # Digit not full
               (set
                  (big Q) (| N (shl (i64 B) Cnt))
                  P (+ Cnt 8) )
               (set 2 P
                  (set (big Q)
                     (boxNum  # Make big
                        (| (int N) (shl (i64 B) 56)) ) ) )
               (set P 4) ) ) ) ) )  # Start new digit

(de void charSym ((i32 . C) (i64* . P))  # [cnt last name link]
   (cond
      ((>= 127 C) (byteSym (i8 C) P))  # Single byte
      ((== TOP C) (byteSym (hex "FF") P))  # Infinite
      (T
         (cond
            ((> (hex "800") C)  # Double-byte
               (byteSym (i8 (| (hex "C0") (& (shr C 6) (hex "1F")))) P) )  # 10xxxxx 10xxxxxx
            ((> (hex "10000") C)  # Three bytes
               (byteSym (i8 (| (hex "E0") (& (shr C 12) (hex "0F")))) P)  # 1110xxxx 10xxxxxx 10xxxxxx
               (byteSym (i8 (| (hex "80") (& (shr C 6) (hex "3F")))) P) )
            (T
               (byteSym (i8 (| (hex "F0") (& (shr C 18) (hex "07")))) P)  # 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
               (byteSym (i8 (| (hex "80") (& (shr C 12) (hex "3F")))) P)
               (byteSym (i8 (| (hex "80") (& (shr C 6) (hex "3F")))) P) ) )
         (byteSym (i8 (| (hex "80") (& C (hex "3F")))) P) ) ) )

### Destructive primitives ###
(local) (zapZero twiceBig twice half tenfold)

# Remove leading zeroes
(de zapZero (N)
   (let (P (push N)  X P  Y P  Z T)
      (until (cnt? (setq Z (val (big N))))  # Last cell
         (when (val (dig N))  # Null digit?
            (setq X Y) )  # New null-tail
         (setq
            Y (big N)  # New short-tail
            N (val Y) ) )  # Next cell
      (when (== Z ZERO)
         (cond
            ((setq N (val (dig N)))  # Final digit
               (unless (& N (hex "F000000000000000"))
                  (set Y (cnt N)) ) )  # Store in short-tail
            ((&
                  (setq N (val (dig (val X))))  # Digit in null-tail
                  (hex "F000000000000000") )
               (set (big (val X)) ZERO) )  # Trim null-tail
            (T (set X (cnt N))) ) )  # Store in null-tail
      (val P) ) )

# Multiply (unsigned) number by 2
(de twiceBig (N)
   (let (X N  A (val (dig X))  Y (val (big X)))
      (set (dig X) (shl A 1))
      (while (big? Y)
         (let B (val (dig Y))
            (set (dig (setq X Y))
               (| (shl B 1) (shl 0 A 1)) )
            (setq A B  Y (val (big Y))) ) )
      (set (big X)
         (box64
            (| (shl (int Y) 1) (shl 0 A 1)) ) ) )
   N )

(de twice (N)
   (if (cnt? N)
      (let X (add N N)  # Shift left
         (if @@  # Overflow
            (boxNum (shr N 3))  # Make big
            (x| X 6) ) )  # Fix tag bit
      (twiceBig N) ) )

# Divide (unsigned) number by 2
(de half (N)
   (if (cnt? N)
      (| (& (shr N 1) -10) 2)  # Clear lowest bit and tag
      (let (X N  A (shr (val (dig X)) 1)  Y (val (big X)))
         (if (big? Y)
            (let Z (val (big Y))
               (loop
                  (let B (val (dig Y))
                     (set (dig X) (| (shr B 0 1) A))
                     (setq A (shr B 1)) )
                  (? (cnt? Z))
                  (setq X Y  Y Z  Z (val (big Z))) )
               (setq
                  Z (int Z)
                  A (| (shr Z 0 1) A) )
               (ifn
                  (or
                     (setq Z (shr Z 1))
                     (& A (hex "F000000000000000")) )
                  (set (big X) (cnt A))
                  (set (dig Y) A)
                  (set (big Y) (cnt Z)) ) )
            (setq
               Y (int Y)
               A (| (shr Y 0 1) A) )
            (unless
               (or
                  (setq Y (shr Y 1))
                  (& A (hex "F000000000000000")) )
               (ret (cnt A)) )
            (set (dig X) A)
            (set (big X) (cnt Y)) )
         N ) ) )

# Multiply (unsigned) number by 10
(de tenfold (N)
   (if (cnt? N)
      (box64 (* 10 (int N)))
      (let (X N  Lo (mul 10 (val (dig X)))  Hi @@@)
         (loop
            (set (dig X) Lo)
            (? (cnt? (val (big X)))
               (set (big X)
                  (box64 (+ Hi (* 10 (int @)))) ) )
            (setq X @)
            (setq
               Lo (add (mul 10 (val (dig X))) Hi)
               Hi (+ @@@ @@) ) )
         N ) ) )

### Non-destructive unsigned primitives ###
(local) (shlu shru andu oru xoru addu sub1 subu mulAddHiLo mulu div1 divu remu)

# Multiply (unsigned) number by 2
(de shlu (N)
   (if (cnt? N)
      (let X (add N N)  # Shift left
         (if @@  # Overflow
            (boxNum (shr N 3))  # Make big
            (x| X 6) ) )  # Fix tag bit
      (let
         (A (val (dig N))
            X (boxNum (shl A 1))
            Y (val (big N))
            R (save X) )
         (while (big? Y)
            (let B (val (dig Y))
               (setq X
                  (set (big X)
                     (boxNum (| (shl B 1) (shl 0 A 1))) ) )
               (setq A B  Y (val (big Y))) ) )
         (set (big X)
            (box64
               (| (shl (int Y) 1) (shl 0 A 1)) ) )
         R ) ) )

# Divide (unsigned) number by 2
(de shru (N)
   (if (cnt? N)
      (| (& (shr N 1) -10) 2)  # Clear lowest bit and tag
      (let A (shr (val (dig N)) 1)
         (if (big? (setq N (val (big N))))
            (let
               (B (val (dig N))
                  P (boxNum (| (shr B 0 1) A))
                  R (save P) )
               (loop
                  (setq A (shr B 1))
                  (? (cnt? (setq N (val (big N)))))
                  (setq
                     B (val (dig N))
                     P
                     (set (big P)
                        (boxNum (| (shr B 0 1) A)) ) ) )
               (setq
                  N (int N)
                  A (| (shr N 0 1) A) )
               (set (big P)
                  (ifn
                     (or
                        (setq N (shr N 1))
                        (& A (hex "F000000000000000")) )
                     (cnt A)
                     (prog1
                        (boxNum A)
                        (set (big @) (cnt N)) ) ) )
               R )
            (setq
               N (int N)
               A (| (shr N 0 1) A) )
            (ifn
               (or
                  (setq N (shr N 1))
                  (& A (hex "F000000000000000")) )
               (cnt A)
               (prog1
                  (boxNum A)
                  (set (big @) (cnt N)) ) ) ) ) ) )

# Bitwise AND of two (unsigned) numbers
(de andu (A B)
   (cond
      ((cnt? A)
         (& A
            (if (cnt? B) B (cnt (val (dig B)))) ) )
      ((cnt? B)  # A is big
         (& B (cnt (val (dig A)))) )
      (T  # Both are big
         (let
            (P
               (boxNum
                  (& (val (dig A)) (val (dig B))) )
               R (save P) )
            (loop
               (setq A (val (big A))  B (val (big B)))
               (? (cnt? A)
                  (set (big P)
                     (& A
                        (if (cnt? B) B (cnt (val (dig B)))) ) ) )
               (? (cnt? B)
                  (set (big P)
                     (& B (cnt (val (dig A)))) ) )
               (setq P
                  (set (big P)
                     (boxNum
                        (& (val (dig A)) (val (dig B))) ) ) ) )
            (zapZero R) ) ) ) )

# Bitwise OR of two (unsigned) numbers
(de oru (A B)
   (cond
      ((cnt? A)
         (if (cnt? B)
            (| A B)
            (consNum
               (| (int A) (val (dig B)))
               (val (big B)) ) ) )
      ((cnt? B)  # A is big
         (consNum
            (| (int B) (val (dig A)))
            (val (big A)) ) )
      (T  # Both are big
         (let
            (P
               (boxNum
                  (| (val (dig A)) (val (dig B))) )
               R (save P) )
            (loop
               (setq A (val (big A))  B (val (big B)))
               (? (cnt? A)
                  (set (big P)
                     (if (cnt? B)
                        (| A B)
                        (consNum
                           (| (int A) (val (dig B)))
                           (val (big B)) ) ) ) )
               (? (cnt? B)
                  (set (big P)
                     (consNum
                        (| (int B) (val (dig A)))
                        (val (big A)) ) ) )
               (setq P
                  (set (big P)
                     (boxNum
                        (| (val (dig A)) (val (dig B))) ) ) ) )
            R ) ) ) )

# Bitwise XOR of two (unsigned) numbers
(de xoru (A B)
   (cond
      ((cnt? A)
         (if (cnt? B)
            (| (x| A B) 2)
            (zapZero
               (consNum
                  (x| (int A) (val (dig B)))
                  (val (big B)) ) ) ) )
      ((cnt? B)  # A is big
         (zapZero
            (consNum
               (x| (int B) (val (dig A)))
               (val (big A)) ) ) )
      (T  # Both are big
         (let
            (P
               (boxNum
                  (x| (val (dig A)) (val (dig B))) )
               R (save P) )
            (loop
               (setq A (val (big A))  B (val (big B)))
               (? (cnt? A)
                  (set (big P)
                     (if (cnt? B)
                        (| (x| A B) 2)
                        (consNum
                           (x| (int A) (val (dig B)))
                           (val (big B)) ) ) ) )
               (? (cnt? B)
                  (set (big P)
                     (consNum
                        (x| (int B) (val (dig A)))
                        (val (big A)) ) ) )
               (setq P
                  (set (big P)
                     (boxNum
                        (x| (val (dig A)) (val (dig B))) ) ) ) )
            (zapZero R) ) ) ) )

# Add two (unsigned) numbers
(de addu (A B)
   (cond
      ((cnt? A)
         (if (cnt? B)
            (box64 (+ (int A) (int B)))
            (xchg 'A 'B)
            (goto 1) ) )
      ((cnt? B)  # A is big
         (: 1
            (let N (val (big A))
               (setq B (add (int B) (val (dig A))))
               (ifn @@
                  (consNum B N)  # No carry
                  (let R (save (setq B (consNum B N)))  # Else build new head
                     (loop
                        (? (cnt? N)
                           (setq N (add N (hex "10")))  # Add carry
                           (set (big B)
                              (ifn @@  # No further carry
                                 N  # Append it
                                 (boxNum (| (int N) (hex "1000000000000000"))) ) ) )  # Set top bit
                        (let D (val (dig N))  # Next digit
                           (setq
                              N (val (big N))
                              D (add D 1) )  # Add carry
                           (? (not @@)  # No carry
                              (set (big B) (consNum D N)) )
                           (setq B (set (big B) (consNum D N))) ) )
                     R ) ) ) ) )
      (T  # Both are big
         (let
            (N (add (val (dig A)) (val (dig B)))
               C @@
               P (boxNum N)
               R (save P) )
            (loop
               (setq A (val (big A))  B (val (big B)))
               (? (cnt? A)
                  (if (cnt? B)
                     (set (big P)
                        (box64 (add (int A) (int B) C)) )
                     (xchg 'A 'B)
                     (goto 2) ) )
               (? (cnt? B)
                  (: 2
                     (setq
                        N (add (int B) (val (dig A)) C)
                        C @@ )
                     (loop
                        (setq P
                           (set (big P)
                              (consNum N (setq A (val (big A)))) ) )
                        (? (not C))
                        (? (cnt? A)
                           (set (big P) (box64 (+ (int A) C))) )
                        (setq
                           N (add (val (dig A)) 1)
                           C @@ ) ) ) )
               (setq
                  N (add (val (dig A)) (val (dig B)) C)
                  C @@
                  P (set (big P) (boxNum N)) ) )
            R ) ) ) )

# Subtract short from big number
(de sub1 (B N)
   (setq
      N (sub (val (dig B)) (int N))
      B (val (big B)) )
   (nond
      (@@  # No borrow
         (if (== B ZERO)
            (box64 N)
            (consNum N B) ) )
      ((big? B)  # Single cell
         (setq B (sub B (hex "10")))  # Subtract borrow
         (if @@  # Again borrow
            (sign (cnt (- N)))  # Lowest digit
            (zapZero (consNum N B)) ) )
      (NIL
         (let (P (boxNum N B)  R (save P))
            (loop
               (setq
                  N (sub (val (dig B)) 1)  # Subtract borrow
                  B (val (big B)) )
               (? (not @@)
                  (set (big P) (consNum N B)) )
               (setq P (set (big P) (consNum N B)))
               (? (cnt? B)
                  (set (big P) (sub B (hex "10"))) ) )  # Subtract borrow
            (zapZero R) ) ) ) )

# Subtract two (unsigned) numbers
(de subu (A B)
   (cond
      ((cnt? A)
         (if (cnt? B)
            (let N (sub A (& B -3))  # Clear tag
               (if @@
                  (+ (x| N -16) (hex "18"))  # 2-complement
                  N ) )
            (neg (sub1 B A)) ) )
      ((cnt? B)  # A is big
         (sub1 A B) )
      (T  # Both are big
         (let
            (N (sub (val (dig A)) (val (dig B)))
               C @@
               P (boxNum N)
               R (save P) )
            (loop
               (setq A (val (big A))  B (val (big B)))
               (? (cnt? B)
                  (setq B (int B))
                  (until (cnt? A)
                     (setq
                        N (sub (val (dig A)) B C)
                        C @@
                        A (val (big A))
                        P (set (big P) (consNum N A)) )
                     (unless C
                        (ret (zapZero R)) )
                     (setq B 0) )
                  (setq A (int A)) )
               (? (cnt? A)
                  (setq A (int A))
                  (loop
                     (setq
                        N (sub A (val (dig B)) C)
                        C @@
                        P (set (big P) (boxNum N)) )
                     (setq A 0)
                     (? (cnt? (setq B (val (big B))))) )
                  (setq B (int B)) )
               (setq
                  N (sub (val (dig A)) (val (dig B)) C)
                  C @@
                  P (set (big P) (boxNum N)) ) )
            (set (big P) (cnt (sub A B C)))  # Subtract final shorts with borrow
            (ifn @@
               (zapZero R)
               # 2-complement
               (let Q R
                  (loop  # Invert
                     (set (dig Q) (x| (val (dig Q)) -1))
                     (? (cnt? (setq N (val (big Q)))))
                     (setq Q N) )
                  (set (big Q) (x| N -16)) )
               (let Q R
                  (loop  # Increment
                     (set (dig Q) (add (val (dig Q)) 1))
                     (unless @@
                        (goto 9) )
                     (? (cnt? (setq N (val (big Q)))))
                     (setq Q N) )
                  (set (big Q) (+ N (hex "10"))) )
               (: 9
                  (sign (zapZero R)) ) ) ) ) ) )

# Multiply two (unsigned) numbers
(inline (Lo Hi) mulAddHiLo (X Y P)
   (let H Hi
      (setq
         Lo (add (mul X Y) (val (dig P)))
         Hi (+ @@@ @@)
         Lo (add Lo H)
         Hi (+ Hi @@) ) ) )

(de mulu (A B)
   (cond
      ((== A ZERO) A)
      ((cnt? A)
         (setq A (int A))
         (if (cnt? B)
            (let N (mul A (int B))
               (if (or @@@ (& N (hex "F000000000000000")))  # Fit in short number
                  (consNum N (cnt @@@))
                  (cnt N) ) )
            (: 1
               (let
                  (Lo (mul A (val (dig B)))
                     Hi @@@
                     P (boxNum Lo)
                     R (save P) )
                  (while (big? (setq B (val (big B))))
                     (setq
                        Lo (add (mul A (val (dig B))) Hi)
                        Hi (+ @@@ @@)
                        P (set (big P) (boxNum Lo)) ) )
                  (setq
                     Lo (add (mul A (int B)) Hi)
                     Hi (+ @@@ @@) )
                  (set (big P)
                     (if (or Hi (& Lo (hex "F000000000000000")))  # Fit in short number
                        (consNum Lo (cnt Hi))
                        (cnt Lo) ) )
                  R ) ) ) )
      ((== B ZERO) B)
      ((cnt? B)  # A is big
         (setq B (int B))
         (xchg 'A 'B)
         (goto 1) )
      (T  # Both are big
         (let (P (boxNum 0)  R (save P))
            (loop
               (let
                  (X A
                     Q P
                     Lo
                     (add
                        (mul (val (dig X)) (val (dig B)))
                        (val (dig Q)) )
                     Hi (+ @@@ @@) )
                  (loop
                     (set (dig Q) Lo)
                     (setq Q
                        (if (cnt? (val (big Q)))
                           (set (big Q) (boxNum 0))
                           @ ) )
                     (? (cnt? (setq X (val (big X)))))
                     (mulAddHiLo (val (dig X)) (val (dig B)) Q) )
                  (mulAddHiLo (int X) (val (dig B)) Q)
                  (set (dig Q) Lo)
                  (when Hi
                     (if (cnt? (val (big Q)))
                        (set (big Q) (boxNum Hi))
                        (set (big @) Hi) ) ) )
               (setq P (val (big P)))
               (? (cnt? (setq B (val (big B))))) )
            (setq B (int B))
            (let
               (Lo
                  (add
                     (mul (val (dig A)) B)
                     (val (dig P)) )
                  Hi (+ @@@ @@) )
               (loop
                  (set (dig P) Lo)
                  (setq P
                     (if (cnt? (val (big P)))
                        (set (big P) (boxNum 0))
                        @ ) )
                  (? (cnt? (setq A (val (big A)))))
                  (mulAddHiLo (val (dig A)) B P) )
               (mulAddHiLo (int A) B P)
               (set (dig P) Lo)
               (when Hi
                  (if (cnt? (val (big P)))
                     (set (big P) (boxNum Hi))
                     (set (big @) Hi) ) ) )
            (zapZero R) ) ) ) )

# Divide big number (Knuth Vol.2, p.257)
(de div1 (A B (i1 . Rem))
   (let
      (R (save ZERO)  # Quotient
         P (boxNum (val (dig A)))
         U (link (push P NIL))  # Dividend 'u'
         V (link (push B NIL))  # Divisor 'v'
         V1 T
         V2 0  # Last cell
         M 0  # 'm'
         N 1  # 'n'
         D 0
         Q T )
      # Copy dividend
      (while (big? (setq A (val (big A))))
         (setq P
            (set (big P) (boxNum (val (dig A)))) )
         (inc 'M) )  # Calculate 'm'
      (unless (== A ZERO)
         (setq P (set (big P) (boxNum (int A))))
         (inc 'M) )
      # Copy divisor
      (if (cnt? B)
         (setq Q (set V (boxNum (int B))))
         (setq Q
            (set V (boxNum (val (dig B)))) )
         (while (big? (setq B (val (big B))))
            (setq
               V2 Q  # Keep last cell
               Q (set (big Q) (boxNum (val (dig B)))) )
            (dec 'M)  # Decrement 'm'
            (inc 'N) )  # Calculate 'n'
         (unless (== B ZERO)
            (setq
               V2 Q  # Keep last cell
               Q (set (big Q) (boxNum (int B))))
            (dec 'M)
            (inc 'N) )
         (when (lt0 M)
            (ret
               (if Rem
                  (zapZero (val U))
                  ZERO ) ) ) )
      (set (big P) (boxNum 0))
      (while (ge0 (val (dig Q)))  # Shift to max left position
         (twiceBig (val U))
         (twiceBig (val V))
         (inc 'D) )
      (setq V1 (val (dig Q)))
      (when V2
         (setq V2 (val (dig V2))) )
      (loop
         (let (X (val U)  U1 0  U2 0  U3 T)
            (let I M  # Index X -> 'u'
               (while (ge0 (dec 'I))
                  (setq X (val (big X))) ) )
            (let (I N  Y X)
               (loop
                  (setq
                     U3 U2
                     U2 U1
                     U1 (val (dig Y))
                     Y (val (big Y)) )
                  (? (lt0 (dec 'I))) ) )
            (let (Hi U1  Lo U2)  # 'r'
               (setq Q
                  (if (== U1 V1)  # 'u1' = 'v1'
                     -1  # 'q' = MAX
                     (div Hi Lo V1) ) )  # 'q' = 'r' / 'v1'
               (setq
                  Lo (sub Lo (mul Q V1))  # 'r' - 'q' * 'v1'
                  Hi (sub Hi @@@ @@) )
               (until Hi  # 'r' <= MAX  and
                  (let L (mul Q V2)  # 'q' * 'v2 '> [lo(r) u3]
                     (? (> Lo @@@))
                     (? (and (== Lo @@@) (>= U3 L))) )
                  (dec 'Q)
                  (setq   # Increment 'r' by 'v1'
                     Lo (add Lo V1)
                     Hi (+ Hi @@) ) )
               (let (Z X  Y (val V))
                  (set (dig Z)
                     (sub
                        (val (dig Z))
                        (mul Q (val (dig Y))) ) )
                  (setq Hi (+ @@@ @@))  # Borrow
                  (while (big? (setq Y (val (big Y))))  # More in 'v'
                     (setq Z (val (big Z)))
                     (set (dig Z) (sub (val (dig Z)) Hi))  # Subtract borrow
                     (setq Hi (- Hi Hi @@))  # New borrow
                     (set (dig Z)
                        (sub
                           (val (dig Z))
                           (mul Q (val (dig Y))) ) )
                     (setq Hi (- (sub Hi @@@ @@))) )
                  (when Hi  # Borrow
                     (setq Z (val (big Z)))
                     (set (dig Z) (sub (val (dig Z)) Hi))  # Subtract borrow
                     (when @@
                        (dec 'Q)
                        (when (or Rem M)
                           (setq Y (val V))
                           (set (dig X)  # 'x' += 'v'
                              (add (val (dig X)) (val (dig Y))) )
                           (let C @@
                              (loop
                                 (setq X (val (big X)))
                                 (? (cnt? (setq Y (val (big Y)))))
                                 (set (dig X)
                                    (add (val (dig X)) (val (dig Y)) C) )
                                 (setq C @@) )
                              (set (dig X) (+ (val (dig X)) C)) ) ) ) ) ) ) )
         (setq R (safe (consNum Q R)))
         (? (lt0 (dec 'M))) )
      (ifn Rem
         (zapZero R)
         (setq A (zapZero (val U)))
         (while D
            (setq A (half A))  # Shift right (destructive)
            (dec 'D) )
         A ) ) )

# Divide two (unsigned) numbers
(de divu (A B)
   (cond
      ((big? A) (div1 A B NO))
      ((big? B) ZERO)
      (T (cnt (/ (int A) (int B)))) ) )

# Remainder of two (unsigned) numbers
(de remu (A B)
   (cond
      ((big? A) (div1 A B YES))
      ((big? B) A)
      (T (cnt (% (int A) (int B)))) ) )

### Non-destructive signed primitives ###
(local) (incs decs adds subs)

# Increment a (signed) number
(de incs (A)
   (if (sign? A)
      (neg (subu (pos A) ONE))
      (addu A ONE) ) )

# Decrement a (signed) number
(de decs (A)
   (if (sign? A)
      (neg (addu (pos A) ONE))
      (subu A ONE) ) )

# Add two (signed) numbers
(de adds (A B)
   (ifn (sign? A)
      (ifn (sign? B)
         (addu A B)
         (subu A (pos B)) )
      (neg
         (ifn (sign? B)
            (subu (pos A) B)
            (addu (pos A) (pos B)) ) ) ) )

# Subtract to (signed) numbers
(de subs (A B)
   (ifn (sign? A)
      (ifn (sign? B)
         (subu A B)
         (addu A (pos B)) )
      (neg
         (ifn (sign? B)
            (addu (pos A) B)
            (subu (pos A) (pos B)) ) ) ) )

### Comparisons ###
(local) (cmpu cmpNum)

(de i64 cmpu (A B)
   (if (cnt? A)
      (cond
         ((or (big? B) (> B A)) -1)
         ((== B A) 0)
         (T +1) )
      # A is big
      (if (cnt? B)
         +1
         # Both are big
         (let (X 0  Y 0)
            (prog1
               (loop
                  (let (C (val (big A))  D (val (big B)))
                     (? (== C D)  # Tails equal
                        (loop
                           (setq
                              C (val (dig A))
                              D (val (dig B)) )
                           (? (> D C) -1)
                           (? (> C D) +1)
                           (? (=0 X) 0)
                           (let Z (val (big X))
                              (set (big X) A)  # Restore A
                              (setq A X  X Z) )
                           (let Z (val (big Y))
                              (set (big Y) B)  # Restore B
                              (setq B Y  Y Z) ) ) )
                     (? (cnt? C)  # End of A
                        (cond
                           ((or (big? D) (> D C)) -1)
                           ((== D C) 0)
                           (T +1) ) )
                     (? (cnt? D) +1)  # End of B
                     (set (big A) X)  # Reverse A
                     (setq X A  A C)
                     (set (big B) Y)  # Reverse B
                     (setq Y B  B D) ) )
               (while X  # Revert
                  (let Z (val (big X))
                     (set (big X) A)  # Restore A
                     (setq A X  X Z) )
                  (let Z (val (big Y))
                     (set (big Y) B)  # Restore B
                     (setq B Y  Y Z) ) ) ) ) ) ) )

(de i64 cmpNum (A B)
   (ifn (sign? A)
      (ifn (sign? B)
         (cmpu A B)
         +1 )
      (ifn (sign? B)
         -1
         (cmpu (pos B) (pos A)) ) ) )

### Formatting ###
(local) (symToNum fmtScl outScl fmtNum)

# Make number from symbol
(de symToNum (Name (i64 . Scl) (i8 . Sep) (i8 . Ign))
   (let
      (P (push 0 Name)  # [cnt name]
         Num (push ZERO NIL)  # Result
         Sign NO
         Frac NO
         B T )
      (until (> (setq B (symByte P)) (char " "))  # Skip white space
         (unless B  # None
            (ret 0) ) )
      (cond
         ((== B (char "+"))
            (goto 1) )
         ((== B (char "-"))
            (setq Sign YES)
            (: 1
               (unless (setq B (symByte P))
                  (ret 0) ) ) ) )
      (when (> (dec 'B (char "0")) 9)
         (ret 0) )
      (set (link Num T) (cnt (i64 B)))
      (while (setq B (symByte P))
         (? (and Frac (=0 Scl))
            (when (> (dec 'B (char "0")) 9)
               (ret 0) )
            (when (>= B 5)  # Round
               (set Num (addu (val Num) ONE)) )
            (while (setq B (symByte P))
               (when (> (dec 'B (char "0")) 9)
                  (ret 0) ) ) )
         (cond
            ((== B Sep)
               (when Frac
                  (ret 0) )
               (setq Frac YES) )
            ((<> B Ign)
               (when (> (dec 'B (char "0")) 9)
                  (ret 0) )
               (set Num
                  (addu
                     (tenfold (val Num))
                     (cnt (i64 B)) ) )
               (when Frac
                  (dec 'Scl) ) ) ) )
      (when Frac
         (while (ge0 (dec 'Scl))
            (set Num (tenfold (val Num))) ) )
      (setq Num (val Num))
      (if Sign (neg Num) Num) ) )

(de i64 fmtScl ((i64 . N) (i64 . Scl) (i8 . Sep) (i8 . Ign) (i64* . P))
   (when (> N 9)
      (setq Scl (fmtScl (/ N 10) Scl Sep Ign P))
      (cond
         ((=0 Scl) (byteSym Sep P))
         ((and Ign (gt0 Scl) (=0 (% Scl 3)))
            (byteSym Ign P) ) )
      (dec 'Scl)
      (setq N (% N 10)) )
   (byteSym (+ (i8 N) (char "0")) P)
   Scl )

(de i64 outScl ((i64 . N) (i64 . Scl) (i8 . Sep))
   (when (> N 9)
      (setq Scl (outScl (/ N 10) Scl Sep))
      (when (=0 Scl)
         (call $Put Sep) )
      (dec 'Scl)
      (setq N (% N 10)) )
   (call $Put (+ (i8 N) (char "0")))
   Scl )

# Format number to output, length, or symbol
(de fmtNum (Num (i64 . Scl) (i8 . Sep) (i8 . Ign) (i64* . P))
   (let (Sign (sign? Num)  Len (+ 19 17))  # Length of 'cnt' (60 bit) plus round up div/18
      # Calculate buffer size
      (let N (setq Num (& Num -9))  # Clear sign bit
         (until (cnt? N)  # Calculate length
            (inc 'Len 20)
            (setq N (val (big N))) ) )  # Add length of 'digit'
      (setq Len (/ Len 18))  # Divide by 18 (rounded), word count
      (let (Acc (b64 Len)  TopA Acc)
         # Build BCD
         (let (Inc (b64 Len)  TopI Inc)
            (set Acc 0  Inc 1)  # Init accumulator to 0 and incrementor to 1
            (loop
               (let (Dig Num  Mask 16)
                  (when (big? Num)  # and first digit and mask
                     (setq Dig (val (dig Num))  Mask 1) )
                  (loop
                     (when (& Dig Mask)  # Bit is set
                        # Add incrementor to accumulator
                        (let (A Acc  I Inc  C 0)  # Carry for BCD addition
                           (loop
                              (let N (+ (val A) (val I) C)  # Add BCDs and Carry
                                 (setq C
                                    (if (> 1000000000000000000 N)
                                       0
                                       (dec 'N 1000000000000000000)  # BCD overflow
                                       1 ) )
                                 (set A N) )
                              (? (> (inc 'I) TopI))
                              (when (> (inc 'A) TopA)
                                 (inc 'TopA)  # Extend accumulator
                                 (set A 0) ) )  # with 0
                           (when C  # BCD-Carry
                              (set (inc 'TopA) 1) ) ) )  # Extend accumulator with 1
                     # Shift incrementor left
                     (let (I Inc  C 0)
                        (loop
                           (let N (val I)
                              (setq C
                                 (if (> 1000000000000000000 (setq N (+ N N C)))  # Double digit
                                    0
                                    (dec 'N 1000000000000000000)  # BCD overflow
                                    1 ) )
                              (set I N) )
                           (? (> (inc 'I) TopI)) )
                        (when C  # BCD-Carry
                           (inc 'TopI)  # Extend incrementor
                           (set I 1) ) )  # with 1
                     (? (=0 (setq Mask (shl Mask 1)))) ) )
               (? (cnt? Num))
               (setq Num (val (big Num))) ) )
         (let (N (* (shr (- TopA Acc) 3) 18)  D (val TopA))  # Calculate length~1
            (cond
               (P  # Build symbol
                  (when Sign
                     (byteSym (char "-") P) )
                  (while (setq D (/ D 10))
                     (inc 'N) )
                  (when (lt0 (setq Scl (- N Scl)))
                     (byteSym (char "0") P)
                     (byteSym Sep P)
                     (while (> -1 Scl)
                        (inc 'Scl)
                        (byteSym (char "0") P) ) )
                  (setq Scl (fmtScl (val TopA) Scl Sep Ign P))  # Pack highest word
                  (while (>= (dec 'TopA) Acc)
                     (let (N (val TopA)  D 100000000000000000)
                        (loop
                           (cond
                              ((=0 Scl) (byteSym Sep P))
                              ((and Ign (gt0 Scl) (=0 (% Scl 3)))
                                 (byteSym Ign P) ) )
                           (dec 'Scl)
                           (byteSym (+ (i8 (/ N D)) (char "0")) P)
                           (setq N (% N D))
                           (? (== 1 (setq D (/ D 10)))) )
                        (byteSym (+ (i8 N) (char "0")) P) ) )
                  0 )
               ((== Scl -1)  # Calculate length
                  (loop
                     (inc 'N)
                     (? (=0 (setq D (/ D 10)))) )
                  (when Sign
                     (inc 'N) )
                  (cnt N) )
               (T  # Direct print
                  (when Sign
                     (call $Put (char "-")) )  # Output sign
                  (if (=0 Sep)
                     (outWord (val TopA))  # Output highest word
                     (while (setq D (/ D 10))
                        (inc 'N) )
                     (when (lt0 (setq Scl (- N Scl)))
                        (call $Put (char "0"))
                        (call $Put Sep)
                        (while (> -1 Scl)
                           (inc 'Scl)
                           (call $Put (char "0")) ) )
                     (setq Scl (outScl (val TopA) Scl Sep)) )
                  (while (>= (dec 'TopA) Acc)
                     (let (N (val TopA)  D 100000000000000000)
                        (loop
                           (when (and Sep (=0 Scl))
                              (call $Put Sep) )
                           (dec 'Scl)
                           (call $Put (+ (i8 (/ N D)) (char "0")))  # Output next digit
                           (setq N (% N D))
                           (? (== 1 (setq D (/ D 10)))) )
                        (call $Put (+ (i8 N) (char "0"))) ) )  # Output last digit
                  0 ) ) ) ) ) )

# (format 'num ['cnt ['sym1 ['sym2]]]) -> sym
# (format 'sym|lst ['cnt ['sym1 ['sym2]]]) -> num
(de _Format (Exe)
   (let
      (X (cdr Exe)
         A (save (eval (++ X)))
         Y (eval (++ X))
         Scl (if (nil? Y) 0 (xCnt Exe Y))
         Sep (i8 (char "."))
         Ign (i8 0) )
      (when (pair X)
         (setq Sep (firstByte (needSymb Exe (eval (++ X)))))
         (when (pair X)
            (setq Ign (firstByte (needSymb Exe (eval (car X))))) ) )
      (cond
         ((num? A)
            (let P (push 4 NIL ZERO NIL)  # [cnt last name link]
               (link (ofs P 2))
               (fmtNum A Scl Sep Ign P)
               (consStr (val 3 P)) ) )
         ((sym? A)
            (cond
               ((sym? (val (tail A))) $Nil)
               ((=0 (symToNum (name @) Scl Sep Ign)) $Nil)
               (T @) ) )
         (T
            (if
               (symToNum
                  (let P (push 4 NIL ZERO NIL)  # [cnt last name link]
                     (link (ofs P 2))
                     (pack A P)
                     (val 3 P) )
                  Scl Sep Ign )
               @
               $Nil ) ) ) ) )

### Arithmetics ###
# (+ 'num ..) -> num
(de _Add (Exe)
   (let X (cdr Exe)
      (if (nil? (eval (car X)))
         @
         (save -ZERO
            (let R (link (push (needNum Exe @) NIL))
               (loop
                  (? (atom (shift X)) (val R))
                  (? (nil? (eval (car X))) @)
                  (safe (needNum Exe @))
                  (set R (adds (val R) @)) ) ) ) ) ) )

# (- 'num ..) -> num
(de _Sub (Exe)
   (let (X (cdr Exe)  N (eval (++ X)))
      (if (nil? N)
         N
         (needNum Exe N)
         (if (atom X)  # Unary minus
            (neg N)
            (save -ZERO
               (let R (link (push N NIL))
                  (loop
                     (? (nil? (eval (++ X))) @)
                     (safe (needNum Exe @))
                     (set R (subs (val R) @))
                     (? (atom X) (val R)) ) ) ) ) ) ) )

# (inc 'num) -> num
# (inc 'var ['num]) -> num
(de _Inc (Exe)
   (let X (cdr Exe)
      (cond
         ((nil? (eval (car X))) @)
         ((num? @) (incs @))
         (T
            (let Y (save (chkVar Exe @))  # Symbol or cell
               (when (and (sym? Y) (sym? (val (tail Y))))  # External
                  (dbTouch Exe Y) )
               (if (atom (shift X))
                  (if (nil? (val Y))
                     @
                     (set Y (incs (needNum Exe @))) )
                  (let (D (save (eval (car X)))  N (val Y))
                     (cond
                        ((nil? N) N)
                        ((nil? D) D)
                        (T (set Y (adds (needNum Exe N) (needNum Exe D)))) ) ) ) ) ) ) ) )

# (dec 'num) -> num
# (dec 'var ['num]) -> num
(de _Dec (Exe)
   (let X (cdr Exe)
      (cond
         ((nil? (eval (car X))) @)
         ((num? @) (decs @))
         (T
            (let Y (save (chkVar Exe @))  # Symbol or cell
               (when (and (sym? Y) (sym? (val (tail Y))))  # External
                  (dbTouch Exe Y) )
               (if (atom (shift X))
                  (if (nil? (val Y))
                     @
                     (set Y (decs (needNum Exe @))) )
                  (let (D (save (eval (car X)))  N (val Y))
                     (cond
                        ((nil? N) N)
                        ((nil? D) D)
                        (T (set Y (subs (needNum Exe N) (needNum Exe D)))) ) ) ) ) ) ) ) )

# (* 'num ..) -> num
(de _Mul (Exe)
   (let X (cdr Exe)
      (if (nil? (eval (car X)))
         @
         (save -ZERO
            (let
               (Sign (sign? (needNum Exe @))
                  R (link (push (pos @) NIL)) )
               (loop
                  (? (atom (shift X))
                     (let N (val R)
                        (if Sign (neg N) N) ) )
                  (let N (eval (car X))
                     (? (nil? N) N)
                     (? (== N ZERO) N)
                     (when (sign? (needNum Exe N))
                        (setq Sign (not Sign)  N (pos N)) )
                     (safe N)
                     (set R (mulu (val R) N)) ) ) ) ) ) ) )

# (*/ 'num1 ['num2 ..] 'num3) -> num
(de _MulDiv (Exe)
   (let X (cdr Exe)
      (if (nil? (eval (car X)))
         @
         (save -ZERO
            (let
               (Sign (sign? (needNum Exe @))
                  R (link (push (pos @) NIL)) )
               (shift X)
               (loop
                  (let N (eval (car X))
                     (? (nil? N) N)
                     (when (sign? (needNum Exe N))
                        (setq Sign (not Sign)  N (pos N)) )
                     (safe N)
                     (? (atom (shift X))
                        (when (== N ZERO)
                           (divErr Exe) )
                        (let Half (save (shru N))
                           (setq N
                              (divu  # Divide by last arg
                                 (set R (addu (val R) Half))  # Round
                                 N ) ) )
                        (if Sign (neg N) N) )
                     (? (== N ZERO) N)
                     (set R (mulu (val R) N)) ) ) ) ) ) ) )

# (/ 'num ..) -> num
(de _Div (Exe)
   (let X (cdr Exe)
      (if (nil? (eval (car X)))
         @
         (save -ZERO
            (let
               (Sign (sign? (needNum Exe @))
                  R (link (push (pos @) NIL)) )
               (loop
                  (? (atom (shift X))
                     (let N (val R)
                        (if Sign (neg N) N) ) )
                  (let N (eval (car X))
                     (? (nil? N) N)
                     (when (== N ZERO)
                        (divErr Exe) )
                     (when (sign? (needNum Exe N))
                        (setq Sign (not Sign)  N (pos N)) )
                     (safe N)
                     (set R (divu (val R) N)) ) ) ) ) ) ) )

# (% 'num ..) -> num
(de _Rem (Exe)
   (let X (cdr Exe)
      (if (nil? (eval (car X)))
         @
         (save -ZERO
            (let
               (Sign (sign? (needNum Exe @))
                  R (link (push (pos @) NIL)) )
               (loop
                  (? (atom (shift X))
                     (let N (val R)
                        (if Sign (neg N) N) ) )
                  (let N (eval (car X))
                     (? (nil? N) N)
                     (when (== N ZERO)
                        (divErr Exe) )
                     (set R
                        (remu
                           (val R)
                           (safe (pos (needNum Exe N))) ) ) ) ) ) ) ) ) )

# (>> 'cnt 'num) -> num
(de _Shr (Exe)
   (let
      (X (cdr Exe)
         N (evCnt Exe X)
         Y (eval (cadr X)) )
      (if
         (or
            (=0 N)
            (nil? Y)
            (== ZERO (needNum Exe Y)) )
         Y
         (let Sign (sign? Y)
            (setq Y (save (pos Y)))
            (cond
               ((gt0 N)
                  (while (and (big? Y) (>= N 64))  # Large shift count
                     (setq Y (val (big Y)))  # Discard 64 bits
                     (unless (dec 'N 64)
                        (goto 9) ) )
                  (setq Y (safe (shru Y)))  # Non-destructive
                  (while (dec 'N)
                     (setq Y (half Y)) ) )  # Shift right (destructive)
               (T
                  (while (>= -64 N)
                     (setq Y (safe (consNum 0 Y)))
                     (unless (inc 'N 64)
                        (goto 9) ) )
                  (setq Y (safe (shlu Y)))  # Non-destructive
                  (while (inc 'N)
                     (setq Y (safe (twice Y))) ) ) )  # Shift left (destructive)
            (: 9
               (if Sign (neg Y) Y) ) ) ) ) )

# (rev 'cnt1 'cnt2) -> cnt
(de _Rev (Exe)
   (let
      (X (cdr Exe)
         C (evCnt Exe X)
         N (evCnt Exe (cdr X))
         R 0 )
      (loop
         (setq
            R (+ R R (& N 1))
            N (shr N 1) )
         (? (=0 (dec 'C))) )
      (cnt R) ) )

# (lt0 'any) -> num | NIL
(de _Lt0 (Exe)
   (if (and (num? (eval (cadr Exe))) (sign? @))
      @
      $Nil ) )

# (le0 'any) -> num | NIL
(de _Le0 (Exe)
   (if
      (and
         (num? (eval (cadr Exe)))
         (or (== @ ZERO) (sign? @)) )
      @
      $Nil ) )

# (ge0 'any) -> num | NIL
(de _Ge0 (Exe)
   (if
      (and
         (num? (eval (cadr Exe)))
         (not (sign? @)) )
      @
      $Nil ) )

# (gt0 'any) -> num | NIL
(de _Gt0 (Exe)
   (if
      (and
         (num? (eval (cadr Exe)))
         (<> @ ZERO)
         (not (sign? @)) )
      @
      $Nil ) )

# (abs 'num) -> num
(de _Abs (Exe)
   (if (nil? (eval (cadr Exe)))
      @
      (pos (needNum Exe @)) ) )

### Bit operations ###
# (bit? 'num ..) -> num | NIL
(de _BitQ (Exe)
   (let
      (X (cdr Exe)
         N (save (pos (needNum Exe (eval (++ X))))) )
      (loop
         (? (atom X) N)  # All matched
         (let Y (eval (++ X))
            (? (nil? Y) Y)  # Abort with NIL
            (setq Y (pos (needNum Exe Y)))
            (let Z N
               (while (big? Z)
                  (unless (big? Y)
                     (ret $Nil) )
                  (let A (val (dig Z))
                     (unless (== A (& A (val (dig Y))))
                        (ret $Nil) ) )
                  (setq
                     Y (val (big Y))
                     Z (val (big Z)) ) )
               (when (big? Y)
                  (setq Z (int Z)  Y (val (dig Y))) )
               (? (<> Z (& Y Z)) $Nil) ) ) ) ) )

# (& 'num ..) -> num
(de _BitAnd (Exe)
   (let X (cdr Exe)
      (if (nil? (eval (car X)))
         @
         (save -ZERO
            (let R (link (push (pos (needNum Exe @)) NIL))
               (loop
                  (? (atom (shift X)) (val R))
                  (? (nil? (eval (car X))) @)
                  (safe (needNum Exe @))
                  (set R (andu (val R) (pos @))) ) ) ) ) ) )

# (| 'num ..) -> num
(de _BitOr (Exe)
   (let X (cdr Exe)
      (if (nil? (eval (car X)))
         @
         (save -ZERO
            (let R (link (push (pos (needNum Exe @)) NIL))
               (loop
                  (? (atom (shift X)) (val R))
                  (? (nil? (eval (car X))) @)
                  (safe (needNum Exe @))
                  (set R (oru (val R) (pos @))) ) ) ) ) ) )

# (x| 'num ..) -> num
(de _BitXor (Exe)
   (let X (cdr Exe)
      (if (nil? (eval (car X)))
         @
         (save -ZERO
            (let R (link (push (pos (needNum Exe @)) NIL))
               (loop
                  (? (atom (shift X)) (val R))
                  (? (nil? (eval (car X))) @)
                  (safe (needNum Exe @))
                  (set R (xoru (val R) (pos @))) ) ) ) ) ) )

# (sqrt 'num ['flg|num]) -> num
(de _Sqrt (Exe)
   (let X (cdr Exe)
      (if (nil? (eval (car X)))
         @
         (when (sign? (needNum Exe @))
            (argErr Exe @) )
         (let (Y (save @)  Z (save (eval (cadr X))))
            (when (num? Z)
               (setq Y (safe (mulu Y Z))) )
            (prog1
               (if (cnt? Y)
                  (let (M (hex "400000000000000")  R 0)
                     (setq Y (int Y))
                     (loop
                        (let N (+ R M)
                           (when (>= Y N)
                              (dec 'Y N)
                              (setq R (+ N M)) ) )
                        (setq R (shr R 1))
                        (? (=0 (setq M (shr M 2)))) )
                     (or (nil? Z) (>= R Y) (inc 'R))  # Round
                     (cnt R) )
                  (let
                     (M (consNum 0 ONE)
                        M* (link (push M NIL))
                        R (link (push ZERO NIL))
                        C (boxNum (val (dig Y)))  # Copy number
                        C* (link (push C NIL)) )
                     (while (big? (setq Y (val (big Y))))
                        (setq C
                           (set (big C) (boxNum (val (dig Y)))) )
                        (setq M (set M* (consNum 0 M))) )
                     (set (big C) Y)
                     (setq Y (safe (val C*)))
                     (while (le0 (cmpu M Y))
                        (twiceBig M)
                        (twiceBig M) )
                     (loop
                        (let N (set C* (addu (val R) M))
                           (when (ge0 (cmpu Y N))
                              (setq Y (safe (subu Y N)))
                              (set R (addu N M)) ) )
                        (set R (half (val R)))
                        (?
                           (==
                              ZERO
                              (setq M (set M* (half (half M)))) ) ) )
                     (setq R (val R))
                     (if (or (nil? Z) (ge0 (cmpu R Y)))
                        R
                        (addu R ONE) ) ) ) ) ) ) ) )  # Round


### Random generator ###
(local) initSeed

(de initSeed (X)
   (let C 0
      (while (pair X)
         (inc 'C (initSeed (++ X))) )
      (unless (nil? X)
         (unless (num? X)  # Need number
            (setq X (name (& (val (tail X)) -9))) )
         (if (cnt? X)
            (inc 'C (shr X 3))  # Keep sign
            (when (sign? X)
               (inc 'C)
               (setq X (pos X)) )
            (loop
               (inc 'C (val (dig X)))
               (? (cnt? (setq X (val (big X))))) )
            (inc 'C (int X)) ) )
      C ) )

# (seed 'any) -> cnt
(de _Seed (Exe)
   (let N (mul 6364136223846793005 (initSeed (eval (cadr Exe))))
      (set $SeedL N  $SeedH @@@)
      (| (& (shr N (- 32 3)) -8) 2) ) )  # Get higher 32 bits

# (hash 'any) -> cnt
(de _Hash (Exe)
   (let (N (initSeed (eval (cadr Exe)))  C 64  R 0)
      (loop
         (when (& (x| N R) 1)
            (setq R (x| R (hex "14002"))) )  # CRC Polynom x**16 + x**15 + x**2 + 1
         (setq N (shr N 1)  R (shr R 1))
         (? (=0 (dec 'C))) )
      (cnt (inc R)) ) )

# (rand ['cnt1 'cnt2] | ['T]) -> cnt | flg
(de _Rand (Exe)
   (let
      (X (cdr Exe)
         Y (eval (++ X))
         N (add (mul 6364136223846793005 (val $SeedL)) 1) )
      (set $SeedL N  $SeedH (+ @@@ @@))
      (cond
         ((nil? Y)
            (| (& (shr N (- 32 3)) -8) 2) )  # Get higher 32 bits
         ((t? Y)
            (add N N)
            (if @@ Y $Nil) )
         (T
            (when (sign? (needCnt Exe Y))
               (argErr Exe Y) )
            (let A (int Y)
               (when (sign? (needCnt Exe (setq Y (eval (car X)))))
                  (argErr Exe Y) )
               (let B (inc (int Y))  # Seed % (cnt2 + 1 - cnt1) + cnt1
                  (when (>= A B)
                     (argErr Exe Y) )
                  (setq N
                     (+
                        (%
                           (shr (val $SeedH) (val $SeedL) 32)  # Get middle 64 bits
                           (- B A) )
                        A ) )
                  (if (lt0 N)
                     (sign (cnt (- N)))
                     (cnt N) ) ) ) ) ) ) )
pil21/src/sym.l0000644000000000000000000017217214760115501010461 0ustar  # 27feb25 Software Lab. Alexander Burger

(symbols '(llvm))

(local) (bufSize pathSize bufString pathString)

(de i64 bufSize (Nm)
   (let N 1
      (while (big? Nm)
         (inc 'N 8)
         (setq Nm (val (big Nm))) )
      (setq Nm (int Nm))
      (while Nm
         (inc 'N)
         (setq Nm (shr Nm 8)) )
      N ) )

(de i64 pathSize (Nm)
   (let
      (Len (bufSize Nm)
         N (if (cnt? Nm) (int @) (val (dig @)))
         B (i8 N) )
      (cond
         ((or
               (== B (char "@"))
               (and
                  (== B (char "+"))
                  (== (i8 (shr N 8)) (char "@")) ) )
            (+ (val $PilLen) (dec Len)) )
         ((or
               (== B (char "~"))
               (and
                  (== B (char "+"))
                  (== (i8 (shr N 8)) (char "~")) ) )
            (+ (val $UsrLen) (dec Len)) )
         (T Len) ) ) )

(de i8* bufString (Nm (i8* . P))
   (let Q (push 0 Nm)  # [cnt name]
      (prog1 P
         (while (set P (symByte Q))
            (inc 'P) ) ) ) )

(de i8* pathString (Nm (i8* . P))
   (let (Q (push 0 Nm)  B (symByte Q))  # [cnt name]
      (prog1 P
         (when (== B (char "+"))
            (set P B)
            (inc 'P)
            (setq B (symByte Q)) )
         (case B
            ((char "@")
               (when (val $PilLen)
                  (memcpy P (val $PilHome) @)
                  (inc 'P @) ) )
            ((char "~")
               (when (val $UsrLen)
                  (memcpy P (val $UsrHome) @)
                  (inc 'P @) ) )
            (T
               (set P B)
               (inc 'P) ) )
         (while (set P (symByte Q))
            (inc 'P) ) ) ) )

(local) (mkChar mkStr firstByte firstChar isBlank)

(de mkChar ((i32 . C))
   (consStr
      (cnt
         (cond
            ((>= 127 C) (i64 C))  # Single byte
            ((== TOP C) (hex "FF"))  # Infinite
            ((> (hex "800") C)  # Double-byte
               (i64
                  (|
                     (| (hex "C0") (& (shr C 6) (hex "1F")))  # 10xxxxx 10xxxxxx
                     (shl (| (hex "80") (& C (hex "3F"))) 8) ) ) )
            ((> (hex "10000") C)  # Three bytes
               (i64
                  (|
                     (|
                        (| (hex "E0") (& (shr C 12) (hex "0F")))  # 1110xxxx 10xxxxxx 10xxxxxx
                        (shl (| (hex "80") (& (shr C 6) (hex "3F"))) 8) )
                     (shl (| (hex "80") (& C (hex "3F"))) 16) ) ) )
            (T
               (|
                  (i64
                     (|
                        (|
                           (| (hex "F0") (& (shr C 18) (hex "07")))  # 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
                           (shl (| (hex "80") (& (shr C 12) (hex "3F"))) 8) )
                        (shl (| (hex "80") (& (shr C 6) (hex "3F"))) 16) ) )
                  (shl
                     (| (hex "80") (& (i64 C) (hex "3F")))
                     24 ) ) ) ) ) ) )

(de mkStr ((i8* . Str))
   (if Str
      (let P (push 4 NIL ZERO NIL)  # [cnt last name link]
         (link (ofs P 2) T)
         (while (val Str)
            (byteSym @ P)
            (inc 'Str) )
         (consStr (val 3 P)) )
      $Nil ) )

(de mkStrE ((i8* . Str) (i8* . End))
   (let P (push 4 NIL ZERO NIL)  # [cnt last name link]
      (link (ofs P 2) T)
      (loop
         (? (== Str End))
         (? (=0 (val Str)))
         (byteSym @ P)
         (inc 'Str) )
      (consStr (val 3 P)) ) )

(de i8 firstByte (Sym)
   (i8
      (cond
         ((nil? Sym) 0)
         ((sym? (val (tail Sym))) 0)
         ((cnt? (name @)) (int @))
         (T (val (dig @))) ) ) )

(de i32 firstChar (Sym)
   (cond
      ((nil? Sym) 0)
      ((sym? (val (tail Sym))) 0)  # External symbol
      (T (symChar (push 0 (name @)))) ) )  # Else get name

(de i1 isBlank (X)
   (or
      (nil? X)
      (and
         (symb? X)
         (not (sym? (val (tail X))))
         (let P (push 0 (name @))  # [cnt name]
            (loop
               (? (=0 (symByte P)) YES)
               (? (> @ 32) NO) ) ) ) ) )

# Build external symbol name
(local) extNm

(de extNm ((i32 . File) (i64 . Obj))
   (cnt
      (|
         (& Obj (hex "FFFFF"))  # Lowest 20 bits
         (|
            (shl (i64 (& File (hex "FF"))) 20)  # Lower 8 bits
            (|
               (shl
                  (& (setq Obj (shr Obj 20)) (hex "FFF"))  # Middle 12 bits
                  28 )
               (|
                  (shl (i64 (shr File 8)) 40)  # Upper 8 bits
                  (shl (shr Obj 12) 48) ) ) ) ) ) )  # Highest 10 bits

(local) (objFile objId packAO packOct packExtNm pack chopExtNm)

# Get file number from external symbol name
(de i32 objFile (Name)
   (|
      (& (i32 (setq Name (shr Name 24))) (hex "FF"))  # Low 8 bits
      (& (i32 (shr Name 12)) (hex "FF00")) ) )  # High 8 bits

# Get object ID from external symbol name
(de i64 objId (Name)
   (|
      (|
         (& (setq Name (shr Name 4)) (hex "FFFFF"))  # Lowest 20 bits
         (& (setq Name (shr Name 8)) (hex "FFF00000")) )  # Middle 12 bits
      (& (shr Name 8) (hex "3FF00000000")) ) )  # Highest 10 bits

# Pack external symbol name
(de void packAO ((i32 . File) (i64* . P))
   (when (> File 15)
      (packAO (shr File 4) P) )  # Divide by 16
   (byteSym (+ (& (i8 File) 15) (char "@")) P) )  # Make ASCII letter

(de void packOct ((i64 . Obj) (i64* . P))
   (when (> Obj 7)
      (packOct (shr Obj 3) P) )  # Divide by 8
   (byteSym (+ (& (i8 Obj) 7) (char "0")) P) )  # Make ASCII digit

(de void packExtNm (Name (i64* . P))
   (when (objFile Name)
      (packAO @ P) )
   (packOct (objId Name) P) )

# General pack
(de void pack (X (i64* . P))
   (when (pair X)
      (stkChk 0)
      (loop
         (pack (++ X) P)
         (? (atom X)) ) )
   (cond
      ((nil? X))
      ((num? X) (fmtNum X 0 0 0 P))
      ((sym? (val (tail X)))
         (byteSym (char "{") P)
         (packExtNm (name (& @ -9)) P)
         (byteSym (char "}") P) )
      (T
         (let Q (push 0 (name @))  # [cnt name]
            (while (symByte Q)
               (byteSym @ P) ) ) ) ) )

# Chop external symbol name
(de chopExtNm (Name)
   (let (R (link (push $Nil NIL))  N (objId Name))
      (loop
         (let A (+ (& N 7) (char "0"))  # Make ASCII digit
            (when (setq N (shr N 3))
               (setq A
                  (|
                     (shl A 8)
                     (+ (& N 7) (char "0")) ) )  # Second octal digit
               (when (setq N (shr N 3))
                  (setq A
                     (|
                        (shl A 8)
                        (+ (& N 7) (char "0")) ) ) ) )  # Third octal digit
            (set R
               (cons (consSym (cnt A) 0) (val R)) ) )
         (? (=0 (setq N (shr N 3)))) )
      (when (setq N (objFile Name))
         (let F (i32 0)
            (loop
               (setq F
                  (| F (+ (& N 15) (char "@"))) )  # Make ASCII letter
               (? (=0 (setq N (shr N 4))))
               (setq F (shl F 8)) )
            (set R
               (cons (consStr (cnt (i64 F))) (val R)) ) ) )
      (pop R) ) )

### Interning ###
(local) (cmpLong isIntern isLstIntern findSym)

# Compare long names
(de i64 cmpLong (X Y)
   (loop
      (? (sub (val (dig X)) (val (dig Y)))
         (if @@ -1 +1) )
      (setq X (val (big X))  Y (val (big Y)))
      (? (cnt? X)
         (cond
            ((big? Y) -1)
            ((== Y X) 0)
            ((> Y X) -1)
            (T +1) ) )
      (? (cnt? Y) +1) ) )

# Is name interned?
(de isIntern (Name Tree)
   (if (cnt? Name)  # Short name
      (let X (car Tree)  # First tree
         (loop
            (? (atom X) 0)  # Empty
            (let (S (car X)  Nm (name (val (tail S))))
               (? (== Name Nm) S)
               (setq X
                  (if (> Name Nm)  # Symbol is smaller
                     (cddr X)
                     (cadr X) ) ) ) ) )
      # Long name
      (let X (cdr Tree)  # Second tree
         (loop
            (? (atom X) 0)  # Empty
            (let (S (car X)  Nm (name (val (tail S))))
               (? (=0 (cmpLong Nm Name)) S)
               (setq X
                  (if (lt0 @)  # Symbol is smaller
                     (cddr X)
                     (cadr X) ) ) ) ) ) ) )

(de isLstIntern (Name Lst)
   (loop
      (? (atom Lst) 0)
      (? (isIntern Name (cdar (car Lst))) @)
      (shift Lst) ) )

(de i1 findSym (Sym Name Lst)
   (loop
      (? (atom Lst) NO)
      (? (== Sym (isIntern Name (cdar (car Lst)))) YES)
      (shift Lst) ) )

(local) (intern1 intern2 internRight internLeft)

(inline intern1 (Sym Val Name Node More)
   (if (isLstIntern Name More)
      @
      (unless Sym  # New symbol
         (setq Sym (consSym Name Val)) )
      (set Node (cons Sym $Nil))
      Sym ) )

(inline intern2 (Sym Val Name Node More)
   (if (isLstIntern Name More)
      @
      (unless Sym  # New symbol
         (setq Sym (consSym Name Val)) )
      (set 2 Node (cons Sym $Nil))
      Sym ) )

(inline internRight (Sym Val Name Node More)
   (if (isLstIntern Name More)
      @
      (unless Sym  # New symbol
         (setq Sym (consSym Name Val)) )
      (set 2 Node (cons $Nil (cons Sym $Nil)))
      Sym ) )

(inline internLeft (Sym Val Name Node More)
   (if (isLstIntern Name More)
      @
      (unless Sym  # New symbol
         (setq Sym (consSym Name Val)) )
      (set 2 Node (cons (cons Sym $Nil) $Nil))
      Sym ) )

(local) (intern requestSym extern delNode unintern)

# Intern a symbol/name
(de intern (Sym Val Name Tree More (i1 . Rpl))
   (if (cnt? Name)  # Short name
      (let X (car Tree)  # First tree
         (if (pair X)  # Not empty
            (loop
               (let (S (car X)  Nm (name (val (tail S))))
                  (? (== Name Nm)  # Found name
                     (if Rpl
                        (set X Sym)  # Replace with argument symbol
                        S ) )  # Return found symbol
                  (let Y (cdr X)  # Get link cell
                     (cond
                        ((> Name Nm)  # Symbol is smaller
                           (? (atom Y) (internRight Sym Val Name X More))  # No link yet
                           (? (atom (setq Y (cdr (setq X Y))))
                              (intern2 Sym Val Name X More) ) )
                        (T  # Symbol is greater
                           (? (atom Y) (internLeft Sym Val Name X More))  # No link yet
                           (? (atom (setq Y (car (setq X Y))))
                              (intern1 Sym Val Name X More) ) ) )
                     (setq X Y) ) ) )
            # Empty
            (intern1 Sym Val Name Tree More) ) )
      # Long name
      (let X (cdr Tree)  # Second tree
         (if (pair X)  # Not empty
            (loop
               (let (S (car X)  Nm (name (val (tail S))))
                  (? (=0 (cmpLong Nm Name))  # Found name
                     (if Rpl
                        (set X Sym)  # Replace with argument symbol
                        S ) )  # Return found symbol
                  (let Y (cdr X)  # Get link cell
                     (cond
                        ((lt0 @)  # Symbol is smaller
                           (? (atom Y) (internRight Sym Val Name X More))  # No link yet
                           (? (atom (setq Y (cdr (setq X Y))))
                              (intern2 Sym Val Name X More) ) )
                        (T  # Symbol is greater
                           (? (atom Y) (internLeft Sym Val Name X More))  # No link yet
                           (? (atom (setq Y (car (setq X Y))))
                              (intern1 Sym Val Name X More) ) ) )
                     (setq X Y) ) ) )
            # Empty
            (intern2 Sym Val Name Tree More) ) ) ) )

(de requestSym (Name)
   (if (isIntern Name $PrivT)
      @
      (let L (val $Intern)
         (intern 0 $Nil Name
            (cdar (car L))
            (cdr L)
            NO ) ) ) )

# Intern an external symbol
(de extern (Name)
   (need3)  # Reserve 3 cells
   (let (X (val $Extern)  C 0  Sym T)
      (loop
         (inc 'C)  # Next level
         (setq Sym (car X))  # Next symbol
         (let Nm
            (&
               (name (& (val (tail Sym)) -9))
               (hex "3FFFFFFFFFFFFFF7") )  # Mask status and extern bits
            (? (== Nm Name))  # Found
            (let Y (cdr X)  # Get link cell
               (cond
                  ((> Name Nm)  # Symbol is smaller
                     (? (atom Y)  # No link yet
                        (set 2 X
                           (cons $Nil (cons (setq Sym (consExt Name)) $Nil)) ) )
                     (? (atom (setq Y (cdr (setq X Y))))
                        (set 2 X
                           (cons (setq Sym (consExt Name)) $Nil) ) ) )
                  (T  # Symbol is greater
                     (? (atom Y)  # No link yet
                        (set 2 X
                           (cons (cons (setq Sym (consExt Name)) $Nil) $Nil) ) )
                     (? (atom (setq Y (car (setq X Y))))
                        (set X
                           (cons (setq Sym (consExt Name)) $Nil) ) ) ) )
               (setq X Y) ) ) )
      (setq C (shr C 1))  # Half depth
      (when (> (shl 1 C) (val $ExtCnt))  # 2 ** (C/2)
         (setq X (val $Extern))
         (let N (val $ExtSkip)  # Levels to skip
            (if (> (inc 'N) C)  # Beyond half depth
               (set $ExtSkip 0)  # Don't skip
               (set $ExtSkip N)
               (loop  # Skip
                  (setq X
                     (if
                        (>
                           Name
                           (&
                              (name (& (val (tail (++ X))) -9))
                              (hex "3FFFFFFFFFFFFFF7") ) )
                        (cdr X)
                        (car X) ) )
                  (? (=0 (dec 'C))) ) ) )
         (loop  # Pivot
            (let
               (Nm
                  (&
                     (name (& (val (tail (car X))) -9))
                     (hex "3FFFFFFFFFFFFFF7") )
                  Y (cdr X) )
               (? (== Nm Name))  # Done
               (if (> Name Nm)  # Symbol is smaller
                  (let Z (cdr Y)  # Get right node
                     (? (atom (cdr Z)))
                     (xchg Z X)  # Pivot left
                     (setq Z (cdr Z)  X (cdr Z))
                     (set  # Rotate pointers
                        2 Z (val Z)
                        Z (val Y)
                        Y (cdr Y)
                        2 Y X) )
                  (let Z (car Y)  # Get left node
                     (? (atom (cdr Z)))
                     (xchg Z X)  # Pivot right
                     (setq Z (cdr Z)  X (val Z))
                     (set  # Rotate pointers
                        Z (cdr Z)
                        2 Z (cdr Y)
                        2 Y (val Y)
                        Y X) ) ) ) ) )
      Sym ) )

(de void delNode (X P)
   (let Y (cdr X)  # Subtrees
      (cond
         ((atom (car Y))  # No left branch
            (set P (cdr Y)) )  # Use right branch
         ((atom (cdr Y))  # No right branch
            (set P (car Y)) )  # Use left branch
         ((atom (car (setq P (cdr (shift Y)))))  # Y on right branch, P on sub-branches
            (set  # No left sub-branch
               X (car Y)  # Insert right sub-branch
               2 (cdr X) (cdr P) ) )
         (T
            (setq P (car P))  # Left sub-branch
            (loop
               (let Z (cdr P)  # More left branches
                  (? (atom (car Z))
                     (set
                        X (car P)  # Insert left sub-branch
                        (cdr Y) (cdr Z) ) )
                  (setq Y P  P (car Z)) ) ) ) ) ) )  # Go down left

(de void unintern (Sym Name P)
   (if (cnt? Name)  # Short name
      (loop  # First tree
         (let X (car P)  # Next node
            (? (atom X))  # Empty
            (let (S (car X)  Nm (name (val (tail S))))
               (? (== Name Nm)
                  (when (== S Sym)  # Correct symbol
                     (delNode X P) ) )
               (? (atom (shift X)))
               (setq P
                  (if (> Name Nm) (ofs X 1) X) ) ) ) )
      # Long name
      (setq P (ofs P 1))  # Second tree
      (loop
         (let X (car P)  # Next node
            (? (atom X))  # Empty
            (let
               (S (car X)
                  Nm (name (val (tail S)))
                  I (cmpLong Nm Name) )
               (? (=0 I)
                  (when (== S Sym)  # Correct symbol
                     (delNode X P) ) )
               (? (atom (shift X)))
               (setq P
                  (if (lt0 I) (ofs X 1) X) ) ) ) ) ) )

# (name 'sym) -> sym
(de _Name (Exe)
   (let Tail (val (tail (needSymb Exe (eval (cadr Exe)))))
      (if (sym? Tail)  # External
         (let P (push 4 NIL ZERO NIL)  # [cnt last name link]
            (link (ofs P 2) T)
            (packExtNm (name (& Tail -9)) P)
            (consStr (val 3 P)) )
         (consStr (name Tail)) ) ) )

# (nsp 'sym) -> sym
(de _Nsp (Exe)
   (let Sym (needSymb Exe (eval (cadr Exe)))
      (if (sym? (val (tail Sym)))
         $Nil
         (let Nm (name @)
            (if (== Sym (isIntern Nm $PrivT))  # Private?
               $priv
               (let Lst (val $Intern)  # Search namespaces
                  (loop
                     (? (atom Lst) $Nil)
                     (let Nsp (car Lst)
                        (? (== Sym (isIntern Nm (cdar Nsp))) Nsp) )
                     (shift Lst) ) ) ) ) ) ) )

# (sp? 'any) -> flg
(de _SpQ (Exe)
   (if (isBlank (eval (cadr Exe)))
      $T
      $Nil ) )

# (pat? 'any) -> sym | NIL
(de _PatQ (Exe)
   (let X (eval (cadr Exe))
      (if (and (symb? X) (== (firstChar X) (char "@")))
         X
         $Nil ) ) )

# (fun? 'any) -> any
(de _FunQ (Exe)
   (if (funq (eval (cadr Exe)))
      @
      $Nil ) )

# (getd 'any) -> fun | NIL
(de _Getd (Exe)
   (let (X (eval (cadr Exe))  V T)
      (cond
         ((not (symb? X)) $Nil)
         ((funq (setq V (val X))) V)
         ((and (nil? V) (sharedLib X)) (val X))
         (T $Nil) ) ) )

### Namespaces ###
(local) consTree

# Build sorted list from tree
(de consTree (P Lst)
   (if (atom P)
      Lst
      (let
         (Q (link (push NIL NIL))
            Tos (link (push -ZERO NIL)))
         (loop
            (loop
               (let X (cdr P)  # Get subtrees
                  (? (atom (cdr X)))  # Right subtree
                  (let Y P  # Go right
                     (setq P @)  # Invert tree
                     (set 2 X (val Tos))
                     (set Tos Y) ) ) )
            (set Q P)  # Save tree
            (loop
               (setq Lst (cons (car P) Lst))  # Cons symbol
               (let X (cdr P)
                  (? (pair (car X))  # Left subtree
                     (let Y P  # Go left
                        (setq P @)  # Invert tree
                        (set X (val Tos))
                        (set Tos (| Y 8))  # First visit
                        (set Q P) ) ) )  # Save tree
               (loop
                  (let X (val Tos)
                     (when (== -ZERO X)
                        (drop Q)
                        (ret Lst) )
                     (? (=0 (& X 8))  # Second visit
                        (let Y (cdr X)  # Nodes
                           (set Tos (cdr Y))  # TOS on up link
                           (set 2 Y P)
                           (setq P X)
                           (set Q P) ) )  # Save tree
                     (setq X (& X -9))  # Clear visit bit
                     (let Y (cdr X)  # Nodes
                        (set Tos (car Y))
                        (set Y P)
                        (setq P X)
                        (set Q P) ) ) ) ) ) ) ) )  # Save tree

# (all ['NIL | 'T | '0 | 'sym | '(NIL . flg) | '(T . flg) | '(0)]) -> lst
(de _All (Exe)
   (let X (eval (cadr Exe))
      (cond
         ((nil? X)  # Internal symbols
            (let Y (val $Intern)
               (loop
                  (let Z (cdar (++ Y))
                     (setq X
                        (consTree (car Z) (consTree (cdr Z) X)) ) )
                  (? (atom Y) X) ) ) )
         ((t? X)  # Transient symbols
            (consTree (val $Transient) (consTree (val 2 $Transient) $Nil)) )
         ((num? X)  # External symbols
            (consTree (val $Extern) $Nil) )
         ((sym? X)  # Given namespace
            (let Y (cdar X)
               (if (pair Y)
                  (consTree (car Y) (consTree (cdr Y) $Nil))
                  $Nil ) ) )
         ((nil? (car X))  # Direct internal tree
            (let Y (val (car (val $Intern)))
               (if (nil? (cdr X))
                  (val Y)
                  (val 2 Y) ) ) )
         ((t? (car X))  # Direct transient trees
            (if (nil? (cdr X))
               (val $Transient)
               (val 2 $Transient) ) )
         (T (val $Extern)) ) ) ) # Direct external tree

# (symbols) -> lst
# (symbols 'lst) -> lst
# (symbols 'lst . prg) -> any
# (symbols ['T] 'sym1 'sym2 ..) -> lst
(de _Symbols (Exe)
   (let X (cdr Exe)
      (if (atom X)  # No args
         (val $Intern)
         (let Y (eval (++ X))
            (if (pair Y)  # List argument
               (let L Y
                  (loop
                     (needNsp Exe (needSymb Exe (++ L)))
                     (? (atom L)) )
                  (if (atom X)  # No 'prg'
                     (prog1
                        (val $Intern)
                        (set $Intern Y) )
                     (let Z (save (val $Intern))
                        (set $Intern Y)
                        (prog1
                           (run X)  # Run 'prg'
                           (set $Intern Z) ) ) ) )
               (let F (t? Y)
                  (when F
                     (setq Y (eval (++ X))) )
                  (if
                     (or  # New namespace
                        (nil? (val (needSymb Exe Y)))
                        (== @ Y) )
                     (set
                        (chkVar Exe Y)
                        (cons $Tilde (cons $Nil $Nil)) )
                     (needNsp Exe Y) )
                  (let R (setq Y (save (cons Y $Nil)))
                     (while (pair X)
                        (setq Y
                           (set 2 Y
                              (cons
                                 (needNsp Exe (needSymb Exe (eval (++ X))))
                                 $Nil ) ) ) )
                     (prog1
                        (val $Intern)
                        (set $Intern R)
                        (when F
                           (set (val $NsLink) R) )
                        (putSrc (car R) 0) ) ) ) ) ) ) ) )

# (intern 'any ['nsp]) -> sym
(de _Intern (Exe)
   (let (X (cdr Exe)  Sym (save (evSym X)))
      (cond
         ((sym? (val (tail Sym))) $Nil)  # External symbol
         ((== (name @) ZERO) $Nil)  # Anonymous symbol
         (T
            (let Nm @
               (if (nil? (eval (cadr X)))
                  (let L (val $Intern)
                     (intern Sym 0 Nm
                        (cdar (car L))
                        (cdr L)
                        NO ) )
                  (intern Sym 0 Nm
                     (if (t? @)
                        (cdar (car (val $Intern)))
                        (cdar @) )
                     $Nil
                     NO ) ) ) ) ) ) )

# (====) -> NIL
(de _Hide (Exe)
   (set $Transient (set 2 $Transient $Nil)) )

# (box? 'any) -> sym | NIL
(de _BoxQ (Exe)
   (let X (eval (cadr Exe))
      (if
         (and
            (symb? X)
            (not (sym? (val (tail X))))
            (== ZERO (name @)) )
         X
         $Nil ) ) )

# (str? 'any) -> sym | NIL
(de _StrQ (Exe)
   (let X (eval (cadr Exe))
      (cond
         ((not (symb? X)) $Nil)
         ((or
               (sym? (val (tail X)))  # External
               (findSym X (name @) (val $Intern)) )
            $Nil )
         (T X) ) ) )

# (zap 'sym) -> sym
(de _Zap (Exe)
   (let Sym (needSymb Exe (eval (cadr Exe)))
      (if (sym? (val (tail Sym)))  # External
         (dbZap Sym)
         (unintern Sym (name @) (cdar (car (val $Intern)))) )
      Sym ) )

# (chop 'any) -> lst
(de _Chop (Exe)
   (let X (eval (cadr Exe))
      (if (or (pair X) (nil? X))
         X
         (let Tail (val (tail (xSym X)))
            (if (sym? Tail)  # External
               (chopExtNm (name (& Tail -9)))
               (let (P (push 0 (name Tail))  C (symChar P))
                  (if C
                     (save Tail
                        (let (Y (cons (mkChar C) $Nil)  R (save Y))
                           (while (setq C (symChar P))
                              (setq Y
                                 (set 2 Y (cons (mkChar C) $Nil)) ) )
                           R ) )
                     $Nil ) ) ) ) ) ) )

# (pack 'any ..) -> sym
(de _Pack (Exe)
   (save -ZERO
      (let
         (X (cdr Exe)
            P (push 4 NIL ZERO NIL) )  # [cnt last name link]
         (link (ofs P 2))
         (while (pair X)
            (pack (safe (eval (++ X))) P) )
         (consStr (val 3 P)) ) ) )

# (glue 'any 'lst) -> sym
(de _Glue (Exe)
   (let (X (cdr Exe)  Y (save (eval (++ X))))  # 'any'
      (if (atom (eval (++ X)))  # 'lst'
         @
         (let (Z (save @)  P (push 4 NIL ZERO NIL))  # [cnt last name link]
            (link (ofs P 2))
            (loop
               (pack (++ Z) P)
               (? (atom Z))
               (pack Y P) )
            (consStr (val 3 P)) ) ) ) )

# (text 'any1 'any ..) -> sym
(de _Text (Exe)
   (let (X (cdr Exe)  Y (evSym X))
      (if (nil? Y)
         Y
         (let
            (P (push 0 (xName Y) NIL)  # [cnt name link]
               Q (link (ofs P 1) T)
               R (push 4 NIL ZERO NIL)  # [cnt last name link]
               A (link (ofs R 2))
               N 0
               C T )
            (while (pair (shift X))
               (setq A (link (push (eval (car X)) NIL)))
               (inc 'N) )
            (while (setq C (symByte P))
               (cond
                  ((<> C (char "@")) (byteSym C R))
                  ((== (setq C (symByte P)) (char "@"))
                     (byteSym C R) )  # "@@"
                  ((gt0 (dec 'C (char "0")))
                     (when (> C 9)
                        (dec 'C 7) )  # Adjust for letter
                     (when (ge0 (setq C (- N (i64 C))))
                        (let I A
                           (while (ge0 (dec 'C))
                              (shift I) )
                           (pack (val I) R) ) ) ) ) )
            (consStr (val 3 R)) ) ) ) )

### Matching ###
(local) (preStr subStr)

(de i1 preStr (Nm (i8 . B) (i64* . P))
   (let (Q (push 0 (i64 Nm))  C (symByte Q))
      (loop
         (? (<> B C) NO)
         (? (=0 (setq C (symByte Q))) YES)
         (? (=0 (setq B (symByte P))) NO) ) ) )

(de i1 subStr (X Y)
   (or
      (nil? X)
      (== ZERO (setq X (xName X)))
      (let (P (push 0 (xName Y))  B T)
         (loop
            (? (=0 (setq B (symByte P))) NO)
            (let (Cnt (val P)  Nm (val 2 P))
               (? (preStr X B P) YES)
               (set P Cnt  2 P Nm) ) ) ) ) )

# (pre? 'any1 'any2) -> any2 | NIL
(de _PreQ (Exe)
   (let (X (cdr Exe)  Y (save (evSym X))  Z (evSym (shift X)))
      (cond
         ((nil? Y) Z)
         ((== ZERO (setq Y (xName Y)))
            Z )
         (T
            (let P (push 0 (xName Z))
               (cond
                  ((=0 (symByte P)) $Nil)
                  ((preStr Y @ P) Z)
                  (T $Nil) ) ) ) ) ) )

# (sub? 'any1 'any2) -> any2 | NIL
(de _SubQ (Exe)
   (let (X (cdr Exe)  Y (save (evSym X))  Z (evSym (shift X)))
      (if (subStr Y Z)
         Z
         $Nil ) ) )

# (val 'var) -> any
(de _Val (Exe)
   (let V (needVar Exe (eval (cadr Exe)))
      (when (and (sym? V) (sym? (val (tail V))))
         (dbFetch Exe V) )
      (val V) ) )

# (set 'var 'any ..) -> any
(de _Set (Exe)
   (save -ZERO
      (let X (cdr Exe)
         (loop
            (let Y (safe (needChkVar Exe (eval (++ X))))
               (when (and (sym? Y) (sym? (val (tail Y))))
                  (dbTouch Exe Y) )
               (let Z (eval (++ X))
                  (set Y Z)
                  (? (atom X) Z) ) ) ) ) ) )

# (setq var 'any ..) -> any
(de _Setq (Exe)
   (let X (cdr Exe)
      (loop
         (let Y (set (needChkVar Exe (++ X)) (eval (++ X)))
            (? (atom X) Y) ) ) ) )

# (swap 'var 'any) -> any
(de _Swap (Exe)
   (let
      (X (cdr Exe)
         Y (save (needChkVar Exe (eval (++ X)))) )
      (when (and (sym? Y) (sym? (val (tail Y))))
         (dbTouch Exe Y) )
      (let (Z (eval (car X))  V (val Y))
         (set Y Z)
         V ) ) )

# (xchg 'var 'var ..) -> any
(de _Xchg (Exe)
   (save -ZERO
      (let X (cdr Exe)
         (loop
            (let Y (safe (needChkVar Exe (eval (++ X))))
               (when (and (sym? Y) (sym? (val (tail Y))))
                  (dbTouch Exe Y) )
               (let Z (needChkVar Exe (eval (++ X)))
                  (when (and (sym? Z) (sym? (val (tail Z))))
                     (dbTouch Exe Z) )
                  (setq Z (xchg Y Z))
                  (? (atom X) Z) ) ) ) ) ) )

# (on var ..) -> T
(de _On (Exe)
   (let X (cdr Exe)
      (loop
         (set (needChkVar Exe (++ X)) $T)
         (? (atom X) $T) ) ) )

# (off var ..) -> NIL
(de _Off (Exe)
   (let X (cdr Exe)
      (loop
         (set (needChkVar Exe (++ X)) $Nil)
         (? (atom X) $Nil) ) ) )

# (onOff var ..) -> flg
(de _OnOff (Exe)
   (let X (cdr Exe)
      (loop
         (let
            (Y (needChkVar Exe (++ X))
               Z (if (nil? (val Y)) $T $Nil) )
            (set Y Z)
            (? (atom X) Z) ) ) ) )

# (zero var ..) -> 0
(de _Zero (Exe)
   (let X (cdr Exe)
      (loop
         (set (needChkVar Exe (++ X)) ZERO)
         (? (atom X) ZERO) ) ) )

# (one var ..) -> 1
(de _One (Exe)
   (let X (cdr Exe)
      (loop
         (set (needChkVar Exe (++ X)) ONE)
         (? (atom X) ONE) ) ) )

# (default sym 'any ..) -> any
(de _Default (Exe)
   (let X (cdr Exe)
      (loop
         (let Y (needChkVar Exe (++ X))
            (when (nil? (val Y))
               (set Y (eval (car X))) )
            (? (atom (shift X)) (val Y)) ) ) ) )

# (push 'var 'any ..) -> any
(de _Push (Exe)
   (let
      (X (cdr Exe)
         Y (save (needChkVar Exe (eval (++ X)))) )
      (when (and (sym? Y) (sym? (val (tail Y))))
         (dbTouch Exe Y) )
      (loop
         (let Z (eval (++ X))
            (set Y (cons Z (val Y)))
            (? (atom X) Z) ) ) ) )

# (push1 'var 'any ..) -> any
(de _Push1 (Exe)
   (let
      (X (cdr Exe)
         Y (save (needChkVar Exe (eval (++ X)))) )
      (when (and (sym? Y) (sym? (val (tail Y))))
         (dbTouch Exe Y) )
      (loop
         (let (Z (eval (++ X))  V (val Y))
            (unless (member Z V)
               (set Y (cons Z V)) )
            (? (atom X) Z) ) ) ) )

# (push1q 'var 'any ..) -> any
(de _Push1q (Exe)
   (let
      (X (cdr Exe)
         Y (save (needChkVar Exe (eval (++ X)))) )
      (when (and (sym? Y) (sym? (val (tail Y))))
         (dbTouch Exe Y) )
      (loop
         (let (Z (eval (++ X))  V (val Y))
            (unless (memq Z V)
               (set Y (cons Z V)) )
            (? (atom X) Z) ) ) ) )

# (pop 'var) -> any
(de _Pop (Exe)
   (let X (needChkVar Exe (eval (cadr Exe)))
      (when (and (sym? X) (sym? (val (tail X))))
         (dbTouch Exe X) )
      (if (atom (val X))
         @
         (set X (cdr @))
         (car @) ) ) )

# (++ var) -> any
(de _Popq (Exe)
   (let X (needChkVar Exe (cadr Exe))
      (if (atom (val X))
         @
         (set X (cdr @))
         (car @) ) ) )

# (shift 'var) -> any
(de _Shift (Exe)
   (let X (needChkVar Exe (eval (cadr Exe)))
      (when (and (sym? X) (sym? (val (tail X))))
         (dbTouch Exe X) )
      (set X (cdr (needLst Exe (val X)))) ) )

# (cut 'cnt 'var) -> lst
(de _Cut (Exe)
   (let (X (cdr Exe)  N (evCnt Exe X))
      (if (le0 N)
         $Nil
         (let Y (needChkVar Exe (eval (cadr X)))
            (when (and (sym? Y) (sym? (val (tail Y))))
               (dbTouch Exe Y) )
            (if (atom (val Y))
               @
               (let
                  (V (save @)
                     Z (cons (++ V) $Nil)
                     R (save Z) )
                  (while (and (pair V) (dec 'N))
                     (setq Z (set 2 Z (cons (++ V) $Nil))) )
                  (set Y V)  # Set new value
                  R ) ) ) ) ) )

# (del 'any 'var ['flg]) -> lst
(de _Del (Exe)
   (let
      (X (cdr Exe)
         Y (save (eval (++ X)))
         Var (save (needChkVar Exe (eval (++ X))))
         Flg (nil? (eval (car X))) )
      (when (and (sym? Var) (sym? (val (tail Var))))
         (dbTouch Exe Var) )
      (let V (val Var)
         (loop
            (? (atom V) V)
            (let Z (++ V)
               (? (not (equal Y Z))
                  (let (P (cons Z $Nil)  R P)
                     (save R
                        (loop
                           (? (atom V))
                           (if (equal Y (setq Z (++ V)))
                              (? Flg)
                              (setq P (set 2 P (cons Z $Nil))) ) ) )
                     (set 2 P V  Var R) ) ) )
            (set Var V)
            (? Flg V) ) ) ) )

# (queue 'var 'any) -> any
(de _Queue (Exe)
   (let
      (X (cdr Exe)
         Y (save (needChkVar Exe (eval (++ X)))) )
      (when (and (sym? Y) (sym? (val (tail Y))))
         (dbTouch Exe Y) )
      (let
         (Z (eval (car X))
            L (cons Z $Nil)
            V (val Y) )
         (if (atom V)
            (set Y L)
            (while (pair (cdr V))
               (shift V) )
            (set 2 V L) )
         Z ) ) )

# (fifo 'var ['any ..]) -> any
(de _Fifo (Exe)
   (let
      (X (cdr Exe)
         Y (save (needChkVar Exe (eval (++ X)))) )
      (when (and (sym? Y) (sym? (val (tail Y))))
         (dbTouch Exe Y) )  # External symbol
      (let V (val Y)
         (cond
            ((pair X)  # Add to fifo
               (let E (eval (car X))
                  (if (pair V)
                     (setq V (set 2 V (cons E (cdr V))))  # Concat into value
                     (setq V (cons E -ZERO))  # Circular cell
                     (set 2 V V) )
                  (while (pair (shift X))
                     (setq V
                        (set 2 V
                           (cons
                              (setq E (eval (car X)))
                              (cdr V) ) ) ) )
                  (set Y V)
                  E ) )
            ((atom V) $Nil)  # Empty
            ((== (cdr V) V)  # Single cell
               (set Y $Nil)  # Clear value
               (car V) )
            (T
               (set 2 V (cdr @))  # Remove
               (car @) ) ) ) ) )  # and return

# (rid 'var 'any) -> any
(de _Rid (Exe)
   (let
      (X (cdr Exe)
         Y (save (needChkVar Exe (eval (++ X)))) )
      (when (and (sym? Y) (sym? (val (tail Y))))
         (dbTouch Exe Y) )  # External symbol
      (setq X (eval (car X)))
      (let V (val Y)
         (cond
            ((pair V)
               (let (Z V  L (cdr Z))
                  (loop
                     (? (atom L)  # Non-circular
                        (when (equal L X)
                           (set 2 Z $Nil) )
                        (if (equal (car V) X)
                           (set Y (cdr V))
                           V ) )
                     (? (== L V)  # Circular
                        (nond
                           ((equal (car L) X) V)
                           ((== L Z)
                              (set 2 Z (cdr L))
                              (set Y Z) )
                           (NIL (set Y $Nil)) ) )
                     (if (equal (car L) X)
                        (set 2 Z (shift L))
                        (setq L (cdr (shift Z))) ) ) ) )
            ((equal V X) (set Y $Nil))
            (T V) ) ) ) )

# (enum 'var 'cnt ['cnt ..]) -> lst
# (enum 'var) -> lst
(de _Enum (Exe)
   (let
      (X (cdr Exe)
         Var (save (needChkVar Exe (eval (++ X))))
         Cnt T )
      (if (pair X)
         (loop
            (? (le0 (setq Cnt (evCnt Exe X))) $Nil)
            (let P (val Var)
               (loop
                  (let N (shr Cnt 1)
                     (? (=0 N)
                        (setq Var
                           (if (pair P)
                              @
                              (set Var (cons $Nil $Nil)) ) ) )
                     (if (& Cnt 1)
                        (cond
                           ((atom P)
                              (let Y (cons $Nil (setq P $Nil))
                                 (set Var (cons $Nil Y))
                                 (setq Var (ofs Y 1)) ) )
                           ((atom (cdr P))
                              (setq Var
                                 (ofs
                                    (set 2 P (cons $Nil (setq P $Nil)))
                                    1 ) ) )
                           (T
                              (setq P (val (setq Var (ofs @ 1)))) ) )
                        (cond
                           ((atom P)
                              (let Y (cons (setq P $Nil) $Nil)
                                 (set Var (cons $Nil Y))
                                 (setq Var Y) ) )
                           ((atom (cdr P))
                              (setq Var
                                 (set 2 P (cons (setq P $Nil) $Nil)) ) )
                           (T (setq P (val (setq Var @)))) ) )
                     (setq Cnt N) ) ) )
            (? (atom (shift X)) Var) )
         (setq Cnt 0)
         (let
            (Q (link (push NIL NIL))
               Tos (link (push -ZERO NIL))
               R (link (push $Nil NIL))
               P (val Var)
               M 1 )
            (loop
               (loop
                  (let Y (cdr P)  # Get subtrees
                     (? (atom (cdr Y)))  # Right subtree
                     (let Z P  # Go right
                        (setq P @)  # Invert tree
                        (set 2 Y (val Tos))
                        (set Tos Z) )
                     (setq
                        Cnt (| Cnt M)
                        M (shl M 1) ) ) )
               (set Q P)  # Save tree
               (loop
                  (unless (nil? (car P))
                     (set R
                        (cons  # (cnt . any)
                           (cons (cnt (| Cnt M)) @)
                           (val R) ) ) )
                  (let Y (cdr P)
                     (? (pair (car Y))  # Left subtree
                        (let Z P  # Go left
                           (setq P @)  # Invert tree
                           (set Y (val Tos))
                           (set Tos (| Z 8))  # First visit
                           (set Q P) )  # Save tree
                        (setq M (shl M 1)) ) )
                  (loop
                     (let Y (val Tos)
                        (when (== -ZERO Y)
                           (ret (val R)) )
                        (? (=0 (& Y 8))  # Second visit
                           (setq
                              M (shr M 1)
                              Cnt (& Cnt (x| M -1)) )
                           (let Z (cdr Y)  # Nodes
                              (set Tos (cdr Z))  # TOS on up link
                              (set 2 Z P)
                              (setq P Y)
                              (set Q P) ) )  # Save tree
                        (setq
                           Y (& Y -9)  # Clear visit bit
                           M (shr M 1)
                           Cnt (& Cnt (x| M -1)) )
                        (let Z (cdr Y)  # Nodes
                           (set Tos (car Z))
                           (set Z P)
                           (setq P Y)
                           (set Q P) ) ) ) ) ) ) ) ) )  # Save tree

# (enum? 'lst 'cnt ['cnt ..]) -> lst | NIL
(de _EnumQ (Exe)
   (let
      (X (cdr Exe)
         P (save (eval (++ X)))
         Cnt T )
      (loop
         (? (le0 (setq Cnt (evCnt Exe X))) $Nil)
         (loop
            (let N (shr Cnt 1)
               (? (=0 N))
               (setq P
                  (if (& Cnt 1) (cddr P) (cadr P)) )
               (? (atom P) (ret $Nil))
               (setq Cnt N) ) )
         (? (atom (shift X)) P)
         (setq P (car P)) ) ) )

(local) (idxPut idxGet idxDel)

(de idxPut (Var Key Flg)
   (let X (val Var)
      (if (pair X)
         (loop
            (? (=0 (compare (car X) Key)) X)  # Found key
            (let Y (cdr X)  # Get link cell
               (cond
                  ((lt0 @)  # Entry is smaller
                     (? (atom Y)  # No link yet
                        (if (or (t? Flg) (chance 1))
                           (set 2 X (cons $Nil (cons Key $Nil)))
                           (set 2 X (cons (cons (car X) $Nil) $Nil))
                           (set X Key) )
                        $Nil )
                     (? (atom (setq Y (cdr Y)))
                        (if (or (t? Flg) (chance 1))
                           (set 2 (cdr X) (cons Key $Nil))
                           (set (cdr X)
                              (cons (car X) (cons (cadr X) $Nil)) )
                           (set X Key) )
                        $Nil )
                     (if
                        (or
                           (t? Flg)
                           (atom (cdr Y))
                           (gt0 (compare (car Y) Key))
                           (chance (hex "FFF")) )
                        (setq X Y)
                        (xchg X Y)
                        (set
                           2 (cdr X) (cddr Y)
                           2 (cdr Y) (cadr Y)
                           (cdr Y) (cadr X)
                           (cdr X) Y ) ) )
                  (T  # Entry is greater
                     (? (atom Y)  # No link yet
                        (if (or (t? Flg) (chance 1))
                           (set 2 X (cons (cons Key $Nil) $Nil))
                           (set 2 X (cons $Nil (cons (car X) $Nil)))
                           (set X Key) )
                        $Nil )
                     (? (atom (setq Y (car Y)))
                        (if (or (t? Flg) (chance 1))
                           (set (cdr X) (cons Key $Nil))
                           (set 2 (cdr X)
                              (cons (car X) (cons $Nil (cddr X))) )
                           (set X Key) )
                        $Nil )
                     (if
                        (or
                           (t? Flg)
                           (atom (cdr Y))
                           (lt0 (compare (car Y) Key))
                           (chance (hex "FFF")) )
                        (setq X Y)
                        (xchg X Y)
                        (set
                           (cdr X) (cadr Y)
                           (cdr Y) (cddr Y)
                           2 (cdr Y) (cddr X)
                           2 (cdr X) Y ) ) ) ) ) )
         (set Var (cons Key $Nil))
         $Nil ) ) )

(de idxGet (Var Key)
   (let X (val Var)
      (cond
         ((nil? Key)
            (while (pair (cadr X))
               (setq X @) )
            X )
         ((t? Key)
            (while (pair (cddr X))
               (setq X @) )
            X )
         (T
            (loop
               (? (atom X) $Nil)
               (? (=0 (compare (car X) Key)) X)  # Found key
               (let Y (cdr X)  # Get link cell
                  (setq X
                     (if (lt0 @) (cdr Y) (car Y)) ) ) ) ) ) ) )

(de idxDel (Var Key)
   (loop
      (let X (val Var)
         (? (atom X) $Nil)
         (let Y (cdr X)  # Subtrees
            (let I (compare (car X) Key)
               (? (=0 I)  # Found key
                  (cond
                     ((atom (car Y))  # No left branch
                        (set Var (cdr Y)) )  # Use right branch
                     ((atom (cdr Y))  # No right branch
                        (set Var (car Y)) )  # Use left branch
                     (T
                        (let Z (cdr (setq Y (cdr Y)))  # Sub-branches
                           (if (atom (car Z))  # No left sub-branch
                              (set   # Insert right sub-branch
                                 X (car Y)
                                 2 (cdr X) (cdr Z) )
                              (let L (cdr (setq Z (car Z)))  # Left sub-branch
                                 (loop
                                    (? (atom (car L)))
                                    (setq Y Z  Z (car L)  L (cdr Z)) )
                                 (set
                                    X (car Z)
                                    (cdr Y) (cdr L) ) ) ) ) ) )
                  X )
               (? (atom Y) $Nil)  # No link cell
               (setq Var Y)  # Default point to left subtree
               (and (lt0 I) (setq Var (ofs Var 1))) ) ) ) ) )  # Point to right

# (idx 'var 'any 'flg) -> lst
# (idx 'var 'any) -> lst
# (idx 'var) -> lst
(de _Idx (Exe)
   (let
      (X (cdr Exe)
         Var (needChkVar Exe (eval (++ X))) )
      (if (atom X)
         (consTree (val Var) $Nil)  # Single arg
         (save Var
            (let Key (save (eval (++ X)))
               (cond
                  ((atom X) (idxGet Var Key))  # Two args
                  ((nil? (eval (car X))) (idxDel Var Key))  # Delete
                  (T (idxPut Var Key @)) ) ) ) ) ) )

# (lup 'lst 'any) -> lst
# (lup 'lst 'any 'any2) -> lst
(de _Lup (Exe)
   (let (X (cdr Exe)  P (save (eval (++ X))))
      (if (atom P)
         P
         (let Key (eval (++ X))
            (if (atom X)
               (loop
                  (let Y (car P)
                     (cond
                        ((t? Y) (setq P (cadr P)))
                        ((atom Y) (setq P (cddr P)))
                        (T
                           (? (=0 (compare (car Y) Key)) (car P))
                           (setq
                              P (cdr P)
                              P (if (lt0 @) (cdr P) (car P)) ) ) ) )
                  (? (atom P) $Nil) )
               (save Key)
               (let
                  (Key2 (save (eval (car X)))
                     Q (link (push NIL NIL))
                     Tos (link (push -ZERO NIL))
                     R $Nil )
                  (loop
                     (loop
                        (let Y (cdr (setq X (cdr P)))  # Right subtree
                           (? (atom Y))
                           (let Z (car P)
                              (? (t? Z))
                              (? (and (pair Z) (gt0 (compare (car Z) Key2)))) )
                           (let Z P  # Go right
                              (setq P Y)  # Invert tree
                              (set 2 X (val Tos))
                              (set Tos Z) ) ) )
                     (set Q P)  # Save tree
                     (loop
                        (when
                           (and
                              (pair (setq X (car P)))
                              (ge0 (compare (car X) Key)) )
                           (when (le0 (compare (car X) Key2))
                              (setq R (cons X R)) )  # Cons symbol
                           (? (pair (car (setq X (cdr P))))  # Left subtree
                              (let Z P  # Go left
                                 (setq P @)  # Invert tree
                                 (set X (val Tos))
                                 (set Tos (| Z 8))  # First visit
                                 (set Q P) ) ) )  # Save tree
                        (loop
                           (when (== -ZERO (setq X (val Tos)))
                              (ret R) )
                           (? (=0 (& X 8))  # Second visit
                              (let Y (cdr X)  # Nodes
                                 (set Tos (cdr Y))  # TOS on up link
                                 (set 2 Y P)
                                 (setq P X)
                                 (set Q P) ) )  # Save tree
                           (setq X (& X -9))  # Clear visit bit
                           (let Y (cdr X)  # Nodes
                              (set Tos (car Y))
                              (set Y P)
                              (setq P X)
                              (set Q P) ) ) ) ) ) ) ) ) ) )  # Save tree

### Property access ###
(local) (put putn get getn prop)

(de void put (Sym Key Val)
   (let Tail (val (tail Sym))
      (unless (num? Tail)  # Property list
         (let (L (any (& Tail -9))  X (car L))
            (if (atom X)
               (when (== Key X)
                  (cond
                     ((nil? Val)
                        (shift L)  # Remove first property
                        (set (tail Sym)
                           (if (sym? Tail) (sym L) L) ) )
                     ((<> Val $T)  # Change to cell
                        (set L (cons Val Key)) ) )
                  (ret) )
               (when (== Key (cdr X))
                  (cond
                     ((nil? Val)
                        (shift L)  # Remove first property
                        (set (tail Sym)
                           (if (sym? Tail) (sym L) L) ) )
                     ((t? Val) (set L Key))  # Change to flag
                     (T (set X Val)) )  # Set new value
                  (ret) ) )
            (while (pair (setq X (cdr L)))
               (let Y (car X)
                  (if (atom Y)
                     (when (== Key Y)
                        (if (nil? Val)
                           (set 2 L (cdr X))  # Remove cell
                           (unless (t? Val)
                              (set X (cons Val Key)) )
                           (set 2 L (cdr X))  # Unlink cell
                           (ifn (sym? Tail)
                              (set 2 X Tail)
                              (set 2 X (& Tail -9))
                              (setq X (sym X)) )
                           (set (tail Sym) X) )
                        (ret) )
                     (when (== Key (cdr Y))
                        (if (nil? Val)
                           (set 2 L (cdr X))  # Remove cell
                           (if (t? Val)
                              (set X Key)  # Change to flag
                              (set Y Val) )  # Set new value
                           (set 2 L (cdr X))  # Unlink cell
                           (ifn (sym? Tail)
                              (set 2 X Tail)
                              (set 2 X (& Tail -9))
                              (setq X (sym X)) )
                           (set (tail Sym) X) )
                        (ret) ) ) )
                  (setq L X) ) ) )
      (unless (nil? Val)  # Non-NIL value
         (setq Val
            (if (t? Val) Key (cons Val Key)) )
         (set (tail Sym)
            (if (sym? Tail)
               (sym (cons Val (& Tail -9)))
               (cons Val Tail) ) ) ) ) )

(de void putn (Exe Lst Key Val)
   (nond
      ((num? Key)
         (loop  # asoq
            (let X (car Lst)
               (? (and (pair X) (== Key (car X)))
                  (set 2 X Val) ) )
            (when (atom (shift Lst))
               (itemErr Exe Key) ) ) )
      ((== ZERO Key)
         (let Cnt (int Key)  # index
            (while (dec 'Cnt)
               (when (atom (shift Lst))
                  (itemErr Exe Key) ) ) )
         (if (sign? Key)
            (set 2 Lst Val)
            (set Lst Val) ) )
      (NIL (argErr Exe Key)) ) )

(de get (Sym Key)
   (let Tail (val (tail Sym))
      (unless (num? Tail)
         (let (L (any (& Tail -9))  X (car L))
            (if (atom X)
               (when (== Key X)
                  (ret $T) )
               (when (== Key (cdr X))
                  (ret (car X)) ) )
            (while (pair (setq X (cdr L)))
               (let Y (car X)
                  (if (atom Y)
                     (when (== Key Y)
                        (set 2 L (cdr X))  # Unlink cell
                        (ifn (sym? Tail)
                           (set 2 X Tail)
                           (set 2 X (& Tail -9))
                           (setq X (sym X)) )
                        (set (tail Sym) X)
                        (ret $T) )
                     (when (== Key (cdr Y))
                        (set 2 L (cdr X))  # Unlink cell
                        (ifn (sym? Tail)
                           (set 2 X Tail)
                           (set 2 X (& Tail -9))
                           (setq X (sym X)) )
                        (set (tail Sym) X)
                        (ret (car Y)) ) )
                  (setq L X) ) ) ) )
      $Nil ) )

(de getn (Exe X Key)
   (when (num? X)  # Need symbol or pair
      (argErr Exe X) )
   (if (pair X)
      (nond
         ((num? Key)
            (loop  # asoq
               (let Y (car X)
                  (? (and (pair Y) (== Key (car Y)))
                     (cdr Y) ) )
               (? (atom (shift X)) $Nil) ) )
         ((== ZERO Key) (nth Key X))
         (NIL $Nil) )
      (when (sym? (val (tail X)))
         (dbFetch Exe X) )
      (if (== Key ZERO)
         (val X)
         (tailcall (get X Key)) ) ) )

(de prop (Sym Key)
   (let Tail (val (tail Sym))
      (unless (num? Tail)
         (let (L (any (& Tail -9))  X (car L))
            (if (atom X)
               (when (== Key X)
                  (ret Key) )
               (when (== Key (cdr X))
                  (ret X) ) )
            (while (pair (setq X (cdr L)))
               (let Y (car X)
                  (if (atom Y)
                     (when (== Key Y)
                        (set 2 L (cdr X))  # Unlink cell
                        (ifn (sym? Tail)
                           (set 2 X Tail)
                           (set 2 X (& Tail -9))
                           (setq X (sym X)) )
                        (set (tail Sym) X)
                        (ret Key) )
                     (when (== Key (cdr Y))
                        (set 2 L (cdr X))  # Unlink cell
                        (ifn (sym? Tail)
                           (set 2 X Tail)
                           (set 2 X (& Tail -9))
                           (setq X (sym X)) )
                        (set (tail Sym) X)
                        (ret Y) ) ) )
               (setq L X) ) ) )
      (let R (cons $Nil Key)
         (set (tail Sym)
            (if (sym? Tail)
               (sym (cons R (& Tail -9)))
               (cons R Tail) ) )
         R ) ) )

# (put 'sym1|lst ['sym2|cnt ..] 'any) -> any
(de _Put (Exe)
   (let
      (X (cdr Exe)
         Y (save (eval (++ X)))
         Key T )
      (loop
         (setq Key (eval (++ X)))
         (? (atom (cdr X)))
         (setq Y (safe (getn Exe Y Key))) )
      (when (num? Y)  # Need symbol or pair
         (argErr Exe Y) )
      (link (push Key NIL))
      (let Val (eval (car X))
         (if (pair Y)
            (putn Exe Y Key Val)
            (when (sym? (val (tail Y)))
               (if (nil? Key)
                  (dbFetch Exe Y)  # Volatile property
                  (dbTouch Exe Y) ) )
            (if (== ZERO Key)
               (set (chkVar Exe Y) Val)
               (put Y Key Val) ) )
         Val ) ) )

# (get 'sym1|lst ['sym2|cnt ..]) -> any
(de _Get (Exe)
   (let (X (cdr Exe)  Y (eval (++ X)))
      (when (pair X)
         (save Y
            (loop
               (setq Y (getn Exe Y (eval (++ X))))
               (? (atom X))
               (safe Y) ) ) )
      Y ) )

# (prop 'sym1|lst ['sym2|cnt ..] 'sym) -> var
(de _Prop (Exe)
   (let
      (X (cdr Exe)
         Y (save (eval (++ X)))
         Key T )
      (loop
         (setq Key (eval (++ X)))
         (? (atom X))
         (setq Y (safe (getn Exe Y Key))) )
      (needSymb Exe Y)
      (link (push Key NIL))
      (when (sym? (val (tail Y)))
         (if (nil? Key)
            (dbFetch Exe Y)  # Volatile property
            (dbTouch Exe Y) ) )
      (prop Y Key) ) )

# (; 'sym1|lst [sym2|cnt ..]) -> any
(de _Semicol (Exe)
   (let (X (cdr Exe)  Y (eval (++ X)))
      (when (pair X)
         (save Y
            (loop
               (setq Y (getn Exe Y (++ X)))
               (? (atom X))
               (safe Y) ) ) )
      Y ) )

# (=: sym|0 [sym1|cnt ..] 'any) -> any
(de _SetCol (Exe)
   (let (X (cdr Exe)  Y (val $This)  Key T)
      (loop
         (setq Key (++ X))
         (? (atom (cdr X)))
         (setq Y (getn Exe Y Key)) )
      (when (num? Y)  # Need symbol or pair
         (argErr Exe Y) )
      (let Val (eval (car X))
         (if (pair Y)
            (putn Exe Y Key Val)
            (when (sym? (val (tail Y)))
               (if (nil? Key)
                  (dbFetch Exe Y)  # Volatile property
                  (dbTouch Exe Y) ) )
            (if (== ZERO Key)
               (set (chkVar Exe Y) Val)
               (put Y Key Val) ) )
         Val ) ) )

# (: sym|0 [sym1|cnt ..]) -> any
(de _Col (Exe)
   (let (X (cdr Exe)  Y (val $This))
      (loop
         (setq Y (getn Exe Y (++ X)))
         (? (atom X) Y) ) ) )

# (:: sym|0 [sym1|cnt .. sym2]) -> var
(de _PropCol (Exe)
   (let (X (cdr Exe)  Y (val $This)  Key T)
      (loop
         (setq Key (++ X))
         (? (atom X))
         (setq Y (getn Exe Y Key)) )
      (needSymb Exe Y)
      (when (sym? (val (tail Y)))
         (if (nil? Key)
            (dbFetch Exe Y)  # Volatile property
            (dbTouch Exe Y) ) )
      (prop Y Key) ) )

# (putl 'sym1|lst1 ['sym2|cnt ..] 'lst) -> lst
(de _Putl (Exe)
   (let
      (X (cdr Exe)
         Y (save (eval (++ X)))
         Z T )
      (loop
         (setq Z (eval (++ X)))
         (? (atom X))
         (setq Y (safe (getn Exe Y Z))) )
      (let
         (R (save Z)
            Tail (val (tail (needSymb Exe Y))) )
         (when (sym? (setq X Tail))
            (dbTouch Exe Y)
            (setq X (& (val (tail Y)) -9)) )
         (until (num? X)  # Skip old properties
            (shift X) )
         (while (pair Z)  # New property list
            (let P (++ Z)
               (if (atom P)
                  (setq X (cons P X))
                  (unless (nil? (car P))
                     (when (t? (car P))
                        (setq P (cdr P)) )
                     (setq X (cons P X)) ) ) ) )
         (set (tail Y)
            (if (sym? Tail) (sym X) X) )
         R ) ) )

# (getl 'sym1|lst1 ['sym2|cnt ..]) -> lst
(de _Getl (Exe)
   (let (X (cdr Exe)  Y (save (eval (car X))))
      (while (pair (shift X))
         (setq Y
            (safe (getn Exe Y (eval (car X)))) ) )
      (when (sym? (setq X (val (tail (needSymb Exe Y)))))
         (dbFetch Exe Y)
         (setq X (& (val (tail Y)) -9)) )
      (if (num? X)
         $Nil
         (let R (setq Y (cons (car X) $Nil))
            (link (push R NIL))
            (while (pair (shift X))
               (setq Y
                  (set 2 Y (cons (car X) $Nil)) ) )
            R ) ) ) )

(local) wipe

(de void wipe (Exe X)
   (let
      (Tail (val (tail (needSymb Exe X)))
         Nm (name (& Tail -9)) )
      (ifn (sym? Tail)  # External symbol
         (set
            X $Nil  # Clear value
            (tail X) Nm )  # and properties
         (setq Nm (add Nm Nm))  # Get carry
         (unless @@  # Not dirty
            (setq Nm (add Nm Nm))
            (when @@  # and loaded
               (set
                  X $Nil
                  (tail X) (sym (shr Nm 2)) ) ) ) ) ) )  # Set "not loaded"

# (wipe 'sym|lst) -> sym|lst
(de _Wipe (Exe)
   (let X (eval (cadr Exe))
      (unless (nil? X)
         (if (atom X)
            (wipe Exe X)
            (let Y X
               (loop
                  (wipe Exe (++ Y))
                  (? (atom Y)) ) ) ) )
      X ) )

(local) meta

(de meta (X Key)
   (loop
      (? (atom X) $Nil)
      (let Y (car X)
         (when (symb? Y)
            (?
               (not
                  (nil?
                     (if (== Key ZERO) (val Y) (get Y Key)) ) )
               @ )
            (stkChk 0)
            (? (not (nil? (meta (car Y) Key))) @) ) )
      (shift X) ) )

# (meta 'obj|typ 'sym ['sym2|cnt ..]) -> any
(de _Meta (Exe)
   (let (X (cdr Exe)  Y (save (eval (++ X))))
      (when (num? Y)  # Need symbol or pair
         (argErr Exe Y) )
      (when (sym? Y)
         (when (sym? (val (tail Y)))
            (dbFetch Exe Y) )
         (setq Y (val Y)) )
      (setq Y (meta Y (eval (car X))))
      (while (pair (shift X))
         (safe Y)
         (setq Y (getn Exe Y (eval (car X)))) )
      Y ) )

# (low? 'any) -> sym | NIL
(de _LowQ (Exe)
   (let X (eval (cadr Exe))
      (if (and (symb? X) (isLowc (firstChar X)))
         X
         $Nil ) ) )

# (upp? 'any) -> sym | NIL
(de _UppQ (Exe)
   (let X (eval (cadr Exe))
      (if (and (symb? X) (isUppc (firstChar X)))
         X
         $Nil ) ) )

# (lowc 'any) -> any
(de _Lowc (Exe)
   (let X (eval (cadr Exe))
      (if (or (not (symb? X)) (nil? X))
         X
         (let
            (P (push 0 (xName X) NIL)  # [cnt name link]
               Q (link (ofs P 1) T)
               R (push 4 NIL ZERO NIL)  # [cnt last name link]
               C T )
            (link (ofs R 2))
            (while (setq C (symChar P))
               (charSym (toLowerCase C) R) )
            (consStr (val 3 R)) ) ) ) )

# (uppc 'any) -> any
(de _Uppc (Exe)
   (let X (eval (cadr Exe))
      (if (or (not (symb? X)) (nil? X))
         X
         (let
            (P (push 0 (xName X) NIL)  # [cnt name link]
               Q (link (ofs P 1) T)
               R (push 4 NIL ZERO NIL)  # [cnt last name link]
               C T )
            (link (ofs R 2))
            (while (setq C (symChar P))
               (ifn (== C (char "ß"))
                  (charSym (toUpperCase C) R)
                  (charSym (char "S") R)
                  (charSym (char "S") R) ) )
            (consStr (val 3 R)) ) ) ) )

# (fold 'any ['cnt]) -> sym
(de _Fold (Exe)
   (let (X (cdr Exe)  Y (eval (++ X)))
      (if (or (not (symb? Y)) (nil? Y))
         Y
         (let
            (N (if (atom X) 0 (evCnt Exe X))
               P (push 0 (xName Y) NIL)  # [cnt name link]
               Q (link (ofs P 1) T)
               R (push 4 NIL ZERO NIL)  # [cnt last name link]
               C T )
            (link (ofs R 2))
            (while (setq C (symChar P))
               (when (isLetterOrDigit C)
                  (charSym (toLowerCase C) R)
                  (? (=0 (dec 'N))) ) )
            (consStr (val 3 R)) ) ) ) )
pil21/src/io.l0000644000000000000000000027712414767053075010301 0ustar  # 20mar25 Software Lab. Alexander Burger

(symbols '(llvm))

(local) (openErr closeErr pipeErr sizeErr eofErr badInput badFd writeErr
selectErr)

(de NIL openErr (Exe X)
   (err Exe X ($ "Open error: %s") (strErrno)) )

(de NIL closeErr ()
   (err 0 0 ($ "Close error: %s") (strErrno)) )

(de NIL pipeErr (Exe)
   (err Exe 0 ($ "Pipe error: %s") (strErrno)) )

(de NIL sizeErr (Exe)
   (err Exe 0 ($ "Size overflow") null) )

(de NIL eofErr ()
   (err 0 0 ($ "EOF Overrun") null) )

(de NIL badInput ()
   (let S (b8 2)
      (set S (i8 (val $Chr)))
      (set 2 S 0)
      (err 0 0 ($ "Bad input '%s'") S) ) )

(de NIL badFd (Exe Fd)
   (err Exe Fd ($ "Bad FD") null) )

(de NIL writeErr ((i8* . Fmt))
   (err 0 0 Fmt (strErrno)) )

(de NIL selectErr (Exe)
   (err Exe 0 ($ "Select error: %s") (strErrno)) )

(local) (closeOnExec rdLockWait wrLockWait)

(de void closeOnExec (Exe (i32 . Fd))
   (when (lt0 (fcntlCloExec Fd))
      (err Exe 0 ($ "SETFD %s") (strErrno)) ) )

(de void rdLockWait ((i32 . Fd) (i64 . Len))
   (while (lt0 (rdLock Fd 0 Len YES))
      (unless (== (gErrno) EINTR)
         (lockErr) ) ) )

(de void wrLockWait ((i32 . Fd) (i64 . Len))
   (while (lt0 (wrLock Fd 0 Len YES))
      (unless (== (gErrno) EINTR)
         (lockErr) ) ) )

(local) (initInFile initOutFile closeInFile closeOutFile)

(de i8* initInFile ((i32 . Fd) (i8* . Nm))
   (let I (val $InFDs)
      (when (>= Fd I)
         (let P
            (set $InFiles
               (i8**
                  (alloc
                     (i8* (val $InFiles))
                     (* 8 (i64 (set $InFDs (+ Fd 1)))) ) ) )
            (loop
               (set (ofs P I) null)
               (? (== I Fd))
               (inc 'I) ) ) ) )
   (let In:
      (inFile
         (let P (ofs (val $InFiles) Fd)
            (if (val P)
               @
               (set P (alloc null (inFile T))) ) ) )
      (In: name Nm)
      (In: tty (n0 (isatty (In: fd Fd))))
      (In: chr 0)
      (In: line (In: src 1))
      (In: ix (In: cnt 0))
      (In:) ) )

(de i8* initOutFile ((i32 . Fd))
   (let I (val $OutFDs)
      (when (>= Fd I)
         (let P
            (set $OutFiles
               (i8**
                  (alloc
                     (i8* (val $OutFiles))
                     (* 8 (i64 (set $OutFDs (+ Fd 1)))) ) ) )
            (loop
               (set (ofs P I) null)
               (? (== I Fd))
               (inc 'I) ) ) ) )
   (let Out:
      (outFile
         (let P (ofs (val $OutFiles) Fd)
            (if (val P)
               @
               (set P (alloc null (outFile T))) ) ) )
      (Out: tty (n0 (isatty (Out: fd Fd))))
      (Out: ix 0)
      (Out:) ) )

(de void closeInFile ((i32 . Fd))
   (when (> (val $InFDs) Fd)
      (let P (ofs (val $InFiles) Fd)
         (when (val P)
            (let In: (inFile @)
               (free (In: name))
               (In: name null)
               (In: fd -1) ) ) ) ) )

(de void closeOutFile ((i32 . Fd))
   (when (> (val $OutFDs) Fd)
      (let P (ofs (val $OutFiles) Fd)
         (when (val P)
            ((outFile @) fd -1) ) ) ) )

(local) (slow slowNb rdBytes rdBytesNb wrBytes clsChild wrChild flush flushAll)

(de i32 slow ((i8* . In))
   (let In: (inFile In)
      (In: ix 0)
      (loop
         (?
            (ge0
               (i32 (read (In: fd) (In: (buf)) BUFSIZ)) )
            (In: cnt @) )
         (? (<> (gErrno) EINTR)
            (In: cnt 0) )
         (sigChk 0) ) ) )

(de i32 slowNb ((i8* . In))
   (let In: (inFile In)
      (loop
         (let
            (Flg (nonBlocking (In: fd))
               N (i32 (read (In: fd) (In: (buf)) BUFSIZ)) )
            (fcntlSetFl (In: fd) Flg)
            (? (gt0 N)
               (In: ix 0)
               (In: cnt N) )
            (? (=0 N)
               (In: ix (In: cnt -1))
               0 ) )
         (? (== (gErrno) EAGAIN) -1)
         (? (<> @ EINTR)
            (In: ix (In: cnt 0)) )
         (sigChk 0) ) ) )

(de i1 rdBytes ((i32 . Fd) (i8* . P) (i32 . Cnt))
   (loop
      (loop
         (? (gt0 (i32 (read Fd P (i64 Cnt))))
            (inc 'P @)
            (dec 'Cnt @) )
         (unless (and @ (== (gErrno) EINTR))
            (ret NO) )
         (sigChk 0) )
      (? (=0 Cnt) YES) ) )

(de i64 rdBytesNb ((i32 . Fd) (i8* . P) (i32 . Cnt))
   (loop
      (let
         (Flg (nonBlocking Fd)
            N (i32 (read Fd P (i64 Cnt))) )
         (fcntlSetFl Fd Flg)
         (when (gt0 N)
            (loop
               (unless (dec 'Cnt N)
                  (ret 1) )
               (inc 'P N)
               (while
                  (le0
                     (setq N (i32 (read Fd P (i64 Cnt)))) )
                  (unless (and N (== (gErrno) EINTR))
                     (ret 0) )
                  (sigChk 0) ) ) )
         (? (=0 N) 0) )
      (? (== (gErrno) EAGAIN) -1)
      (? (<> @ EINTR) 0)
      (sigChk 0) ) )

(de i1 wrBytes ((i32 . Fd) (i8* . P) (i32 . Cnt))
   (loop
      (? (lt0 Fd) NO)
      (let N (i32 (write Fd P (i64 Cnt)))
         (if (lt0 N)
            (let E (gErrno)
               (? (== E EBADF) NO)
               (? (== E EPIPE) NO)
               (? (== E ECONNRESET) NO)
               (unless (== E EINTR)
                  (when (== Fd 2)  # Stderr
                     (bye 2) )
                  (writeErr ($ "bytes write: %s")) )
               (sigChk 0) )
            (? (=0 (dec 'Cnt N)) YES)
            (inc 'P N) ) ) ) )

(de void clsChild ((i8* . Cld))
   (let Cld: (child Cld)
      (when (== (Cld: pid) (val $Talking))
         (set $Talking 0) )
      (Cld: pid 0)
      (close (Cld: hear))
      (close (Cld: tell))
      (free (Cld: buf)) ) )

(de void wrChild ((i8* . Cld)  (i8* . P) (i32 . Cnt))
   (let (Cld: (child Cld)  C (Cld: cnt))
      (unless C
         (loop
            (let N (i32 (write (Cld: tell) P (i64 Cnt)))
               (if (lt0 N)
                  (let E (gErrno)
                     (? (== E EAGAIN))
                     (when (or (== E EPIPE) (== E ECONNRESET))
                        (clsChild Cld)
                        (ret) )
                     (unless (== E EINTR)
                        (writeErr ($ "child write: %s")) ) )
                  (unless (dec 'Cnt N)
                     (ret) )
                  (inc 'P N) ) ) ) )
      (let Siz (+ C Cnt 4)  # New buffer size
         (when (> Siz (hex "3FFFFFFF"))  # Allow max 1 GiB
            (sizeErr 0) )
         (let Q (ofs (Cld: buf (alloc (Cld: buf) (i64 Siz))) C)
            (set (i32* Q) Cnt)
            (memcpy (ofs Q 4) P (i64 Cnt))
            (Cld: cnt Siz) ) ) ) )

(de i1 flush ((i8* . Out))
   (ifn Out
      YES
      (let Out: (outFile Out)
         (ifn (Out: ix)
            YES
            (Out: ix 0)
            (wrBytes (Out: fd) (Out: (buf)) @) ) ) ) )

(de void flushAll ()
   (let (A (val $OutFiles)  N (val $OutFDs)  I (i32 0))
      (while (> N I)
         (flush (val (ofs A I)))
         (inc 'I) ) ) )

(local) (stdinByte getBinary binRead)

(de i32 stdinByte ()
   (let In: (inFile (val (val $InFiles)))  # Stdin
      (cond
         ((and
               (ge0 (In: fd))
               (or
                  (<> (In: ix) (In: cnt))
                  (and (ge0 @) (slow (In:))) ) )
            (let I (In: ix)
               (In: ix (+ I 1))
               (i32 (val (ofs (In: (buf)) I))) ) )
         ((In: tty) (bye 0))
         (T -1) ) ) )

(de i32 getBinary ()
   (let (In: (inFile (val $InFile))  I (In: ix))
      (when (== I (In: cnt))
         (when (or (lt0 I) (=0 (slow (In:))))  # Closed or EOF
            (ret -1) )
         (setq I 0) )
      (In: ix (+ I 1))
      (i32 (val (ofs (In: (buf)) I))) ) )

# Read binary PLIO expression
(de binRead ()
   (case (call $GetBin)
      (NIX $Nil)  # NIL
      (BEG
         (ifn (binRead)
            0
            (let (X (cons @ $Nil)  R (save X))
               (loop
                  (? (=0 (binRead)) @)
                  (? (== @ END) R)
                  (? (== @ -ZERO)  # DOT
                     (ifn (binRead)
                        0
                        (set 2 X (if (== @ END) R @))
                        R ) )
                  (setq X (set 2 X (cons @ $Nil))) ) ) ) )
      (DOT -ZERO)  # DOT -> -ZERO
      (END (i64 @))  # END
      (T
         (if (lt0 @)
            0  # EOF
            (let  # Atom
               (Tag (& @ 3)
                  Cnt (shr @ 2)
                  P (i64* (push NIL NIL ZERO NIL))  # [cnt last name link]
                  Q (link (ofs P 2)) )
               (cond
                  ((== Tag NUMBER)
                     (set P 3)  # 'cnt' for signed number
                     (when (== Cnt 63)  # More than one chunk
                        (loop
                           (loop
                              (when (lt0 (call $GetBin))
                                 (: 1
                                    (drop Q)
                                    (ret 0) ) )
                              (byteNum (i8 @) P)
                              (? (=0 (dec 'Cnt))) )
                           (when (lt0 (setq Cnt (call $GetBin)))
                              (goto 1) )
                           (? (<> Cnt 255)) )
                        (unless Cnt
                           (goto 2) ) )
                     (loop
                        (when (lt0 (call $GetBin))
                           (goto 1) )
                        (byteNum (i8 @) P)
                        (? (=0 (dec 'Cnt))) )
                     (: 2
                        (drop Q
                           (if (cnt? (val Q))
                              @
                              (let S (& (val (dig @)) 1)
                                 (| (half @) (shl S 3)) ) ) ) ) )
                  (T  # Symbol
                     (set P 4)  # 'cnt' for symbol name
                     (when (== Cnt 63)  # More than one chunk
                        (loop
                           (loop
                              (when (lt0 (call $GetBin))
                                 (goto 1) )
                              (byteSym (i8 @) P)
                              (? (=0 (dec 'Cnt))) )
                           (when (lt0 (setq Cnt (call $GetBin)))
                              (goto 1) )
                           (? (<> Cnt 255)) )
                        (unless Cnt
                           (goto 3) ) )
                     (loop
                        (when (lt0 (call $GetBin))
                           (goto 1) )
                        (byteSym (i8 @) P)
                        (? (=0 (dec 'Cnt))) )
                     (: 3
                        (drop Q
                           (let Nm (val Q)
                              (case Tag
                                 (TRANSIENT (consStr Nm))
                                 (INTERN (requestSym Nm))
                                 (T  # External
                                    (when (val $Extn)
                                       (let N
                                          (shl
                                             (& (i64 (+ (objFile Nm) @)) (hex "FFFF"))
                                             24 )  # Mask overflow
                                          (setq Nm
                                             (|
                                                (& Nm (hex "FFF00FFF00FFFFFF"))  # Mask object ID
                                                (&
                                                   (| N (shl N 12))
                                                   (hex "000FF000FF000000") ) ) ) ) )  # Mask file number
                                    (extern Nm) ) ) ) ) ) ) ) ) ) ) ) )

(local) (prCnt binPrint pr putTell prTell tellBeg tellEnd unsync)

# Binary print short number
(de void prCnt ((i8 . Tag) Num)
   (let N Num
      (while (setq N (shr N 8))
         (inc 'Tag 4) ) )
   (call $PutBin Tag)
   (loop
      (call $PutBin (i8 Num))
      (? (=0 (setq Num (shr Num 8)))) ) )

# Binary print expression
(de void binPrint (X)
   (cond
      ((cnt? X)
         (tailcall (prCnt (+ NUMBER 4) (shr X 3))) )
      ((big? X)
         (let (Y (pos X)  Z Y  N 8)
            (loop
               (let C (val (dig Z))
                  (? (cnt? (setq Z (val (big Z))))
                     (setq
                        Z (int Z)  # Normalize short
                        C (add C C)  # Get most significant bit of last digit
                        Z (add Z Z @@) ) )
                  (inc 'N 8) ) )
            (when Z  # Significant bits in short number
               (loop
                  (inc 'N)
                  (? (=0 (setq Z (shr Z 8)))) ) )
            (let (M (- N 63)  D (val (dig Y)))
               (when (ge0 M)
                  (setq N 63) )
               (setq Y (val (big Y)))
               (setq X (shr X X 4))  # Sign into highest bit
               (add X X)  # Keep in carry
               (setq D (add D D @@))
               (call $PutBin (i8 (shl N 2)))  # Output tag byte
               (let (S @@  C 8)
                  (loop
                     (loop
                        (call $PutBin (i8 D))  # Output next byte
                        (if (dec 'C)
                           (setq D (shr D 8))
                           (setq C 8)
                           (if (cnt? Y)
                              (setq D (int Y))
                              (setq
                                 D (val (dig Y))
                                 Y (val (big Y)) ) )
                           (setq
                              D (add D D S)
                              S @@ ) )
                        (? (=0 (dec 'N))) )
                     (? (lt0 M))
                     (? (=0 M) (call $PutBin 0))  # Output final zero
                     (when (ge0 (setq M (- (setq N M) 255)))
                        (setq N 255) )
                     (call $PutBin (i8 N)) ) ) ) ) )  # Output next chunk size
      ((nil? X) (call $PutBin NIX))
      ((pair X)
         (call $PutBin BEG)
         (let (P (circ X)  Z X)
            (loop
               (binPrint (car X))
               (? (nil? (shift X))
                  (call $PutBin END) )
               (? (atom X)
                  (call $PutBin DOT)
                  (binPrint X) )
               (? (== Z X)
                  (call $PutBin DOT)
                  (call $PutBin END) )
               (when (== P X)
                  (call $PutBin DOT)
                  (call $PutBin BEG)
                  (setq Z P) ) ) ) )
      ((sym? (val (tail X)))  # External symbol
         (let Nm (name (& @ -9))
            (when (val $Extn)
               (let N
                  (shl
                     (& (i64 (- (objFile Nm) @)) (hex "FFFF"))
                     24 )  # Mask overflow
                  (setq Nm
                     (|
                        (& Nm (hex "FFF00FFF00FFFFFF"))  # Mask object ID
                        (&
                           (| N (shl N 12))
                           (hex "000FF000FF000000") ) ) ) ) )  # Mask file number
            (tailcall
               (prCnt (+ EXTERN 4) (shr (shl Nm 2) 6)) ) ) )  # Strip status bits
      ((== (name @) ZERO) (call $PutBin NIX))
      (T
         (let
            (Nm @
               Tag
               (if (findSym X Nm (val $Intern))
                  (i8 INTERN)
                  (i8 TRANSIENT) ) )
            (if (cnt? Nm)
               (prCnt (+ Tag 4) (int Nm))
               (let (Y Nm  N 8)
                  (while (big? (setq Y (val (big Y))))
                     (inc 'N 8) )
                  (setq Y (int Y))
                  (while Y
                     (inc 'N)
                     (setq Y (shr Y 8)) )
                  (let (P (push 0 Nm)  M (- N 63)  C 8)  # [cnt name]
                     (when (ge0 M)
                        (setq N 63) )
                     (call $PutBin (+ Tag (i8 (shl N 2))))
                     (loop
                        (loop
                           (call $PutBin (symByte P))
                           (? (=0 (dec 'N))) )
                        (? (lt0 M))
                        (? (=0 M) (call $PutBin 0))
                        (when (ge0 (setq M (- (setq N M) 255)))
                           (setq N 255) )
                        (call $PutBin (i8 N)) ) ) ) ) ) ) ) )

(de void pr (X)
   (set $PutBin (fun (void i8) _putStdout))
   (tailcall (binPrint X)) )

(de void putTell ((i8 . B))
   (let P (val $Ptr)
      (set P B)
      (when (== (set $Ptr (inc P)) (val $End))
         (err 0 0 ($ "Tell PIPE_BUF") null) ) ) )

(de void prTell (X)
   (set
      $PutBin (fun (void i8) putTell)
      $Extn 0 )
   (tailcall (binPrint X)) )

(de void tellBeg ((i8* . P))
   (set
      $TellBuf P
      $End (ofs P (dec (val PipeBufSize)))
      (inc 'P 8) BEG  # 8 bytes space (PID and count)
      $Ptr (inc P) ) )  # Begin a list

(de void tellEnd ((i32 . Pid))
   (let (P (val $Ptr)  Q (val $TellBuf))
      (set P END)  # Close list
      (inc 'P)
      (let (D (i32 (- P Q))  N (- D 8))  # Size without PID and count
         (set
            (i32* Q) Pid
            (inc (i32* Q)) N )
         (when (val $Tell)
            (let Fd @
               (unless (wrBytes Fd Q D)
                  (close Fd)
                  (set $Tell 0) ) ) )
         (let
            (Cld (val $Child)  # Iterate children
                (In:) (stack))  # Assume stack is growing downwards
                  (> (Out:) (In:))
                  (> (In:) (Out:)) )
               ((inFile (In: file)) fd)
               ((outFile (Out: file)) fd) ) ) ) ) )

(local) (getIn put1 putOut)

(de i32 getIn ()
   (set $Chr
      (cond
         ((val $IoChar)
            (set $IoChar (shr @ 8))
            (i32 (i8 @)) )
         ((nil?
               (let (Iox: (ioxFrame (val $InFrames))  At (save (val $At)))
                  (prog2
                     (set
                        $Chr (Iox: chr)
                        (i8** $Get) (Iox: fun)
                        $InFrames (Iox: link) )
                     (eval (Iox: exe))
                     (set
                        $InFrames (Iox:)
                        $Get (fun (i32) getIn)
                        $At At )
                     (Iox: chr (val $Chr)) ) ) )
            -1 )
         ((sym? @)
            (let (S @  V (val (tail @)))
               (if
                  (or
                     (sym? V)
                     (not (cnt? (setq V (name V)))) )
                  (charErr 0 S)
                  (let C (int V)
                     (set $IoChar (shr C 8))
                     (i32 (i8 C)) ) ) ) )
         (T (symErr 0 @)) ) ) )

(de void put1 ((i8* . Iox) (i32 . C) (i32 . D))
   (let
      (Iox: (ioxFrame Iox)
         At (save (val $At))
         At2 (save (val $At2))
         At3 (save (val $At3)) )
      (set
         (i8** $Put) (Iox: fun)
         $OutFrames (Iox: link)
         $At2 (consStr (cnt (i64 C)))
         $At3 (if D (consStr (cnt (i64 @))) $Nil) )
      (eval (Iox: exe))
      (set
         $OutFrames (Iox:)
         $Put (fun (void i8) putOut)
         $At3 At3
         $At2 At2
         $At At ) ) )

(de void putOut ((i8 . B))
   (nond
      ((& B (hex "80"))  # Single byte
         (set $IoChar (i64 B)) )
      ((& B (hex "40"))  # Following byte
         (set $IoChar
            (|
               (val $IoChar)
               (shl
                  (i64 B)
                  (set $IoIx (+ (val $IoIx) 8)) ) ) )
         (when (set $IoCnt (dec (val $IoCnt)))
            (ret) ) )
      ((& B (hex "20"))
         (set $IoCnt 1  $IoIx 0  $IoChar (i64 B))
         (ret) )
      ((& B (hex "10"))
         (set $IoCnt 2  $IoIx 0  $IoChar (i64 B))
         (ret) )
      (NIL
         (set $IoCnt 3  $IoIx 0  $IoChar (i64 B))
         (ret) ) )
   (let (Iox: (ioxFrame (val $OutFrames))  C (i32 (val $IoChar)))
      (when (Iox: chr)
         (put1 (Iox:) @ C) )
      (Iox: chr C) ) )

(local) (pushInFile pushOutFile pushErrFile pushCtlFile)

(de void pushInFile ((i8* . Io) (i8* . In) (i32 . Pid))
   (let Io: (ioFrame Io)
      (Io: link (val $InFrames))
      (when (val $InFile)
         ((inFile @) chr (val $Chr)) )
      (set $Chr
         ((inFile (Io: file (set $InFile In))) chr) )
      (Io: fun (val (i8** $Get)))
      (Io: pid Pid)
      (set $InFrames (Io:)  $Get (fun (i32) _getStdin)) ) )

(de void pushOutFile ((i8* . Io) (i8* . Out) (i32 . Pid))
   (let Io: (ioFrame Io)
      (Io: link (val $OutFrames))
      (Io: file (set $OutFile Out))
      (Io: fun (val (i8** $Put)))
      (Io: pid Pid)
      (set $OutFrames (Io:)  $Put (fun (void i8) _putStdout)) ) )

(de void pushErrFile ((i8* . Ct))
   ((ctFrame Ct) link (val $ErrFrames))
   (set $ErrFrames Ct) )

(de void pushCtlFile ((i8* . Ct))
   ((ctFrame Ct) link (val $CtlFrames))
   (set $CtlFrames Ct) )

(local) (popInFiles popOutFiles popErrFiles popCtlFiles)

(de void popInFiles ()
   (let Io: (ioFrame (val $InFrames))
      (when (Io: file)
         (let In: (inFile @)
            (when (ge0 (In: fd))
               (ifn (Io: pid)
                  (In: chr (val $Chr))
                  (close (In: fd))
                  (closeInFile (In: fd))
                  (when (> (Io: pid) 1)
                     (waitFile @) ) ) ) ) )
      (set (i8** $Get) (Io: fun))
      (setq Io: (ioFrame (set $InFrames (Io: link))))
      (set $Chr
         (if (Io: file)
            ((inFile (set $InFile @)) chr)
            ((ioxFrame (Io:)) chr) ) ) ) )

(de void popOutFiles ()
   (let Io: (ioFrame (val $OutFrames))
      (cond
         ((Io: file)
            (let Out: (outFile @)
               (flush (val $OutFile))
               (when (ge0 (Out: fd))
                  (when (Io: pid)
                     (close (Out: fd))
                     (closeOutFile (Out: fd))
                     (when (> (Io: pid) 1)
                        (waitFile @) ) ) ) ) )
         (((ioxFrame (Io:)) chr)
            (put1 (Io:) @ 0) ) )
      (set (i8** $Put) (Io: fun))
      (setq Io: (ioFrame (set $OutFrames (Io: link))))
      (when (Io: file)
         (set $OutFile @) ) ) )

(de void popErrFiles ()
   (let Ct: (ctFrame (val $ErrFrames))
      (dup2 (Ct: fd) 2)  # Restore stderr
      (close (Ct: fd))
      (set $ErrFrames (Ct: link)) ) )

(de void popCtlFiles ()
   (let Ct: (ctFrame (val $CtlFrames))
      (if (ge0 (Ct: fd))
         (close @)
         (unLock (currFd 0) 0 0) )
      (set $CtlFrames (Ct: link)) ) )

# (path 'any) -> sym
(de _Path (Exe)
   (let Nm (xName (evSym (cdr Exe)))
      (mkStr (pathString Nm (b8 (pathSize Nm)))) ) )

(local) (pollfd hasData inReady getBlk waitFd)

(de i64* pollfd ((i32 . Fd))
   (let I (val $Nfds)
      (when (>= Fd I)
         (let P
            (set $Poll
               (i64*
                  (alloc
                     (i8* (val $Poll))
                     (* 8 #{pollfd}# (i64 (set $Nfds (+ Fd 1)))) ) ) )
            (loop
               (pollIgn (ofs P I))
               (? (== I Fd))
               (inc 'I) ) ) ) )
   (ofs (val $Poll) Fd) )

(de i1 hasData ((i32 . Fd))
   (and
      (> (val $InFDs) Fd)
      (val (ofs (val $InFiles) Fd))
      (let In: (inFile @)
         (and
            (ge0 (In: fd))
            (> (In: cnt) (In: ix)) ) ) ) )

(de i1 inReady ((i32 . Fd) (i1 . Flg))
   (let P (pollfd Fd)
      (cond
         ((>= Fd (val $InFDs))
            (readyIn P) )
         ((=0 (val (ofs (val $InFiles) Fd)))
            (readyIn P) )
         (T
            (let In: (inFile @)
               (if (lt0 (In: fd))
                  (readyIn P)
                  (or
                     (> (In: cnt) (In: ix))
                     (and
                        (readyIn P)
                        (or Flg (ge0 (slowNb (In:)))) ) ) ) ) ) ) ) )
(de i32 getBlk ()
   (let P (val $BlkPtr)
      (set $BlkPtr (inc P))
      (i32 (val P)) ) )

(de i64 waitFd (Exe (i32 . Fd) (i64 . Ms))
   (let
      (Run (save (val $Run))
         At (save (val $At))
         Buf (b8 (val PipeBufSize))
         Pn (b32 2)
         Tim (getMsec) )
      (stkChk Exe)
      (loop
         (let Dly Ms
            (when (ge0 Fd)
               (if (hasData Fd)
                  (setq Dly 0)
                  (pollIn Fd (pollfd Fd)) ) )
            (let R Run  # '*Run' elements
               (while (pair R)
                  (let X (++ R)
                     (cond
                        ((sign? (car X))
                           (let N (int (cadr X))
                              (when (> Dly N)
                                 (setq Dly N) ) ) )
                        ((<> (i32 (int @)) Fd)
                           (let N @
                              (if (hasData N)
                                 (setq Dly 0)
                                 (pollIn N (pollfd N)) ) ) ) ) ) ) )
            (when (and (val $Hear) (<> @ Fd))  # RPC listener
               (let N @
                  (if (hasData N)
                     (setq Dly 0)
                     (pollIn N (pollfd N)) ) ) )
            (when (val $Spkr)  # RPC speaker
               (pollIn @ (pollfd @))
               (let
                  (Cld (val $Child)  # Iterate children
                      (val 2 Pn) (val PipeBufSize))
                                          (sizeErr Exe) )
                                       ((rdBytes (Cld: hear) Buf @)
                                          (ifn (=0 (val Pn))
                                             (let
                                                (Cld2 (val $Child)  # Iterate children
                                                    Cld Cld2)
                                                            (Cld2: pid)
                                                            (or (lt0 (val Pn)) (== @ (Cld2: pid))) )
                                                         (wrChild Cld2 Buf (val 2 Pn)) ) )
                                                   (setq Cld2 (ofs Cld2 (child T))) ) )
                                             (set
                                                $BlkPtr Buf
                                                $GetBin (fun (i32) getBlk)
                                                $Extn 0 )
                                             (let E (binRead)
                                                (save E (evList E)) ) ) )
                                       (T
                                          (clsChild Cld)
                                          (goto 1) ) ) ) ) )
                           (when (readyOut (pollfd (Cld: tell)))
                              (let
                                 (P (ofs (Cld: buf) (Cld: ofs))  # Buffer pointer plus offset
                                    N (val (i32* P)) )  # Size
                                 (ifn (wrBytes (Cld: tell) (ofs P 4) N)
                                    (clsChild Cld)
                                    (setq N (Cld: ofs (+ (Cld: ofs) N 4)))  # Add size plus size of size to buffer offset
                                    (when (>= (* 2 N) (Cld: cnt))
                                       (when (Cld: cnt (- (Cld: cnt) N))
                                          (memcpy
                                             (Cld: buf)
                                             (ofs (Cld: buf) N)
                                             (i64 (Cld: cnt)) )
                                          (Cld: buf (alloc (Cld: buf) (i64 (Cld: cnt)))) )
                                       (Cld: ofs 0) ) ) ) ) ) )
                     (: 1
                        (setq Cld (ofs Cld (child T))) ) ) )
               (when
                  (and
                     (=0 (val $Talking))
                     (readyIn (pollfd (val $Spkr)))
                     (gt0 (rdBytesNb (val $Spkr) (i8* Pn) 4)) )  # Slot
                  (let Cld (ofs (val $Child) (* (val Pn) (child T)))
                     (when ((child Cld) pid)
                        (set $Talking @)
                        (wrChild Cld $TBuf 2) ) ) )
               (set $Protect (dec (val $Protect))) )
            (let N (val $Hear)  # RPC listener
               (when (and N (<> N Fd) (inReady N NO))
                  (let In (val $InFile)
                     (set
                        $InFile (val (ofs (val $InFiles) (val $Hear)))
                        $GetBin (fun (i32) getBinary)
                        $Extn 0 )
                     (let E (binRead)
                        (cond
                           ((=0 E)
                              (close N)
                              (closeInFile N)
                              (closeOutFile N)
                              (set $Hear 0) )
                           ((t? E) (set $Sync YES))
                           (T (save E (evList E))) ) )
                     (set $InFile In) ) ) )
            (let R Run
               (while (pair R)
                  (let X (++ R)
                     (cond
                        ((sign? (car X))
                           (let Y (cdr X)
                              (if (gt0 (- (int (car Y)) Dif))  # Not yet timed out
                                 (set Y (sign (cnt @)))   # Store short negative number
                                 (let V (car X)  # Timeout value
                                    (set Y (pos V)  $At V)
                                    (exec (cdr Y)) ) ) ) )  # Run body
                        ((<> (i32 (int @)) Fd)
                           (when (inReady @ NO)
                              (set $At (car X))  # File descriptor
                              (exec (cdr X)) ) ) ) ) ) )  # Run body
            (and
               (gt0 Ms)
               (<> Ms 292MY)
               (lt0 (dec 'Ms Dif))
               (setq Ms 0) )
            (setq Tim Now) )
         (sigChk Exe)
         (? (or (=0 Ms) (lt0 Fd) (inReady Fd YES)))
         (setq Run (safe (val $Run))) )
      (set $At At)
      Ms ) )

# (wait 'cnt|NIL . prg) -> any
# (wait 'cnt|NIL T 'fd) -> fd|NIL
(de _Wait (Exe)
   (let
      (X (cdr Exe)
         N
         (if (nil? (eval (++ X)))
            292MY
            (xCnt Exe @) ) )
      (if (t? (car X))
         (let Fd (evCnt Exe (cdr X))  # Wait for file descriptor
            (if (waitFd Exe (i32 Fd) N)
               (cnt Fd)
               $Nil ) )
         (loop
            (? (not (nil? (run X))) @)  # 'prg'
            (? (=0 (waitFd Exe -1 N)) (run X))  # Timeout
            (setq N @) ) ) ) )

# (sync) -> flg
(de _Sync (Exe)
   (cond
      ((or (=0 (val $Mic)) (=0 (val $Hear)))
         $Nil )
      ((val $Sync) $T)
      (T
         (let (Mic (val $Mic)  P (i8* $Slot)  Cnt 4)
            (loop
               (let N (write Mic P Cnt)
                  (cond
                     ((ge0 N)
                        (? (=0 (dec 'Cnt N)))
                        (setq P (ofs P N)) )
                     ((== (gErrno) EINTR) (sigChk Exe))
                     (T (writeErr ($ "sync write: %s"))) ) ) ) )
         (set $Sync NO)
         (loop
            (waitFd Exe -1 292MY)
            (? (val $Sync)) )
         $T ) ) )

# (hear 'cnt) -> cnt
(de _Hear (Exe)
   (let
      (X (eval (cadr Exe))
         Fd (i32 (xCnt Exe X)) )
      (when
         (or
            (lt0 Fd)
            (>= Fd (val $InFDs))
            (=0 (val (ofs (val $InFiles) Fd)))
            (lt0 ((inFile @) fd)) )
         (badFd Exe X) )
      (when (val $Hear)
         (close @)
         (closeInFile @)
         (closeOutFile @) )
      (set $Hear Fd)
      X ) )

# (tell ['cnt] 'sym ['any ..]) -> any
(de _Tell (Exe)
   (cond
      ((and (=0 (val $Tell)) (=0 (val $Children)))
         $Nil )
      ((atom (cdr Exe))
         (unsync)
         $Nil )
      (T
         (let (X @  Y (eval (car X))  Pid (i32 -1))
            (when (cnt? Y)
               (setq
                  Pid (i32 (int @))
                  Y (eval (car (shift X))) ) )
            (let (TellBuf (val $TellBuf)  Ptr (val $Ptr)  End (val $End))
               (tellBeg (b8 (val PipeBufSize)))
               (stkChk Exe)
               (loop
                  (prTell Y)
                  (? (atom (shift X)))
                  (setq Y (eval (car X))) )
               (tellEnd Pid)
               (set $TellBuf TellBuf  $Ptr Ptr  $End End)
               Y ) ) ) ) )

# (poll 'cnt) -> cnt | NIL
(de _Poll (Exe)
   (let
      (C (eval (cadr Exe))
         Fd (i32 (xCnt Exe C)) )
      (when (or (lt0 Fd) (>= Fd (val $InFDs)))
         (badFd Exe C) )
      (let In: (inFile (val (ofs (val $InFiles) Fd)))
         (ifn (and (In:) (ge0 (In: fd)))
            $Nil
            (let Poll (b64 1)
               (pollIn Fd Poll)
               (loop
                  (? (> (In: cnt) (In: ix)) C)
                  (while (lt0 (gPoll Poll 1 0))
                     (unless (== (gErrno) EINTR)
                        (selectErr Exe) ) )
                  (? (not (readyIn Poll)) $Nil)
                  (? (ge0 (slowNb (In:))) C) ) ) ) ) ) )

(local) (rdOpen wrOpen erOpen ctOpen)

(de void rdOpen (Exe X (i8* . Io))
   (cond
      ((nil? X)
         (pushInFile Io (val (val $InFiles)) 0) )  # Stdin
      ((num? X)
         (let N (i32 (int X))
            (pushInFile Io
               (cond
                  ((sign? X)
                     (let In (val $InFrames)
                        (loop
                           (unless (setq In ((ioFrame In) link))
                              (badFd Exe X) )
                           (? (=0 (dec 'N))) )
                        ((ioFrame In) file) ) )
                  ((>= N (val $InFDs))
                     (badFd Exe X) )
                  ((=0 (val (ofs (val $InFiles) N)))
                     (badFd Exe X) )
                  (T @) )
               0 ) ) )
      ((sym? X)
         (let
            (Nm (xName X)
               S (pathString Nm (b8 (pathSize Nm)))
               Fd T )
            (while (lt0 (setq Fd (openRd S)))
               (unless (== (gErrno) EINTR)
                  (openErr Exe X) )
               (sigChk Exe) )
            (closeOnExec Exe Fd)
            (pushInFile Io (initInFile Fd (strdup S)) 1) ) )
      (T  # Pipe
         (let
            (Pfd (b32 2)
               Av (b8* (inc (length X)))
               Cmd (xName (xSym (car X))) )
            (when (lt0 (pipe Pfd))
               (pipeErr Exe) )
            (set Av (pathString Cmd (b8 (pathSize Cmd))))
            (let A Av
               (while (pair (shift X))
                  (let Nm (xName (xSym (car X)))
                     (set (inc 'A)
                        (bufString Nm (b8 (bufSize Nm))) ) ) )
               (set (inc 'A) null) )
            (cond
               ((lt0 (fork)) (forkErr Exe))
               ((=0 @)  # In child
                  (setpgid 0 0)  # Set process group
                  (close (val Pfd))  # Close read pipe
                  (unless (== (val 2 Pfd) 1)
                     (dup2 @ 1)  # Dup write pipe to STDOUT_FILENO
                     (close @) )
                  (signal (val SIGPIPE Sig) (val SigDfl))  # Default SIGPIPE
                  (execvp (val Av) Av)  # Execute program
                  (execErr (val Av)) ) )  # Error if failed
            # In parent
            (let (Pid @  Fd (val Pfd))
               (setpgid Pid 0)  # Set process group
               (close (val 2 Pfd))  # Close write pipe
               (closeOnExec Exe Fd)
               (pushInFile Io (initInFile Fd null) Pid) ) ) ) ) )

(de void wrOpen (Exe X (i8* . Io))
   (cond
      ((nil? X)
         (pushOutFile Io (val 2 (val $OutFiles)) 0) )  # Stdout
      ((num? X)
         (let N (i32 (int X))
            (pushOutFile Io
               (cond
                  ((sign? X)
                     (let Out (val $OutFrames)
                        (loop
                           (unless (setq Out ((ioFrame Out) link))
                              (badFd Exe X) )
                           (? (=0 (dec 'N))) )
                        ((ioFrame Out) file) ) )
                  ((>= N (val $OutFDs))
                     (badFd Exe X) )
                  ((=0 (val (ofs (val $OutFiles) N)))
                     (badFd Exe X) )
                  (T @) )
               0 ) ) )
      ((sym? X)
         (let
            (Nm (xName X)
               S (pathString Nm (b8 (pathSize Nm)))
               Flg (== (val S) (char "+"))
               Fd T )
            (when Flg
               (setq S (ofs S 1)) )
            (while (lt0 (setq Fd (if Flg (openRdWrAppend S) (openWr S))))
               (unless (== (gErrno) EINTR)
                  (openErr Exe X) )
               (sigChk Exe) )
            (closeOnExec Exe Fd)
            (pushOutFile Io (initOutFile Fd) 1) ) )
      (T  # Pipe
         (let
            (Pfd (b32 2)
               Av (b8* (inc (length X)))
               Cmd (xName (xSym (car X))) )
            (when (lt0 (pipe Pfd))
               (pipeErr Exe) )
            (set Av (pathString Cmd (b8 (pathSize Cmd))))
            (let A Av
               (while (pair (shift X))
                  (let Nm (xName (xSym (car X)))
                     (set (inc 'A)
                        (bufString Nm (b8 (bufSize Nm))) ) ) )
               (set (inc 'A) null) )
            (cond
               ((lt0 (fork)) (forkErr Exe))
               ((=0 @)  # In child
                  (setpgid 0 0)  # Set process group
                  (close (val 2 Pfd))  # Close write pipe
                  (when (val Pfd)  # STDIN_FILENO
                     (dup2 @ 0)  # Dup read pipe to STDIN_FILENO
                     (close @) )
                  (execvp (val Av) Av)  # Execute program
                  (execErr (val Av)) ) )  # Error if failed
            # In parent
            (let (Pid @  Fd (val 2 Pfd))
               (setpgid Pid 0)  # Set process group
               (close (val Pfd))  # Close read pipe
               (closeOnExec Exe Fd)
               (pushOutFile Io (initOutFile Fd) Pid) ) ) ) ) )

(de void erOpen (Exe X (i8* . Ct))
   (let Ct: (ctFrame Ct)
      (Ct: fd (dup 2))  # Stderr
      (let Fd
         (if (nil? (needSymb Exe X))
            (dup ((outFile (val $OutFile)) fd))
            (let
               (Nm (xName X)
                  S (pathString Nm (b8 (pathSize Nm)))
                  Flg (== (val S) (char "+")) )
               (when Flg
                  (setq S (ofs S 1)) )
               (while (lt0 (if Flg (openWrAppend S) (openWr S)))
                  (unless (== (gErrno) EINTR)
                     (openErr Exe X) )
                  (sigChk Exe) )
               (closeOnExec Exe @)
               @ ) )
         (dup2 Fd 2)
         (close Fd) )
      (pushErrFile Ct) ) )

(de void ctOpen (Exe X (i8* . Ct))
   (let Ct: (ctFrame Ct)
      (cond
         ((nil? (needSymb Exe X))
            (Ct: fd -1)
            (rdLockWait (currFd Exe) 0) )
         ((t? X)
            (Ct: fd -1)
            (wrLockWait (currFd Exe) 0) )
         (T
            (let
               (Nm (xName X)
                  S (pathString Nm (b8 (pathSize Nm)))
                  Flg (== (val S) (char "+")) )
               (when Flg
                  (setq S (ofs S 1)) )
               (while (lt0 (openRdWrCreate S))
                  (unless (== (gErrno) EINTR)
                     (openErr Exe X) )
                  (sigChk Exe) )
               (let Fd (Ct: fd @)
                  (if Flg
                     (rdLockWait Fd 0)
                     (wrLockWait Fd 0) )
                  (closeOnExec Exe Fd) ) ) ) )
      (pushCtlFile Ct) ) )

(local) (read0 getChar skipc comment skip)

(de read0 (i1))

(de i32 rlGetc ((i8* . F))
   (if (waitFd 0 0 292MY)
      (stdinByte)
      -1 ) )

(de i32 rlAvail ()
   (i32 (waitFd 0 0 60)) )

(de i32 _getStdin ()
   (let In: (inFile (val $InFile))
      (set $Chr
         (cond
            ((lt0 (In: fd)) -1)  # EOF
            ((or (In: fd) (not (In: tty)))  # Not stdin
               (if
                  (and
                     (== (In: ix) (In: cnt))
                     (or (lt0 (In: ix)) (=0 (slow (In:)))) )
                  -1
                  (let I (In: ix)
                     (prog1
                        (i32 (val (ofs (In: (buf)) I)))
                        (when (== @ (char "\n"))
                           (In: line (+ (In: line) 1)) )
                        (In: ix (+ I 1)) ) ) ) )
            (T
               (let P (val $LinePtr)
                  (unless P
                     (when (val $LineBuf)
                        (free @)
                        (set $LineBuf null) )
                     (flushAll)
                     (unless (setq P (set $LineBuf (gReadline (val $LinePrmt))))
                        (wrnl)
                        (when (or (val $Bind) (== (val $LinePrmt) (val $ContPrmt)))
                           (err 0 0 $Empty null) )  # quit
                        (bye 0) )
                     (set $LinePrmt (val $ContPrmt))
                     (unless
                        (or
                           (=0 (val P))
                           (== @ 32)
                           (and
                              (== @ (char "."))
                              (=0 (val (inc P))) )
                           (and (currentLine) (=0 (strcmp @ P))) )
                        (add_history P) ) )
                  (nond
                     ((val P)
                        (set $LinePtr null)
                        (char "\n") )
                     (NIL
                        (set $LinePtr (inc P))
                        (i32 @) ) ) ) ) ) ) ) )

(de i32 getChar ((i32 . C))
   (cond
      ((>= 127 C) C)  # Single byte
      ((== C (hex "FF")) (i32 TOP))  # Infinite
      (T
         (let B
            (ifn (& C (hex "20"))  # Two bytes
               (& C (hex "1F"))  # First byte 110xxxxx
               (let A
                  (ifn (& C (hex "10"))  # Three bytes
                     (& C (hex "0F"))  # First byte 1110xxxx
                     (|  # Four bytes
                        (shl (& C 7) 6)  # First byte 11110xxx
                        (& (call $Get) (hex "3F")) ) )  # 10xxxxxx
                  (| (shl A 6) (& (call $Get) (hex "3F"))) ) )
            (| (shl B 6) (& (call $Get) (hex "3F"))) ) ) ) )

# Skip White Space and Comments
(de i32 skipc ((i32 . C))
   (let Chr (val $Chr)
      (loop
         (while (>= 32 Chr)  # White space
            (when (lt0 (setq Chr (call $Get)))
               (ret Chr) ) )
         (unless (== Chr C)
            (ret Chr) )
         (until (== (setq Chr (call $Get)) (char "\n"))
            (when (lt0 Chr)
               (ret Chr) ) )
         (setq Chr (call $Get)) ) ) )

(de void comment ()
   (let Chr (call $Get)
      (if (== Chr (char "{"))
         (let N 0
            (loop
               (? (lt0 (setq Chr (call $Get))))
               (if
                  (and
                     (== Chr (char "#"))
                     (== (setq Chr (call $Get)) (char "{")) )
                  (inc 'N)
                  (?
                     (and
                        (== Chr (char "}"))
                        (== (setq Chr (call $Get)) (char "#"))
                        (lt0 (dec 'N)) ) ) ) ) )
         (until (== Chr (char "\n"))
            (? (lt0 Chr))
            (setq Chr (call $Get)) ) )
      (call $Get) ) )

(de i32 skip ()
   (loop
      (let Chr (val $Chr)
         (when (lt0 Chr)
            (ret Chr) )
         (while (>= (char " ") Chr)
            (when (lt0 (setq Chr (call $Get)))
               (ret Chr) ) )
         (unless (== Chr (char "#"))
            (ret Chr) )
         (comment) ) ) )

(local) (uniChr testEsc anonymous rdAtom rdl rdList)

(de i32 uniChr ((i32 . Chr))
   (when (and (>= Chr (char "0")) (>= (char "9") Chr))
      (dec 'Chr (char "0"))
      (until (== (call $Get) (char "\\"))
         (unless
            (and
               (>= (val $Chr) (char "0"))
               (>= (char "9") (val $Chr)) )
            (badInput) )
         (setq Chr
            (+ (* Chr 10) (- (val $Chr) (char "0"))) ) ) )
   Chr )

(de i1 testEsc ((i32 . Chr))
   (loop
      (? (lt0 Chr) NO)
      (? (== Chr (char "\^"))  # Control character
         (when (== (setq Chr (call $Get)) (char "@"))
            (badInput) )
         (set $Chr
            (if (== Chr (char "?"))
               127
               (& Chr (hex "1F")) ) )
         YES )
      (? (<> Chr (char "\\"))  # No Backslash
         (set $Chr (getChar Chr))
         YES )
      (? (<> (char "\n") (setq Chr (call $Get)))  # Backslash: Skip '\'
         (case Chr
            ((char "b") (set $Chr (char "\b")))
            ((char "e") (set $Chr (char "\e")))
            ((char "n") (set $Chr (char "\n")))
            ((char "r") (set $Chr (char "\r")))
            ((char "t") (set $Chr (char "\t")))
            (T (set $Chr (uniChr Chr))) )
         YES )
      (loop
         (setq Chr (call $Get))
         (?
            (and
               (<> Chr (char " "))
               (<> Chr (char "\t")) ) ) ) ) )

(de anonymous (Nm)
   (let P (push 0 Nm)  # [cnt name]
      (unless (== (symByte P) (char "$"))  # Starting with '$'
         (ret 0) )
      (let B (- (symByte P) (char "0"))
         (unless (>= 7 B)  # Octal Digit
            (ret 0) )
         (let N (i64 B)
            (loop
               (? (=0 (symByte P))
                  (sym (shl N 4)) )  # Make symbol pointer
               (? (> (- @ (char "0")) 7) 0)
               (setq N (| (i64 @) (shl N 3))) ) ) ) ) )

(de rdAtom ((i32 . Chr))
   (let
      (Int (save (val $Intern))  # Current symbol namespaces
         P (push 4 NIL ZERO NIL)  # [cnt last name link]
         C (val $Chr) )
      (when
         (and
            (== Chr (char "%"))
            (== C (char "~")) )
         (when (nil? (cdr Int))
            (symNspErr 0 $rem) )
         (set $Intern @)
         (setq Chr (call $Get)  C (call $Get)) )
      (link (ofs P 2))
      (byteSym (i8 Chr) P)  # Pack first byte
      (setq Chr C)
      (while (ge0 Chr)
         (if (== Chr (char "~"))  # Namespace
            (let S (requestSym (val 3 P))  # Find or create symbol
               (needNsp 0 S)
               (set (set $Intern (any $Cell)) S)  # Switch symbol namespace
               (set P 4  3 P ZERO) )  # Build new name
            (? (strchr $Delim Chr))
            (when (== Chr (char "\\"))
               (setq Chr (uniChr (call $Get))) )
            (byteSym (i8 Chr) P) )
         (setq Chr (call $Get)) )
      (prog1
         (let (Nm (val 3 P)  L (val $Intern))
            (cond
               ((== Nm ZERO) (badInput))
               ((== L (any $Cell))
                  (intern 0 $Nil Nm (cdar (car @)) $Nil NO) )
               ((symToNum Nm (int (val $Scl)) (char ".") 0) @)
               ((anonymous Nm) @)
               ((and (== (car L) $priv) (nil? (cdr L)))
                  (intern (consSym Nm $Nil) 0 Nm $PrivT $Nil YES) )
               (T (requestSym Nm)) ) )
         (set $Intern Int) ) ) )

(de void rdl (R P)
   (loop
      (? (== (skip) (char ")"))
         (call $Get) )
      (? (== @ (char "]")))
      (cond
         ((== @ (char "."))
            (? (strchr $Delim (call $Get))
               (setq P
                  (set 2 P
                     (if
                        (or
                           (== (skip) (char ")"))
                           (== @ (char "]")) )
                        R
                        (read0 NO) ) ) )
               (cond
                  ((== (skip) (char ")"))
                     (call $Get) )
                  ((<> (val $Chr) (char "]"))
                     (err 0 P ($ "Bad dotted pair") null) ) ) )
            (setq P
               (set 2 P (cons (rdAtom (char ".")) $Nil)) ) )
         ((== @ (char "~"))
            (call $Get)
            (let (X (save (read0 NO))  R (eval X))
               (cond
                  ((nil? R))
                  ((atom R)
                     (set 2 P (cons R $Nil))
                     (shift P) )
                  (T
                     (set 2 P R)
                     (while (pair (cdr P))
                        (shift P) ) ) ) ) )
         (T
            (setq P
               (set 2 P (cons (read0 NO) $Nil)) ) ) ) ) )

(de rdList ()
   (stkChk 0)
   (call $Get)
   (save -ZERO)
   (loop
      (? (== (skip) (char ")"))  # Empty list
         (call $Get)
         $Nil )
      (? (== @ (char "]")) $Nil)  # Empty list
      (? (<> @ (char "~"))  # Read macro
         (let R (safe (cons (read0 NO) $Nil))
            (rdl R R)
            R ) )
      (call $Get)
      (let (X (safe (read0 NO))  R (eval X))
         (? (not (nil? R))
            (if (atom (safe R))
               (rdl (safe (setq R (cons R $Nil))) R)
               (let L R
                  (while (pair (cdr L))
                     (setq L @) )
                  (rdl R L) ) )
            R ) ) ) )

(de read0 ((i1 . Top))
   (let C (skip)
      (when Top
         (let In: (inFile (val $InFile))
            (In: src (In: line)) ) )
      (cond
         ((lt0 C)
            (unless Top (eofErr))
            $Nil )
         ((== C (char "("))
            (prog1
               (rdList)
               (and
                  Top
                  (== (val $Chr) (char "]"))
                  (call $Get) ) ) )
         ((== C (char "["))
            (let X (rdList)
               (unless (== (val $Chr) (char "]"))
                  (err 0 X ($ "Super parentheses mismatch") null) )
               (call $Get)
               X ) )
         ((== C (char "'"))
            (call $Get)
            (cons $Quote (read0 Top)) )
         ((== C (char ","))
            (call $Get)
            (let
               (Tr1 (save (val $Transient))
                  Tr2 (save (val 2 $Transient)) )
               (set $Transient (set 2 $Transient $Nil))
               (prog1
                  (let X (read0 Top)
                     (if (t? (val $Uni))
                        X
                        (save X
                           (if (pair (idxPut $Uni X $T))
                              (car @)
                              X ) ) ) )
                  (set 2 $Transient Tr2)
                  (set $Transient Tr1) ) ) )
         ((== C (char "`"))
            (call $Get)
            (let E (read0 Top)
               (save E
                  (eval E) ) ) )
         ((== C (char "\""))
            (if (== (setq C (call $Get)) (char "\""))
               (prog (call $Get) $Nil)  # Empty string
               (unless (testEsc C) (eofErr))
               (let
                  (P (push 4 NIL ZERO NIL)  # [cnt last name link]
                     Q (link (ofs P 2)) )
                  (loop
                     (charSym (val $Chr) P)
                     (? (== (setq C (call $Get)) (char "\"")))
                     (unless (testEsc C) (eofErr)) )
                  (call $Get)  # Skip "\""
                  (drop Q
                     (intern 0 0 (val Q) $Transient $Nil NO) ) ) ) )
         ((== C (char "{"))
            (prog1
               (if (== (setq C (call $Get)) (char "}"))
                  (consSym ZERO $Nil)  # Empty: New anonymous symbol
                  (let F (i32 0)  # File number
                     (while (>= C (char "@"))
                        (when (> C (char "O"))  # A-O range
                           (badInput) )
                        (setq
                           F (| (shl F 4) (- C (char "@")))
                           C (call $Get) ) )
                     (let N 0  # Id
                        (loop
                           (unless (and (>= C (char "0")) (>= (char "7") C))
                              (badInput) )
                           (setq N
                              (|
                                 (shl N 3)
                                 (i64 (- C (char "0"))) ) )
                           (? (== (setq C (call $Get)) (char "}"))) )
                        (extern (extNm F N)) ) ) )
               (call $Get) ) )  # Skip "}"
         ((or (== C (char ")")) (== C (char "]")) (== C (char "~")))
            (badInput) )
         (T
            (when (== C (char "\\"))
               (call $Get) )
            (setq C (val $Chr))
            (call $Get)
            (rdAtom C) ) ) ) )

(local) (read1 noToken token)

(de read1 ((i32 . End))
   (unless (val $Chr)
      (call $Get) )
   (if (== End (val $Chr))
      $Nil
      (read0 YES) ) )

(inline noToken (C Set)
   (not
      (or
         (== C (char "\\"))
         (and (>= (char "z") C) (>= C (char "a")))
         (and (>= (char "Z") C) (>= C (char "A")))
         (strchr Set C) ) ) )

(de token (Set (i32 . Cmt))
   (let C (if (val $Chr) @ (call $Get))
      (cond
         ((lt0 (skipc Cmt)) 0)  # Skip white space and comments
         ((== (setq C @) (char "\""))
            (cond
               ((== (setq C (call $Get)) (char "\""))  # Empty string
                  (call $Get)
                  $Nil )
               ((not (testEsc C)) $Nil)
               (T
                  (let
                     (Y (cons (mkChar (val $Chr)) $Nil)
                        R (save Y) )
                     (loop
                        (? (== (setq C (call $Get)) (char "\""))
                           (call $Get) )  # Skip "\""
                        (? (not (testEsc C)))
                        (setq Y
                           (set 2 Y (cons (mkChar (val $Chr)) $Nil)) ) )
                     R ) ) ) )
         ((and (>= (char "9") C) (>= C (char "0")))
            (let P (push 4 NIL ZERO NIL)  # [cnt last name link]
               (link (ofs P 2) T)
               (loop
                  (byteSym (i8 C) P)
                  (?
                     (and
                        (<> (setq C (call $Get)) (char "."))
                        (or (> (char "0") C) (> C (char "9"))) ) ) )
               (symToNum
                  (val 3 P)
                  (int (val $Scl))
                  (char ".")
                  0 ) ) )
         (T
            (let
               (Nm (xName Set)
                  S (bufString Nm (b8 (bufSize Nm))) )
               (if
                  (or
                     (== C (char "+"))
                     (== C (char "-"))
                     (noToken C S) )
                  (prog1
                     (mkChar (getChar C))
                     (call $Get) )
                  (when (== C (char "\\"))
                     (call $Get) )
                  (let P (push 4 NIL ZERO NIL)  # [cnt last name link]
                     (link (ofs P 2) T)
                     (loop
                        (byteSym (i8 C) P)
                        (?
                           (and
                              (noToken (setq C (call $Get)) S)
                              (or (> (char "0") C) (> C (char "9"))) ) )
                        (when (== C (char "\\"))
                           (call $Get) ) )
                     (requestSym (val 3 P)) ) ) ) ) ) ) )

# (read ['sym1 ['sym2]]) -> any
(de _Read (Exe)
   (let X (cdr Exe)
      (prog1
         (if (atom X)
            (read1 0)
            (let Y (save (needSymb Exe (eval (++ X))))
               (if (token Y (firstChar (needSymb Exe (eval (car X)))))
                  @
                  $Nil ) ) )
         (and
            (== (val $Chr) (char "\n"))
            (== (val $InFile) (val (val $InFiles)))  # Stdin
            (set $Chr 0) ) ) ) )

# (key ['cnt ['var]]) -> sym
(de _Key (Exe)
   (flushAll)
   (let
      (X (cdr Exe)
         Cnt
         (if (nil? (eval (++ X)))
            292MY
            (xCnt Exe @) )
         Var
         (save
            (if (nil? (eval (car X)))
               -ZERO
               (needChkVar Exe @) ) )
         Raw (val Termio) )
      (prog2
         (setRaw)
         (if (waitFd Exe 0 Cnt)
            (let (Ms @  C (stdinByte))
               (unless (== Var -ZERO)
                  (set Var (cnt Ms)) )
               (mkChar
                  (cond
                     ((>= 127 C) C)  # Single byte
                     ((== C (hex "FF")) (i32 TOP))  # Infinite
                     (T
                        (let B
                           (ifn (& C (hex "20"))  # Two bytes
                              (& C (hex "1F"))  # First byte 110xxxxx
                              (let A
                                 (ifn (& C (hex "10"))  # Three bytes
                                    (& C (hex "0F"))  # First byte 1110xxxx
                                    (|  # Four bytes
                                       (shl (& C 7) 6)  # First byte 11110xxx
                                       (& (stdinByte) (hex "3F")) ) )  # 10xxxxxx
                                 (| (shl A 6) (& (stdinByte) (hex "3F"))) ) )
                           (| (shl B 6) (& (stdinByte) (hex "3F"))) ) ) ) ) )
            $Nil )
         (unless Raw
            (setCooked) ) ) ) )

# (peek) -> sym
(de _Peek (Exe)
   (let C (if (val $Chr) @ (call $Get))
      (if (lt0 C) $Nil (mkChar C)) ) )

# (char) -> sym
# (char 'cnt) -> sym
# (char T) -> sym
# (char 'sym) -> cnt
(de _Char (Exe)
   (let X (cdr Exe)
      (cond
         ((atom X)
            (let Chr (if (val $Chr) @ (call $Get))
               (prog1
                  (if (lt0 Chr)
                     $Nil
                     (mkChar (getChar Chr)) )
                  (call $Get) ) ) )
         ((cnt? (eval (car X)))
            (if (int @)
               (mkChar (i32 @))
               $Nil ) )
         ((t? @) (mkChar TOP))
         ((symb? @) (cnt (i64 (firstChar @))))
         (T (atomErr Exe @)) ) ) )

# (skip ['any]) -> sym
(de _Skip (Exe)
   (if (lt0 (skipc (firstChar (evSym (cdr Exe)))))
      $Nil
      (mkChar @) ) )

# (eol) -> flg
(de _Eol (Exe)
   (let C (if (val $Chr) @ (call $Get))
      (if (or (le0 C) (== C (char "\n")))
         $T
         $Nil ) ) )

# (eof ['flg]) -> flg
(de _Eof (Exe)
   (nond
      ((nil? (eval (cadr Exe)))
         (set $Chr -1)
         $T )
      ((=0 (val $Chr))
         (if (lt0 @) $T $Nil) )
      (NIL
         (if (lt0 (call $Get)) $T $Nil) ) ) )

# (from 'any ..) -> sym
(de _From (Exe)
   (let
      (X (cdr Exe)
         N 1
         Y (evSym X)
         Nm (xName Y)
         L
         (link
            (push Y NIL 0  # [sym link ix str]
               (any (bufString Nm (b8 (bufSize Nm)))) ) )
         P L )
      (while (pair (shift X))
         (setq
            Y (evSym X)
            Nm (xName Y)
            L
            (link
               (push Y NIL 0  # [sym link ix str]
                  (any (bufString Nm (b8 (bufSize Nm)))) ) ) )
         (inc 'N) )
      (unless (val $Chr)
         (call $Get) )
      (while (ge0 (val $Chr))
         (let (B (i8 @)  Q (i64* L)  I N)
            (loop
               (loop
                  (let S (ofs (i8* (val 4 Q)) (val 3 Q))
                     (when (== B (val S))  # Bytes match
                        (set 3 Q (inc (val 3 Q)))  # Increment index
                        (? (val 2 S))  # Not end of string
                        (call $Get) # Skip next input byte
                        (drop P)
                        (ret (val Q)) ) )  # Return matched symbol
                  (? (=0 (val 3 Q)))  # Still at beginning of string
                  (let S (ofs (i8* (val 4 Q)) 1)  # Pointer to second byte
                     (while (set 3 Q (dec (val 3 Q)))  # Decrement index
                        (? (=0 (memcmp (i8* (val 4 Q)) S @)))
                        (inc 'S) ) ) )
               (? (=0 (dec 'I)))
               (setq Q (i64* (val 2 Q))) ) )
         (call $Get) )
      (drop P)
      $Nil ) )

# (till 'any ['flg]) -> lst|sym
(de _Till (Exe)
   (let
      (X (cdr Exe)
         Nm (xName (evSym X))
         S (bufString Nm (b8 (bufSize Nm))) )
      (let C (if (val $Chr) @ (call $Get))
         (cond
            ((or (lt0 C) (strchr S C))
               $Nil )
            ((nil? (eval (cadr X)))
               (let
                  (Y (cons (mkChar (getChar C)) $Nil)
                     R (save Y) )
                  (until
                     (or
                        (le0 (setq C (call $Get)))
                        (strchr S C) )
                     (setq Y
                        (set 2 Y (cons (mkChar (getChar C)) $Nil)) ) )
                  R ) )
            (T
               (let
                  (P (push 4 NIL ZERO NIL)  # [cnt last name link]
                     Q (link (ofs P 2)) )
                  (loop
                     (charSym (getChar C) P)
                     (? (le0 (setq C (call $Get))))
                     (? (strchr S C)) )
                  (drop Q
                     (consStr (val 3 P)) ) ) ) ) ) ) )

(local) eol

(de i1 eol ((i32 . C))
   (cond
      ((lt0 C) YES)
      ((== C (char "\n"))
         (set $Chr 0)
         YES )
      ((== C (char "\r"))
         (when (== (call $Get) (char "\n"))
            (set $Chr 0) )
         YES )
      (T NO) ) )

# (line 'flg ['cnt ..]) -> lst|sym
(de _Line (Exe)
   (let C (if (val $Chr) @ (call $Get))
      (if (eol C)
         $Nil
         (let X (cdr Exe)
            (cond
               ((nil? (eval (++ X)))
                  (let  # List of characters
                     (Y (cons (mkChar (getChar C)) $Nil)
                        R (save Y) )
                     (when (pair X)
                        (let Z (set Y (cons (car Y) $Nil))
                           (loop
                              (let N (evCnt Exe X)
                                 (while (gt0 (dec 'N))
                                    (when (eol (setq C (call $Get)))
                                       (ret R) )
                                    (setq Z
                                       (set 2 Z (cons (mkChar (getChar C)) $Nil)) ) ) )
                              (? (atom (shift X)))
                              (when (eol (setq C (call $Get)))
                                 (ret R) )
                              (setq Y
                                 (set 2 Y
                                    (cons
                                       (setq Z (cons (mkChar (getChar C)) $Nil))
                                       $Nil ) ) ) ) ) )
                     (until (eol (setq C (call $Get)))
                        (setq Y
                           (set 2 Y (cons (mkChar (getChar C)) $Nil)) ) )
                     R ) )
               ((atom X)  # Pack single string
                  (let
                     (P (push 4 NIL ZERO NIL)  # [cnt last name link]
                        Q (link (ofs P 2)) )
                     (loop
                        (charSym (getChar C) P)
                        (? (eol (setq C (call $Get)))) )
                     (drop Q
                        (consStr (val 3 P)) ) ) )
               (T
                  (let
                     (N (evCnt Exe X)
                        P (push 4 NIL ZERO NIL)  # [cnt last name link]
                        Q (link (ofs P 2) T) )
                     (loop
                        (charSym (getChar C) P)
                        (when (eol (setq C (call $Get)))
                           (ret (cons (consStr (val Q)) $Nil)) )
                        (? (=0 (dec 'N))) )
                     (let
                        (Y (cons (consStr (val Q)) $Nil)
                           R (save Y) )
                        (while (pair (shift X))
                           (setq N (evCnt Exe X))
                           (set P 4  3 P ZERO)
                           (loop
                              (charSym (getChar C) P)
                              (when (eol (setq C (call $Get)))
                                 (set 2 Y (cons (consStr (val Q)) $Nil))
                                 (ret R) )
                              (? (=0 (dec 'N))) )
                           (setq Y
                              (set 2 Y (cons (consStr (val Q)) $Nil)) ) )
                        (loop
                           (setq Y
                              (set 2 Y (cons (mkChar (getChar C)) $Nil)) )
                           (? (eol (setq C (call $Get)))) )
                        R ) ) ) ) ) ) ) )

# (in 'any . prg) -> any
(de _In (Exe)
   (let X (cdr Exe)
      (rdOpen Exe (eval (++ X)) (b8+ (ioFrame T)))
      (prog1
         (run X)
         (popInFiles) ) ) )

# (out 'any . prg) -> any
(de _Out (Exe)
   (let X (cdr Exe)
      (wrOpen Exe (eval (++ X)) (b8+ (ioFrame T)))
      (prog1
         (run X)
         (popOutFiles) ) ) )

# (err 'sym . prg) -> any
(de _Err (Exe)
   (let X (cdr Exe)
      (erOpen Exe (eval (++ X)) (b8+ (ctFrame T)))
      (prog1
         (run X)
         (popErrFiles) ) ) )

# (ctl 'sym . prg) -> any
(de _Ctl (Exe)
   (let X (cdr Exe)
      (ctOpen Exe (eval (++ X)) (b8+ (ctFrame T)))
      (prog1
         (run X)
         (popCtlFiles) ) ) )

(local) (pushInput pushOutput)

(de void pushInput ((i8* . Iox) Exe)
   (let Iox: (ioxFrame Iox)
      (Iox: link (val $InFrames))
      (Iox: file null)
      (Iox: fun (val (i8** $Get)))
      (Iox: exe Exe)
      (Iox: chr (val $Chr))
      (set
         $InFrames (Iox:)
         $Get (fun (i32) getIn)
         $IoChar 0
         $Chr 0 ) ) )

(de void pushOutput ((i8* . Iox) Exe)
   (let Iox: (ioxFrame Iox)
      (Iox: link (val $OutFrames))
      (Iox: file null)
      (Iox: fun (val (i8** $Put)))
      (Iox: exe Exe)
      (Iox: chr 0)
      (set $OutFrames (Iox:)  $Put (fun (void i8) putOut)) ) )

# (input exe . prg) -> any
(de _Input (Exe)
   (let X (cdr Exe)
      (pushInput (b8+ (ioxFrame T)) (++ X))
      (prog1
         (run X)
         (popInFiles) ) ) )

# (output exe . prg) -> any
(de _Output (Exe)
   (let X (cdr Exe)
      (pushOutput (b8+ (ioxFrame T)) (++ X))
      (prog1
         (run X)
         (popOutFiles) ) ) )

# (fd ['cnt]) -> cnt
(de _Fd (Exe)
   (let (X (eval (cadr Exe))  Fd (currFd Exe))
      (unless (nil? X)
         (dup2 Fd (i32 (xCnt Exe X))) )
      (cnt (i64 Fd)) ) )

(local) forkLisp

(de i32 forkLisp (Exe)
   (flushAll)
   (unless (val $Spkr)  # Not listening for children yet
      (when (lt0 (pipe $SpMiPipe))  # Open speaker/microphone pipe
         (pipeErr Exe) )
      (closeOnExec Exe (set $Spkr (val $SpMiPipe)))
      (closeOnExec Exe (val 2 $SpMiPipe)) )
   (let (Hear (b32 2)  Tell (b32 2))
      (when (or (lt0 (pipe Hear)) (lt0 (pipe Tell)))
         (pipeErr Exe) )
      (closeOnExec Exe (val Hear))  # Read end of 'hear'
      (closeOnExec Exe (val 2 Hear))  # Write end
      (closeOnExec Exe (val Tell))  # Read end of 'tell'
      (closeOnExec Exe (val 2 Tell))  # Write end
      (let (I (i32 0)  N (val $Children))
         (let Cld (val $Child)
            (while (> N I)  # Find a free child slot
               (? (=0 ((child Cld) pid)))
               (inc 'I)
               (setq Cld (ofs Cld (child T))) ) )
         (cond
            ((lt0 (fork)) (forkErr Exe))
            ((=0 @)  # In child
               (set
                  $Slot I  # Set child index
                  $Spkr 0  # No children yet
                  $Mic (val 2 $SpMiPipe) )  # Set microphone to write end
               (close (val 2 Hear))  # Close write end of 'hear'
               (close (val Tell))  # Close read end of 'tell'
               (close (val $SpMiPipe))  # Close read end
               (when (val $Hear)
                  (close @)
                  (closeInFile @)
                  (closeOutFile @) )
               (initInFile (set $Hear (val Hear)) null)  # Read end of 'hear'
               (when (val $Tell)  # Telling
                  (close @) )
               (set $Tell (val 2 Tell))  # Write end of 'tell'
               (set $Nfds 0)   # Clear poll entries
               (free (i8* (val $Poll)))
               (set $Poll (i64* null))
               (let Cld (val $Child)
                  (while (ge0 (dec 'N))  # Close children
                     (let Cld: (child Cld)
                        (when (Cld: pid)
                           (free (Cld: buf))
                           (close (Cld: hear))
                           (close (Cld: tell)) ) )
                     (setq Cld (ofs Cld (child T))) ) )
               (set $Children 0)  # No children
               (free (val $Child))
               (set $Child null)
               (let In (val $InFrames)  # Clear pids in InFrames
                  (while In
                     (let In: (ioFrame In)
                        (when (In: file)
                           (In: pid 0) )
                        (setq In (In: link)) ) ) )
               (let Out (val $OutFrames)  # Clear pids in OutFrames
                  (while Out
                     (let Out: (ioFrame Out)
                        (when (Out: file)
                           (Out: pid 0) )
                        (setq Out (Out: link)) ) ) )
               (let Ca (val $Catch)  # Clear 'finally' expressions in Catch frames
                  (while Ca
                     (let Ca: (caFrame Ca)
                        (Ca: fin ZERO)
                        (setq Ca (Ca: link)) ) ) )
               (let R (val $Run)  # Switch off all tasks
                  (while (pair R)
                     (let X (++ R)
                        (unless (sign? (car X))
                           (let Fd (i32 (int @))
                              (close Fd)
                              (closeInFile Fd)
                              (closeOutFile Fd) ) ) ) ) )
               (set $Bye $Nil)
               (set $Run $Nil)
               (free (val Termio))  # Give up terminal control
               (set Termio null)
               (set
                  $PRepl (val $Repl)  # Set parent REPL flag
                  $PPid (val $Pid) )  # Set parent process ID
               (set $Pid (cnt (i64 (getpid))))  # Set new process ID
               (execAt (val $Fork))  # Run '*Fork'
               (set $Fork $Nil)
               0 )
            (T  # In parent
               (let Pid @
                  (when (== I N)  # Children table full
                     (set $Children (inc 'N 8))  # Eight more slots
                     (let P
                        (set $Child
                           (alloc (val $Child) (i64 (* N (child T)))) )
                        (let Cld (ofs P (* I (child T)))
                           (loop
                              ((child Cld) pid 0)  # Clear 'pid'
                              (? (== I (dec 'N)))
                              (setq Cld (ofs Cld (child T))) ) ) ) )
                  (close (val Hear))  # Close read end of 'hear'
                  (close (val 2 Tell))  # Close write end of 'tell'
                  (let Cld: (child (ofs (val $Child) (* I (child T))))  # Free 'child' entry
                     (Cld: buf null)  # No buffer yet
                     (Cld: ofs (Cld: cnt 0))  # Init buffer offset and count
                     (Cld: pid Pid)  # Set 'pid'
                     (Cld: hear (val Tell))  # Read end of 'tell'
                     (nonBlocking (Cld: tell (val 2 Hear))) )  # Write end of 'hear'
                  Pid ) ) ) ) ) )

# (pipe exe) -> cnt
# (pipe exe . prg) -> any
(de _Pipe (Exe)
   (let
      (X (cdr Exe)
         E (++ X)
         Pfd (b32 2)
         Io: (ioFrame (b8+ (ioFrame T))) )
      (when (lt0 (if (pair X) (pipe Pfd) (socketPair Pfd)))
         (pipeErr Exe) )
      (when (< (val 2 Pfd) 2)  # pfd[1]
         (pipeErr Exe) )
      (if (forkLisp Exe)
         (let Pid @  # In parent
            (close (val 2 Pfd))  # Close write end
            (let Fd (val Pfd)  # Read end
               (closeOnExec Exe Fd)
               (cond
                  ((atom X)  # No 'prg'
                     (initInFile Fd null)
                     (initOutFile Fd)
                     (cnt (i64 Fd)) )
                  (T
                     (setpgid Pid 0)  # Set process group
                     (pushInFile (Io:) (initInFile Fd null) Pid)
                     (prog1
                        (run X)
                        (popInFiles) ) ) ) ) )
         # In child
         (close (val Pfd))  # Close read end
         (let Fd (val 2 Pfd)  # Write end
            (if (pair X)  # 'prg'
               (setpgid 0 0)  # Set process group
               (dup2 Fd 0)  # Dup write pipe to STDIN_FILENO
               ((inFile (val (val $InFiles))) tty NO) )  # Clear 'tty' in stdin
            (dup2 Fd 1)  # Dup write pipe to STDOUT_FILENO
            (close Fd) )
         (signal (val SIGPIPE Sig) (val SigDfl))  # Default SIGPIPE
         ((outFile (val $OutFile)) tty NO)  # Clear 'tty'
         (pushOutFile (Io:) (val 2 (val $OutFiles)) 0)  # Stdout
         (set $LinePtr null)  # Switch off line editor
         (when (pair E)  # Evaluate 'exe'
            (evList E) )
         (bye 0) ) ) )

# (open 'any ['flg]) -> cnt | NIL
(de _Open (Exe)
   (let
      (X (cdr Exe)
         Nm (xName (evSym X))
         S (pathString Nm (b8 (pathSize Nm)))
         Flg (nil? (eval (cadr X))) )
      (loop
         (? (ge0 (if Flg (openRdWrCreate S) (openRd S)))
            (closeOnExec Exe @)
            (initInFile @ (strdup S))
            (initOutFile @)
            (cnt (i64 @)) )
         (? (<> (gErrno) EINTR) $Nil)
         (sigChk Exe) ) ) )

# (close 'cnt) -> cnt | NIL
(de _Close (Exe)
   (let
      (X (eval (cadr Exe))
         Fd (i32 (xCnt Exe X)) )
      (loop
         (? (=0 (close Fd))
            (closeInFile Fd)
            (closeOutFile Fd)
            X )
         (? (<> (gErrno) EINTR) $Nil)
         (sigChk Exe) ) ) )

# (echo ['cnt ['cnt]] | ['sym ..]) -> sym
(de _Echo (Exe)
   (let (X (cdr Exe)  Y (eval (++ X)))
      (cond
         ((and (nil? Y) (atom X))
            (let C (if (val $Chr) @ (call $Get))
               (until (lt0 C)
                  (call $Put (i8 C))
                  (setq C (call $Get)) ) )
            $T )
         ((num? Y)
            (let N (xCnt Exe Y)
               (when (pair X)
                  (let C (evCnt Exe X)
                     (while (ge0 (dec 'N))
                        (when (lt0 (call $Get))
                           (ret $Nil) ) )
                     (setq N C) ) )
               (while (ge0 (dec 'N))
                  (when (lt0 (call $Get))
                     (ret $Nil) )
                  (call $Put (i8 @)) )
               (set $Chr 0)
               $T ) )
         ((pair Y) (argErr Exe Y))
         (T  # sym
            (let
               (M (i64* null)
                  N 1
                  Nm (xName Y)
                  L
                  (link
                     (push Y NIL 0  # [sym link ix str]
                        (any (bufString Nm (b8 (bufSize Nm)))) ) )
                  P L )
               (while (pair X)
                  (setq
                     Y (evSym (++ X))
                     Nm (xName Y)
                     L
                     (link
                        (push Y NIL 0  # [sym link ix str]
                           (any (bufString Nm (b8 (bufSize Nm)))) ) ) )
                  (inc 'N) )
               (unless (val $Chr)
                  (call $Get) )
               (while (ge0 (val $Chr))
                  (let
                     (B (i8 @)
                        Q (i64* L)
                        I N
                        OutM M
                        OutC (if M (val 3 M) 0) )
                     (loop
                        (loop
                           (let S (ofs (i8* (val 4 Q)) (val 3 Q))
                              (when (== B (val S))  # Bytes match
                                 (set 3 Q (inc (val 3 Q)))  # Increment index
                                 (? (val 2 S)  # Not end of string
                                    (unless (and M (>= (val 3 M) (val 3 Q)))
                                       (setq M Q) ) )
                                 (when OutM
                                    (setq S (i8* (val 4 OutM)))
                                    (dec 'OutC (val 3 Q))
                                    (until (lt0 OutC)
                                       (call $Put (val S))
                                       (inc 'S)
                                       (dec 'OutC) ) )
                                 (set $Chr 0)  # Clear look ahead
                                 (drop P)
                                 (ret (val Q)) ) )  # Return matched symbol
                           (? (=0 (val 3 Q)))  # Still at beginning of string
                           (let S (ofs (i8* (val 4 Q)) 1)  # Pointer to second byte
                              (while (set 3 Q (dec (val 3 Q)))  # Decrement index
                                 (? (=0 (memcmp (i8* (val 4 Q)) S @)))
                                 (inc 'S) ) )
                           (when (== Q M)  # On current max
                              (setq M (i64* null))
                              (let (Z (i64* L)  J N)
                                 (loop
                                    (when (val 3 Z)
                                       (unless (and M (>= (val 3 M) (val 3 Z)))
                                          (setq M Z) ) )
                                    (? (=0 (dec 'J)))
                                    (setq Z (i64* (val 2 Z))) ) ) ) )
                        (? (=0 (dec 'I)))
                        (setq Q (i64* (val 2 Q))) )
                     (cond
                        ((=0 M)
                           (when OutM
                              (let (S (i8* (val 4 OutM))  C OutC)
                                 (loop
                                    (call $Put (val S))
                                    (inc 'S)
                                    (? (=0 (dec 'C))) ) ) )
                           (call $Put B) )
                        (OutM
                           (let S (i8* (val 4 OutM))
                              (dec 'OutC (val 3 M))
                              (until (lt0 OutC)
                                 (call $Put (val S))
                                 (inc 'S)
                                 (dec 'OutC) ) ) ) ) )
                  (call $Get) )
               (drop P)
               $Nil ) ) ) ) )

(de void _putStdout ((i8 . B))
   (let Out: (outFile (val $OutFile))
      (when (Out:)
         (let I (Out: ix)
            (when (== I BUFSIZ)
               (Out: ix (setq I 0))
               (wrBytes (Out: fd) (Out: (buf)) BUFSIZ) )
            (set (ofs (Out: (buf)) I) B)
            (Out: ix (inc 'I))
            (when (and (== B (char "\n")) (Out: tty))
               (Out: ix 0)
               (wrBytes (Out: fd) (Out: (buf)) I) ) ) ) ) )

(local) (newline space)

(de void newline ()
   (call $Put (char "\n")) )

(de void space ()
   (call $Put (char " ")) )

(local) (outWord outNum outOct outAo bufAo prExt)

# Output decimal number
(de void outWord ((i64 . N))
   (when (> N 9)
      (outWord (/ N 10))
      (setq N (% N 10)) )
   (call $Put (+ (i8 N) (char "0"))) )

(de void outNum (X)
   (when (sign? X)
      (call $Put (char "-")) )
   (outWord (shr (i64 X) 4)) )

# Output octal number
(de void outOct ((i64 . N))
   (when (> N 7)
      (outOct (shr N 3))
      (setq N (& N 7)) )
   (call $Put (+ (i8 N) (char "0"))) )

# Output A-O encoding
(de void outAo ((i32 . N))
   (when (> N 15)
      (outAo (shr N 4))
      (setq N (& N 15)) )
   (call $Put (+ (i8 N) (char "@"))) )

# Append A-O encoding to buffer
(de i8* bufAo ((i8* . P) (i32 . N))
   (when (> N 15)
      (setq
         P (bufAo P (shr N 4))
         N (& N 15) ) )
   (set P (+ (i8 N) (char "@")))
   (inc P) )

# Output external symbol name
(de void prExt (Nm)
   (when (objFile Nm)
      (outAo @) )
   (outOct (objId Nm)) )

(local) (outString prName prSym printName printSym)

# Output string
(de void outString ((i8* . S))
   (while (val S)
      (call $Put @)
      (inc 'S) ) )

(de void prName (Nm)
   (let P (push 0 Nm)  # [cnt name]
      (while (symByte P)
         (call $Put @) ) ) )

(de void prSym (Sym)
   (prName (name (val (tail Sym)))) )

(de void printName (Nm)
   (ifn (== Nm (hex "2E2"))  # Dot
      (let (P (push 0 Nm)  B (symByte P))  # [cnt name]
         (when (== B (char "#"))
            (call $Put (char "\\")) )  # Escape leading hash
         (loop
            (if (or (== B 127) (> 32 B))  # DEL or Ctrl
               (prog
                  (call $Put (char "\\"))  # Unicode
                  (outWord (i64 B))
                  (call $Put (char "\\")) )
               (when
                  (or
                     (== B (char "\\"))
                     (strchr $Delim (i32 B)) )
                  (call $Put (char "\\")) )  # Escape backslash and delimiters
               (call $Put B) )
            (? (=0 (setq B (symByte P))) ) ) )
      (call $Put (char "\\"))
      (call $Put (char ".")) ) )

(de void printSym (Sym)
   (printName (name (val (tail Sym)))) )

(local) (print prin)

(de void print (X)
   (sigChk 0)
   (cond
      ((cnt? X) (outNum X))
      ((big? X) (fmtNum X 0 0 0 null))
      ((sym? X)
         (cond
            ((sym? (val (tail X)))  # External
               (call $Put (char "{"))
               (prExt (name (& @ -9)))
               (call $Put (char "}")) )
            ((== (name @) ZERO)  # Anonymous
               (call $Put (char "$"))
               (outOct (int X)) )
            (T
               (let (Nm @  Prv (isIntern Nm $PrivT))
                  (ifn (== X Prv)
                     (let (Lst (val $Intern)  F NO)  # Search namespaces
                        (loop
                           (? (atom Lst)  # Transient
                              (call $Put (char "\""))
                              (let (P (push 0 Nm)  B (symByte P))  # [cnt name]
                                 (loop
                                    (cond
                                       ((or
                                             (== B (char "\\"))
                                             (== B (char "\^"))
                                             (== B (char "\"")) )
                                          (call $Put (char "\\")) )
                                       ((== B 127)  # DEL
                                          (call $Put (char "\^"))  # Print ^?
                                          (setq B (char "?")) )
                                       ((> 32 B)  # Ctrl
                                          (call $Put (char "\^"))  # Escape with caret
                                          (setq B (| B 64)) ) )
                                    (call $Put B)
                                    (? (=0 (setq B (symByte P))) ) ) )
                              (call $Put (char "\"")) )
                           (let Nsp (car Lst)
                              (when (isIntern Nm (cdar Nsp))
                                 (? (== @ X)  # Internal
                                    (when (or Prv F)  # Found in other namespace
                                       (printSym Nsp)
                                       (call $Put (char "~")) )
                                    (printName Nm) )
                                 (setq F YES) ) )
                           (shift Lst) ) )
                     (outString ($ "priv~"))  # Found in 'priv'
                     (printName Nm) ) ) ) ) )
      ((and (== (car X) $Quote) (<> X (cdr X)))
         (call $Put (char "'"))
         (print (cdr X)) )
      (T
         (stkChk 0)
         (call $Put (char "("))
         (let (P (circ X)  Z X)
            (loop
               (print (car X))
               (? (nil? (shift X)))
               (? (atom X)
                  (outString ($ " . "))
                  (print X) )
               (space)
               (? (== Z X)
                  (call $Put (char "."))
                  (unless P
                     (call $Put (char ")")) ) )
               (when (== P X)
                  (outString ($ ". ("))
                  (setq Z P  P 0) ) ) )
         (call $Put (char ")")) ) ) )

(de void prin (X)
   (sigChk 0)
   (unless (nil? X)
      (cond
         ((cnt? X) (outNum X))
         ((big? X) (fmtNum X 0 0 0 null))
         ((pair X)
            (stkChk 0)
            (loop
               (prin (car X))
               (? (nil? (shift X)))
               (? (atom X) (prin X)) ) )
         ((sym? (val (tail X)))
            (call $Put (char "{"))
            (prExt (name (& @ -9)))
            (call $Put (char "}")) )
         (T (prName (name @))) ) ) )

# (prin 'any ..) -> any
(de _Prin (Exe)
   (let X (cdr Exe)
      (loop
         (let Y (eval (++ X))
            (prin Y)
            (? (atom X) Y) ) ) ) )

# (prinl 'any ..) -> any
(de _Prinl (Exe)
   (prog1 (_Prin Exe) (newline)) )

# (space ['cnt]) -> cnt
(de _Space (Exe)
   (let X (eval (cadr Exe))
      (ifn (nil? X)
         (let N (xCnt Exe X)
            (while (ge0 (dec 'N))
               (space) )
            X )
         (space)
         ONE ) ) )

# (print 'any ..) -> any
(de _Print (Exe)
   (let X (cdr Exe)
      (loop
         (let Y (eval (++ X))
            (print Y)
            (? (atom X) Y)
            (space) ) ) ) )

# (printsp 'any ..) -> any
(de _Printsp (Exe)
   (prog1 (_Print Exe) (space)) )

# (println 'any ..) -> any
(de _Println (Exe)
   (prog1 (_Print Exe) (newline)) )

# (flush) -> flg
(de _Flush (Exe)
   (if (flush (val $OutFile)) $T $Nil) )

# (rewind) -> flg
(de _Rewind (Exe)
   (let Out: (outFile (val $OutFile))
      (if
         (and
            (Out:)
            (let Fd (Out: fd)
               (Out: ix 0)
               (and (seek0 Fd) (truncate0 Fd)) ) )
         $T
         $Nil ) ) )

# (ext 'cnt . prg) -> any
(de _Ext (Exe)
   (let (X (cdr Exe)  N (evCnt Exe X)  Old (val $ExtN))
      (set $ExtN (i32 N))
      (prog1
         (run (cdr X))
         (set $ExtN Old) ) ) )

(local) (getPlio putPlio)

(de i32 getPlio ()
   (let P (val $Ptr)
      (set $Ptr (inc P))
      (i32 (val P)) ) )

(de void putPlio ((i8 . B))
   (let P (val $Ptr)
      (set P B)
      (when (== (set $Ptr (inc P)) (val $End))
         (sizeErr 0) ) ) )

# (plio 'num) -> any
# (plio 'num 'cnt 'any) -> cnt
(de _Plio (Exe)
   (let
      (X (cdr Exe)
         P
         (i8*
            (if (cnt? (needNum Exe (eval (++ X))))
               (int @)
               (val (dig @)) ) ) )
      (let (Ptr (val $Ptr)  End (val $End))
         (set
            $Extn (val $ExtN)  # Set external symbol offset
            $Ptr P )
         (prog1
            (if (pair X)
               (let (N (evCnt Exe X)  Y (eval (car (shift X))))
                  (set
                     $PutBin (fun (void i8) putPlio)
                     $End (ofs P N) )
                  (binPrint Y)
                  (cnt (- (val $Ptr) P)) )
               (set $GetBin (fun (i32) getPlio))
               (if (binRead) @ $Nil) )
            (set $Ptr Ptr  $End End) ) ) ) )

# (rd ['sym]) -> any
# (rd 'cnt) -> num | NIL
(de _Rd (Exe)
   (let X (save (eval (cadr Exe)))
      (cond
         ((lt0 ((inFile (val $InFile)) fd)) $Nil)
         ((num? X)
            (let
               (P (push 3 NIL ZERO NIL)  # [cnt last name link]
                  Q (link (ofs P 2))
                  Cnt (int X) )
               (cond
                  ((=0 Cnt) $Nil)
                  ((sign? X)  # Little endian
                     (loop
                        (when (lt0 (getBinary))
                           (: 1 (ret $Nil)) )
                        (byteNum (i8 @) P)
                        (? (=0 (dec 'Cnt))) )
                     (if (cnt? (val Q))
                        (twice @)
                        (zapZero @) ) )
                  (T
                     (loop
                        (when (lt0 (getBinary))
                           (goto 1) )
                        (set Q
                           (addu
                              (cnt (i64 @))
                              (set Q (mulu (val Q) (hex "1002"))) ) )  # Multiply number by 256
                        (? (=0 (dec 'Cnt))) )
                     (if (cnt? (val Q))
                        @
                        (zapZero @) ) ) ) ) )
         (T
            (set
               $GetBin (fun (i32) getBinary)
               $Extn (val $ExtN) )
            (if (binRead) @ X) ) ) ) )

# (pr 'any ..) -> any
(de _Pr (Exe)
   (let X (cdr Exe)
      (loop
         (let Y (eval (++ X))
            (set $Extn (val $ExtN))  # Set external symbol offset
            (pr Y)  # Print binary
            (? (atom X) Y) ) ) ) )

# (wr 'cnt ..) -> cnt
(de _Wr (Exe)
   (let X (cdr Exe)
      (loop
         (let N (eval (++ X))
            (_putStdout (i8 (int N)))
            (? (atom X) N) ) ) ) )

(local) (getParse parse)

(de i32 getParse ()
   (let P (val $Parser)
      (set $Chr
         (if (i32 (symByte P))
            @
            (let C (val 3 P)
               (set 3 P (shr C 8))
               (if C (i32 (i8 C)) -1) ) ) ) ) )

(de parse (Nm (i1 . Skip) Eof Set)
   (let
      (Chr (val $Chr)
         Get (val (i8** $Get))
         Pars (val $Parser) )
      (set
         $Chr 0
         $Get (fun (i32) getParse)
         $Parser (push 0 (save Nm) Eof) )
      (when Skip
         (getParse) )
      (prog1
         (cond
            ((=0 Set) (rdList))
            ((== 1 Set) (read0 YES))
            ((=0 (token Set 0)) $Nil)
            (T
               (let (R (save (cons @ $Nil))  P R)
                  (while (token Set 0)
                     (setq P (set 2 P (cons @ $Nil))) )
                  R ) ) )
         (set
            $Parser Pars
            (i8** $Get) Get
            $Chr Chr ) ) ) )

(local) (putString begString tglString endString)

(de void putString ((i8 . B))
   (byteSym B (val $StrP)) )

(de void begString ((i64* . P))  # [cnt last name link fun ptr]
   (set 6 P (i64 (val $StrP)))
   (link (ofs (set $StrP P) 2))
   (set
      5 P (val (i64* $Put))
      $Put (fun (void i8) putString) ) )

(de void tglString ((i64* . P))
   (xchg (any (ofs P 4)) (any (i64* $Put))) )

(de endString ()
   (let (P (val $StrP)  Q (ofs P 2))
      (set
         (i64* $Put) (val 5 P)
         $StrP (i64* (val 6 P)) )
      (drop Q
         (consStr (val Q)) ) ) )

# (any 'sym) -> any
(de _Any (Exe)
   (if (sym? (val (tail (save (evSym (cdr Exe))))))
      $Nil
      (parse (name @) YES (hex "20") 1) ) )  # Blank, EOF

# (sym 'any) -> sym
(de _Sym (Exe)
   (let X (eval (cadr Exe))
      (begString (push 4 NIL ZERO NIL NIL NIL))  # [cnt last name link fun ptr]
      (print X)
      (endString) ) )

# (str 'sym ['sym1]) -> lst
# (str 'lst) -> sym
(de _Str (Exe)
   (let (X (cdr Exe)  Y (eval (car X)))
      (cond
         ((nil? Y) Y)
         ((num? Y) (argErr Exe Y))
         ((pair Y)
            (begString (push 4 NIL ZERO NIL NIL NIL))  # [cnt last name link fun ptr]
            (loop
               (print (++ Y))
               (? (atom Y))
               (space) )
            (endString) )
         ((sym? (setq Y (val (tail @)))) $Nil)
         ((atom (shift X))
            (parse (name Y) NO (hex "5D0A") 0) )  # '\n', ']', EOF
         (T
            (save Y
               (parse (name Y) NO 0 (save (evSym X))) ) ) ) ) )

(local) (stdRead stdEval repl loadAll)

(de stdRead ((i8* . Prmt))
   (prog2
      (set
         $LinePrmt
         (if
            (or
               (nil? (runAt (val $Prompt)))
               (not (symb? @)) )
            Prmt
            (let
               (Nm (name (val (tail @)))
                  N (bufSize Nm)
                  P
                  (set $ReplPrmt
                     (alloc (val $ReplPrmt) (+ N (strlen Prmt))) ) )
               (bufString Nm P)
               (strcpy (ofs P (dec N)) Prmt)
               P ) )
         $ContPrmt ($ "   ") )
      (read1
         (if ((inFile (val $InFile)) tty)
            (char "\n")
            (i32 0) ) )
      (set $LinePrmt (set $ContPrmt null))
      (while (gt0 (val $Chr))
         (? (== (val $Chr) (char "\n"))
            (set $Chr 0) )
         (if (== (val $Chr) (char "#"))
            (comment)
            (? (> (val $Chr) (char " ")))
            (call $Get) ) ) ) )

(de stdEval (Exe)
   (flushAll)
   (let
      (At (save (val $At))
         At2 (save (val $At2))
         X (save (eval Exe)) )
      (outString ($ "-> "))
      (flushAll)
      (print X)
      (unless (nil? (val $Remark))
         (let
            (V (push NIL $Nil ZERO NIL NIL)  # [car cdr name arg link]
               E (push NIL V ZERO @ NIL) )  # [car cdr name fun link]
            (set 4 V X)
            (set
               V (link (ofs V 3) T)
               E (link (ofs E 3)) )
            (evList E) ) )
      (newline)
      (set $At3 At2  $At2 At  $At X) ) )

(de repl (Exe (i8* . Prmt) X)
   (if (and (symb? X) (== (firstByte X) (char "-")))
      (let E (save (parse (xName X) YES (hex "5D0A") 0))  # '\n', ']', EOF
         (evList E) )
      (let
         (Lnk (val $NsLink)
            Tr1 (save (val $Transient))
            Tr2 (save (val 2 $Transient))
            Pr1 (save (val $PrivT))
            Pr2 (save (val 2 $PrivT))
            V (link (push -ZERO NIL))
            Raw (val Termio) )
         (save (val $Intern))
         (set $NsLink (val $Link))
         (when (nil? X)
            (setCooked)
            (unless (val $Repl)
               (set $Repl YES)
               (iSignal (val SIGINT Sig) (fun sig)) ) )
         (rdOpen Exe X (b8+ (ioFrame T)))
         (set $PrivT (set 2 $PrivT $Nil))
         (set $Rule (set $Transient (set 2 $Transient $Nil)))
         (setq X $Nil)
         (if (== (val $InFile) (val (val $InFiles)))  # Stdin
            (until (nil? (stdRead Prmt))
               (let Y (set V @)
                  (setq X
                     (if (and (=0 (val $Chr)) Prmt)
                        (stdEval Y)
                        (eval Y) ) ) ) )
            (until (nil? (read1 0))
               (setq X (eval (set V @))) ) )
         (popInFiles)
         (set $Intern (val (val $NsLink)))
         (when Raw
            (setRaw) )
         (set 2 $PrivT Pr2)
         (set $PrivT Pr1)
         (set 2 $Transient Tr2)
         (set $Transient Tr1)
         (set $NsLink Lnk)
         X ) ) )

(de loadAll (Exe)
   (let X $Nil
      (loop
         (let (A (val $AV)  P (val A))
            (?
               (or
                  (=0 P)
                  (and
                     (== (val P) (char "-"))
                     (=0 (val 2 P)) ) ) )
            (set $AV (inc A))
            (setq X (repl Exe null (mkStr P))) ) )
      X ) )

# (load 'any ..) -> any
(de _Load (Exe)
   (let X (cdr Exe)
      (loop
         (let Y
            (if (t? (eval (++ X)))
               (loadAll Exe)
               (repl Exe ($ "> ") @) )
            (? (atom X) Y) ) ) ) )
pil21/src/db.l0000644000000000000000000014051114643270122010227 0ustar  # 09jul24 Software Lab. Alexander Burger

(symbols '(llvm))

(local) (dbfErr dbRdErr dbWrErr jnlErr dbSyncErr)

(de NIL dbfErr (Exe)
   (err Exe 0 ($ "Bad DB file") null) )

(de NIL dbRdErr ()
   (err 0 0 ($ "DB read: %s") (strErrno)) )

(de NIL dbWrErr ()
   (err 0 0 ($ "DB write: %s") (strErrno)) )

(de NIL jnlErr (Exe)
   (err Exe 0 ($ "Bad Journal") null) )

(de NIL dbSyncErr (Exe)
   (err Exe 0 ($ "DB fsync error: %s") (strErrno)) )

(local) (getAdr setAdr dbfBuf)

# 6 bytes in little endian format
# Get block address from buffer
(de i64 getAdr ((i8* . P))
   (|
      (shl
         (|
            (shl
               (|
                  (shl
                     (|
                        (shl
                           (|
                              (shl (i64 (val 6 P)) 8)
                              (i64 (val 5 P)) )
                           8 )
                        (i64 (val 4 P)) )
                     8 )
                  (i64 (val 3 P)) )
               8 )
            (i64 (val 2 P)) )
         8 )
      (i64 (val P)) ) )

# Set block address in buffer
(de void setAdr ((i64 . N) (i8* . P))
   (set P (i8 N))
   (set 2 P (i8 (setq N (shr N 8))))
   (set 3 P (i8 (setq N (shr N 8))))
   (set 4 P (i8 (setq N (shr N 8))))
   (set 5 P (i8 (setq N (shr N 8))))
   (set 6 P (i8 (shr N 8))) )

# Read file number from buffer into '$DbFile'
(de i8* dbfBuf ((i8* . P))
   (let N
      (|  # Two bytes little endian
         (shl (i32 (val 2 P)) 8)
         (i32 (val P)) )
      (if (> (val $DBs) N)  # Local file
         (set $DbFile  # Set current file
            (ofs (val $DbFiles) (* N (dbFile T))) )
         null ) ) )

# Locking
(local) (rdLockDb wrLockDb unLockDb tryLock lockJnl unLockJnl)

(de void rdLockDb ()
   (unless (t? (val $Solo))  # Not already locked whole DB
      (rdLockWait ((dbFile (val $DbFiles)) fd) 1) ) )  # Descriptor of first file

(de void wrLockDb ()
   (unless (t? (val $Solo))  # Not already locked whole DB
      (wrLockWait ((dbFile (val $DbFiles)) fd) 1) ) )  # Descriptor of first file

(de void unLockDb ((i64 . Len))
   (unless (t? (val $Solo))  # Not already locked whole DB
      (unless Len
         (let (Db (val $DbFiles)  C (val $DBs))  # Iterate DB files
            (while (dec 'C)
               (let Db: (dbFile (setq Db (ofs Db (dbFile T))))  # Skip first, increment by size of dbFile
                  (when (Db: lck)
                     (unLock (Db: fd) 0 0)
                     (Db: lck NO) ) ) ) )
         (set $Solo ZERO) )
      (unLock ((dbFile (val $DbFiles)) fd) 0 Len) ) )  # Descriptor of first file

(de i32 tryLock ((i8* . DbFile) (i64 . N) (i64 . Len))
   (let Db: (dbFile DbFile)
      (loop
         (? (ge0 (wrLock (Db: fd) N Len NO))  # Try to lock
            (Db: lck YES)  # Set lock flag
            (nond
               (N (set $Solo $T))  # Set solo mode
               ((t? (val $Solo)) (set $Solo $Nil)) )  # Clear solo mode
            0 )
         (unless
            (or
               (== (gErrno) EINTR)  # Interrupted
               (== @ EACCES)  # Locked by another process
               (== @ EAGAIN) )  # Memory-mapped by another process
            (lockErr) )
         (while (lt0 (getLock (Db: fd) N Len))
            (unless (== (gErrno) EINTR)
               (lockErr) ) )
         (? (gt0 @) @) ) ) )

(de void lockJnl ()
   (wrLockWait (fileno (val $DbJnl)) 0) )

(de void unLockJnl ()
   (let Jnl (val $DbJnl)
      (fflush Jnl)
      (unLock (fileno Jnl) 0 0) ) )

(local) (blkPeek rdBlock blkPoke wrBlock logBlock)

(de void blkPeek ((i64 . Pos) (i8* . Buf) (i32 . Siz))
   (let (S (i64 Siz)  Db: (dbFile (val $DbFile)))
      (unless (== S (pread (Db: fd) Buf S Pos))
         (dbRdErr) ) ) )

(de i8* rdBlock ((i64 . N))
   (let (Db: (dbFile (val $DbFile))  Blk (val $DbBlock))
      (blkPeek  # Read block
         (shl (set $BlkIndex N) (i64 (Db: sh)))
         Blk
         (Db: siz) )
      (set
         $BlkLink (& (getAdr Blk) BLKMASK)
         $BlkEnd (ofs Blk (Db: siz))
         $BlkPtr (ofs Blk BLK) )  # Pointer to data
      Blk ) )  # Pointer to block

(de void blkPoke ((i64 . Pos) (i8* . Buf) (i32 . Siz))
   (let Db: (dbFile (val $DbFile))
      (unless (== Siz (i32 (pwrite (Db: fd) Buf (i64 Siz) Pos)))
         (dbWrErr) )
      (when (val $DbJnl)
         (let Jnl @
            (putc_unlocked (if (== Siz (Db: siz)) 0 Siz) Jnl)
            (let P (b8 (+ BLK 2))  # Allocate buffer
               (set P (i8 (Db: db)))  # Store file number
               (set 2 P (i8 (shr (Db: db) 8)))
               (setAdr
                  (shr Pos (i64 (Db: sh)))  # Un-shift position
                  (ofs P 2) )
               (unless
                  (and
                     (== 1 (fwrite P (+ BLK 2) 1 Jnl))  # Write file number and address
                     (== 1 (fwrite Buf (i64 Siz) 1 Jnl)) )  # Write 'Buf'
                  (err 0 0 ($ "Journal write: %s") (strErrno)) ) ) ) ) ) )

(de void wrBlock ()
   (let Db: (dbFile (val $DbFile))
      (blkPoke
         (shl (val $BlkIndex) (i64 (Db: sh)))
         (val $DbBlock)
         (Db: siz) ) ) )

(de void logBlock ()
   (let
      (Db: (dbFile (val $DbFile))
         Log (val $DbLog)
         P (b8 (+ BLK 2)) )
      (set P (i8 (Db: db)))  # Store file number
      (set 2 P (i8 (shr (Db: db) 8)))
      (setAdr (val $BlkIndex) (ofs P 2))  # and block
      (unless
         (and
            (== 1 (fwrite P (+ BLK 2) 1 Log))  # Write file number and address
            (== 1 (fwrite (val $DbBlock) (i64 (Db: siz)) 1 Log)) )  # Write block
         (err 0 0 ($ "Log write: %s") (strErrno)) ) ) )

(local) (newBlock newId isLife cleanUp getBlock putBlock)

(de i64 newBlock ()
   (let
      (Db: (dbFile (val $DbFile))
         Siz (Db: siz)
         P (b8 Siz) )
      (blkPeek 0 P (* 2 BLK))  # Read 'free' and 'next' from block zero
      (let N (getAdr P)
         (cond
            ((and N (Db: flu))
               (blkPeek (shl N (i64 (Db: sh))) P BLK)  # Get free link
               (Db: flu (dec (Db: flu))) )
            ((== (setq N (getAdr (ofs P BLK))) (hex "FFFFFFFFFFC0"))  # Max object ID
               (err 0 0 ($ "DB Oversize") null) )
            (T (setAdr (+ N BLKSIZE) (ofs P BLK))) )  # Increment next
         (blkPoke 0 P (* 2 BLK))  # Write back
         (memset P 0 (i64 Siz) T)  # Init new block
         (blkPoke (shl N (i64 (Db: sh))) P Siz)
         N ) ) )

(de newId (Exe (i32 . N))
   (when (>= (dec 'N) (val $DBs))
      (dbfErr Exe) )
   (set $DbFile  # Set current file
      (ofs (val $DbFiles) (* N (dbFile T))) )
   (set $Protect (inc (val $Protect)))
   (wrLockDb)
   (when (val $DbJnl)
      (lockJnl) )
   (prog1
      (extNm
         ((dbFile (val $DbFile)) db)
         (shr (newBlock) 6) )
      (when (val $DbJnl)
         (unLockJnl) )
      (unLockDb 1)
      (set $Protect (dec (val $Protect))) ) )

(de i1 isLife (Sym)
   (let
      (Nm (name (& (val (tail Sym)) -9))
         F (objFile Nm)
         N (shl (objId Nm) 6) )
      (when N
         (cond
            ((> (val $DBs) F)  # Local file
               (setq Nm (add Nm Nm))
               (when @@  # Dirty
                  (ret YES) )
               (add Nm Nm)
               (when @@  # Loaded
                  (ret YES) )
               (let
                  (Db:
                     (dbFile
                        (set $DbFile  # Set current file
                           (ofs (val $DbFiles) (* F (dbFile T))) ) )
                     P (b8 (* BLK 2)) )
                  (blkPeek BLK P BLK)  # Read 'next'
                  (when (> (getAdr P) N)
                     (blkPeek (shl N (i64 (Db: sh))) P BLK)  # Read link field
                     (when (== 1 (& (val P) BLKTAG))  # ID-Block
                        (ret YES) ) ) ) )
            ((pair (val $Ext))
               (ret YES) ) ) )
      NO ) )

# (ext? 'any ['flg]) -> sym | NIL
(de _ExtQ (Exe)
   (let (X (cdr Exe)  Y (save (eval (++ X))))
      (if
         (and
            (symb? Y)
            (sym? (val (tail Y)))
            (or (nil? (eval (car X))) (isLife Y)) )
         Y
         $Nil ) ) )

(de void cleanUp ((i64 . N))
   (let (P (b8 BLK)  Db: (dbFile (val $DbFile)))
      (blkPeek 0 P BLK)  # Read 'free'
      (let Free (getAdr P)
         (setAdr N P)
         (blkPoke 0 P BLK)  # Set new 'free'
         (loop
            (let Pos (shl N (i64 (Db: sh)))
               (blkPeek Pos P BLK)  # Get block link
               (set P (& (val P) BLKMASK))  # Clear tag
               (? (=0 (setq N (getAdr P)))  # No more links
                  (setAdr Free P)  # Append old 'free' list
                  (blkPoke Pos P BLK) )
               (blkPoke Pos P BLK) ) ) ) ) )

(de i32 getBlock ()
   (let P (val $BlkPtr)
      (when (== P (val $BlkEnd))
         (unless (val $BlkLink)
            (ret -1) )
         (setq P (ofs (rdBlock @) BLK)) )
      (set $BlkPtr (inc P))
      (i32 (val P)) ) )

(de void putBlock ((i8 . B))
   (let P (val $BlkPtr)
      (when (== P (val $BlkEnd))
         (let Link (val $BlkLink)
            (ifn Link
               (let
                  (New (newBlock)
                     Cnt (i64 (val (setq P (val $DbBlock)))) )  # Block count (link is zero)
                  (setAdr (| New Cnt) P)
                  (wrBlock)  # Write new block
                  (set $BlkIndex New)  # Set new block index
                  (setAdr (if (== Cnt BLKTAG) Cnt (inc Cnt)) P)
                  (setq P (ofs P BLK)) )
               (wrBlock)  # Write current block
               (setq P (ofs (rdBlock Link) BLK)) ) ) )  # Read next block
      (set P B)
      (set $BlkPtr (inc P)) ) )

# (rollback) -> flg
(de _Rollback (Exe)
   (if (and (=0 (val $DBs)) (atom (val $Ext)))
      $Nil
      (let (Tos 0  P (val $Extern))  # Iterate external symbol tree
         (loop
            (loop
               (let X (cdr P)  # Get subtrees
                  (? (atom (cdr X)))  # Right subtree
                  (let Y P  # Go right
                     (setq P @)  # Invert tree
                     (set 2 X Tos)
                     (setq Tos Y) ) ) )
            (loop
               (let (S (val P)  Tail (val (tail S)))  # Get external symbol
                  (unless (num? Tail)  # Any properties
                     (setq Tail (& Tail -9))  # Clear 'extern' tag
                     (loop
                        (? (num? (shift Tail))) )  # Find name
                     (setq Tail (sym Tail)) )  # Set 'extern' tag
                  (set (tail S) (shr (shl Tail 2) 2))  # Strip status bits
                  (set S $Nil) )  # Clear value
               (let X (cdr P)
                  (? (pair (car X))  # Left subtree
                     (let Y P  # Go left
                        (setq P @)  # Invert tree
                        (set X Tos)
                        (setq Tos (| Y 8)) ) ) )  # First visit
               (loop
                  (unless Tos
                     (goto 1) )
                  (? (=0 (& Tos 8))  # Second visit
                     (let (X Tos  Y (cdr X))  # Nodes
                        (setq Tos (cdr Y))  # TOS on up link
                        (set 2 Y P)
                        (setq P X) ) )
                  (setq Tos (& Tos -9))  # Clear visit bit
                  (let (X Tos  Y (cdr X))  # Nodes
                     (setq Tos (car Y))
                     (set Y P)
                     (setq P X) ) ) ) ) )
      (: 1
         (when (pair (val $Zap))  # Objects to delete
            (set @ $Nil) ) )  # Clear zap list
      (when (val $DBs)  # DB open
         (unLockDb 0) )  # Unlock all
      (unsync)
      $T ) )

# (extern 'sym) -> sym | NIL
(de _Extern (Exe)
   (let
      (Sym (needSymb Exe (eval (cadr Exe)))
         Nm (name (& (val (tail Sym)) -9)) )
      (when (== Nm ZERO)
         (ret $Nil) )
      (let
         (P (push 0 Nm)  # [cnt name]
            C (symChar P)
            F (i32 0) )
         (when (== C (char "{"))
            (setq C (symChar P)) )
         (while (>= C (char "@"))
            (when (> C (char "O"))  # A-O range
               (ret $Nil) )
            (setq
               F (| (shl F 4) (- C (char "@")))
               C (symChar P) ) )
         (let N 0
            (loop
               (unless (and (>= C (char "0")) (>= (char "7") C))
                  (ret $Nil) )
               (setq N
                  (|
                     (shl N 3)
                     (i64 (- C (char "0"))) ) )
               (?
                  (or
                     (=0 (setq C (symChar P)))
                     (== C (char "}")) ) ) )
            (if (isLife (setq Sym (extern (extNm F N))))
               Sym
               $Nil ) ) ) ) )

(local) (ignLog transaction fsyncDB restore truncLog)

(de void ignLog ()
   (stderrMsg ($ "Discarding incomplete transaction\n") null) )

# Test for existing transaction
(de i1 transaction ()
   (let (Log (val $DbLog)  Blk (b8 BLK))
      (fseek0 Log)
      (if (fread Blk 2 1 Log)  # Read first file number
         (loop
            (? (== (val (i16* Blk)) (hex "FFFF")) YES)  # Byte order doesn't matter
            (?
               (or
                  (=0 (dbfBuf Blk))
                  (<> (fread Blk BLK 1 Log) 1)
                  (not (fseekOfs Log ((dbFile (val $DbFile)) siz)))
                  (<> (fread Blk 2 1 Log) 1) )
               (ignLog)
               NO ) )
         (unless (feof Log)
            (ignLog) )  # Discard incomplete transaction
         NO ) ) )

(de void fsyncDB (Exe)
   (let (Db (val $DbFiles)  C (val $DBs))  # Iterate DB files
      (loop
         (let Db: (dbFile Db)
            (when (and (Db: drt) (lt0 (fsync (Db: fd))))
               (dbSyncErr Exe) ) )
         (? (=0 (dec 'C)))
         (setq Db (ofs Db (dbFile T))) ) ) )

(de void restore (Exe)
   (stderrMsg ($ "Last transaction not completed: Rollback\n") null)
   (let Log (val $DbLog)
      (fseek0 Log)
      (let (Db (val $DbFiles)  C (val $DBs))  # Iterate DB files
         (loop
            ((dbFile Db) drt NO)
            (? (=0 (dec 'C)))
            (setq Db (ofs Db (dbFile T))) ) )
      (let (Blk (b8 BLK)  Buf (b8 (val $MaxBlkSize)))
         (loop
            (unless (== (fread Blk 2 1 Log) 1)  # Get file number
               (jnlErr Exe) )
            (? (== (val (i16* Blk)) (hex "FFFF")))  # Byte order doesn't matter
            (if (dbfBuf Blk)
               (let Db: (dbFile @)
                  (unless
                     (and
                        (== (fread Blk BLK 1 Log) 1)
                        (== (fread Buf (i64 (Db: siz)) 1 Log) 1) )
                     (jnlErr Exe) )
                  (unless
                     (==
                        (pwrite
                           (Db: fd)
                           Buf
                           (i64 (Db: siz))
                           (shl (getAdr Blk) (i64 (Db: sh))) )
                        (i64 (Db: siz)) )
                     (dbWrErr) )
                  (Db: drt YES) )
               (jnlErr Exe) ) )
         (fsyncDB Exe) ) ) )

(de void truncLog (Exe)
   (let Log (val $DbLog)
      (unless (and (fseek0 Log) (truncate0 (fileno Log)))
         (err Exe 0 ($ "Log truncate error: %s") (strErrno)) ) ) )

# (pool ['sym1 ['lst] ['sym2] ['sym3]]) -> T
(de _Pool (Exe)
   (let
      (X (cdr Exe)
         Sym1 (save (evSym X))  # Database name
         Dbs (save (evLst (shift X)))  # Database sizes
         Sym2 (save (evSym (shift X)))  # Replication journal
         Sym3 (save (evSym (shift X))) )  # Transaction log
      (set $Solo ZERO)  # Reset solo mode
      (when (val $DBs)
         (_Rollback ZERO)
         (let (Db (val $DbFiles)  C @)  # Iterate DB files
            (loop
               (let Db: (dbFile Db)
                  (close (Db: fd))
                  (free (Db: mark)) )
               (? (=0 (dec 'C)))
               (setq Db (ofs Db (dbFile T))) ) )
         (set $DBs 0  $DB $Nil)
         (when (val $DbJnl)
            (fclose @)
            (set $DbJnl null) )
         (when (val $DbLog)
            (fclose @)
            (set $DbLog null) ) )
      (unless (nil? Sym1)
         (let
            (Nm (xName Sym1)  # DB name
               Len (pathSize Nm)
               Buf (pathString Nm (b8 (+ Len 4)))  # 4 bytes for AO file number
               End (ofs Buf (dec Len))
               Siz (dbFile T) )  # Default to single dbFile
            (when (pair Dbs)
               (let L Dbs
                  (while (pair (shift L))
                     (inc 'Siz (dbFile T)) ) ) )
            (let
               (Db (set $DbFiles (alloc (val $DbFiles) Siz))
                  P (b8 (+ BLK BLK 1))
                  Fnr (i32 0)
                  Max (i32 0) )
               (loop
                  (let Db: (dbFile (set $DbFile Db))  # Set current file
                     (Db: db Fnr)
                     (if (atom Dbs)
                        (Db: sh 2)
                        (set (bufAo End Fnr) 0)
                        (Db: sh (i32 (int (++ Dbs)))) )
                     (cond
                        ((ge0 (Db: fd (openRdWr Buf)))  # Exists
                           (blkPeek 0 P (+ BLK BLK 1))  # Read block shift from block zero
                           (Db: siz
                              (shl
                                 (i32 BLKSIZE)
                                 (Db: sh (i32 (val (+ BLK BLK 1) P))) ) ) )  # Override block shift from 'Dbs'
                        ((and
                              (== (gErrno) ENOENT)
                              (ge0 (Db: fd (openRdWrExcl Buf))) )
                           (let
                              (N (shl (i32 BLKSIZE) (Db: sh))
                                 Stk (stack)
                                 Blk (b8 (Db: siz N)) )
                              (memset Blk 0 (i64 N) T)  # 'free' is null
                              (setAdr
                                 (if (== (Db:) (val $DbFiles))  # First file
                                    (* 2 BLKSIZE)  # Block zero plus DB root
                                    BLKSIZE )
                                 (ofs Blk BLK) )  # Address of 'next' in buffer
                              (set  # Set block shift in block zero
                                 (inc (* 2 BLK)) Blk
                                 (i8 (Db: sh)) )
                              (blkPoke 0 Blk N)  # Write DB block zero
                              (when (== (Db:) (val $DbFiles))  # First file
                                 (memset Blk 0 16 T)  # Clear 'next' link in buffer
                                 (setAdr 1 Blk)  # First block for DB root into link field
                                 (blkPoke (i64 (Db: siz)) Blk N) )  # has block size position
                              (stack Stk) ) )
                        (T (openErr Exe Sym1)) )
                     (closeOnExec Exe (Db: fd))
                     (when (> (Db: siz) Max)
                        (setq Max @) )
                     (Db: mark null)
                     (Db: mrks 0)
                     (Db: flu -1)
                     (Db: lck (Db: drt NO))
                     (inc 'Fnr)
                     (? (atom Dbs))
                     (setq Db (ofs Db (dbFile T))) ) )
               (set
                  $DB $Db1
                  $DBs Fnr
                  $MaxBlkSize Max
                  $DbBlock (alloc (val $DbBlock) (i64 Max)) ) ) )
         (unless (nil? Sym2)  # Replication journal
            (let Nm (xName Sym2)  # Journal name
               (unless (fopen (pathString Nm (b8 (pathSize Nm))) ($ "a"))
                  (openErr Exe Sym2) )
               (set $DbJnl @)
               (closeOnExec Exe (fileno @)) ) )
         (unless (nil? Sym3)  # Transaction log
            (let Nm (xName Sym3)  # Transaction log name
               (unless (fopen (pathString Nm (b8 (pathSize Nm))) ($ "a+"))
                  (openErr Exe Sym3) )
               (set $DbLog @)
               (closeOnExec Exe (fileno @))
               (when (transaction)
                  (restore Exe) )
               (truncLog Exe)  ) ) ) )
   $T )

# (pool2 'sym . prg) -> any
(de _Pool2 (Exe)
   (let
      (X (cdr Exe)
         Sym (evSym X)
         Nm (xName Sym)
         Jnl (val $DbJnl)
         Log (val $DbLog)
         C (val $DBs)
         FDs (b32 C) )
      (set $DbJnl null  $DbLog null)  # Stop journal and transaction log
      (let (Db (val $DbFiles)  I (i32 0))  # Iterate DB files
         (loop
            (let Db: (dbFile Db)
               (set (ofs FDs I) (Db: fd)) )  # Save file descriptor
            (? (== C (inc 'I)))
            (setq Db (ofs Db (dbFile T))) ) )
      (let
         (Len (pathSize Nm)
            Buf (pathString Nm (b8 (+ Len 4)))  # 4 bytes for AO file number
            End (ofs Buf (dec Len)) )
         (let (Db (val $DbFiles)  I (i32 0))  # Iterate DB files
            (loop
               (let Db: (dbFile Db)
                  (set (bufAo End (Db: db)) 0)
                  (when (lt0 (Db: fd (openRdWr Buf)))  # Try to open
                     (openErr Exe Sym) )
                  (closeOnExec Exe @) )
               (? (== C (inc 'I)))
               (setq Db (ofs Db (dbFile T))) ) ) )
      (prog1
         (run (cdr X)
            (let (Db (val $DbFiles)  I (i32 0))  # Iterate DB files
               (loop
                  (let Db: (dbFile Db)
                     (close (Db: fd))  # Close file
                     (Db: fd (val (ofs FDs I))) )  # Restore file descriptor
                  (? (== C (inc 'I)))
                  (setq Db (ofs Db (dbFile T))) ) )
            (set $DbLog Log  $DbJnl Jnl) ) ) ) )

# (journal ['T] 'any ..) -> T
(de _Journal (Exe)
   (let
      (X (cdr Exe)
         Sym (evSym X)
         Jnl (val $DbJnl)
         Log (val $DbLog)
         Buf (b8 (val $MaxBlkSize))
         Blk (b8 BLK) )
      (stkChk Exe)
      (when (t? Sym)
         (set $DbJnl null  $DbLog null)  # Stop journal and transaction log
         (setq Sym (evSym (shift X))) )
      (loop
         (let
            (Nm (xName Sym)  # Journal name
               Fp (fopen (pathString Nm (b8 (pathSize Nm))) ($ "r")) )
            (unless Fp
               (openErr Exe Sym) )
            (while (ge0 (getc_unlocked Fp))
               (let Siz @
                  (unless (== (fread Blk 2 1 Fp) 1)  # Read file number
                     (jnlErr Exe) )
                  (if (dbfBuf Blk)  # Get file number from 'Buf' to 'DbFile'
                     (let Db: (dbFile @)
                        #! Temporary backward compatibility
                        (when (== Siz BLKSIZE)
                           (setq Siz (Db: siz)) )
                        #!
                        (unless Siz
                           (setq Siz (Db: siz)) )
                        (unless
                           (and
                              (== (fread Blk BLK 1 Fp) 1)
                              (== (fread Buf (i64 Siz) 1 Fp) 1) )
                           (jnlErr Exe) )
                        (blkPoke
                           (shl (getAdr Blk) (i64 (Db: sh)))
                           Buf
                           Siz ) )
                     (dbfErr Exe) ) ) )  # No local file
            (fclose Fp)
            (? (atom (shift X)))
            (setq Sym (evSym X)) ) )
      (set $DbLog Log  $DbJnl Jnl)
      $T ) )

# (id 'num ['num]) -> sym
# (id 'sym [NIL]) -> num
# (id 'sym T) -> (num . num)
(de _Id (Exe)
   (let (X (cdr Exe)  Y (eval (++ X)))
      (if (cnt? Y)  # File number or object ID
         (extern
            (if (nil? (eval (car X)))
               (extNm 0 (int Y))
               (extNm (dec (i32 (int Y))) (xCnt Exe @)) ) )
         (needSymb Exe Y)
         (unless (sym? (val (tail (needSymb Exe Y))))
            (extErr Exe Y) )
         (let
            (Nm (name (& (val (tail Y)) -9))
               Z (cnt (objId Nm)) )
            (if (nil? (eval (car X)))  # Return only object ID
               Z
               (cons
                  (cnt (i64 (inc (objFile Nm))))
                  Z ) ) ) ) ) )

# (blk 'fd 'cnt 'siz ['fd2]) -> lst
# (blk 'fd 0) -> (cnt . siz)
(de _Blk (Exe)
   (let (X (cdr Exe)  Db: (dbFile (b8+ (dbFile T))))
      (Db: fd (i32 (evCnt Exe X)))  # File descriptor
      (if (=0 (evCnt Exe (shift X)))  # Block number
         (let Buf (b8 BLK)
            (unless
               (==
                  (+ BLK 1)
                  (pread (Db: fd) Buf (+ BLK 1) BLK) )
               (dbRdErr) )
            (cons
               (cnt (shr (getAdr Buf) 6))  # Block count
               (cnt (i64 (val (ofs Buf BLK)))) ) )  # Block shift
         (let
            (N (shl @ 6)  # Block index
               P (val $DbBlock)  # Block buffer
               Siz  # Block size
               (shl
                  (i32 BLKSIZE)
                  (Db: sh (i32 (evCnt Exe (shift X)))) )  # 'siz' scale factor
               Fd
               (i32
                  (if (atom (shift X))
                     -1
                     (evCnt Exe @)) ) )
            (when (> (Db: siz Siz) (val $MaxBlkSize))
               (set $MaxBlkSize Siz  $DbBlock (alloc P (i64 Siz))) )
            (set $DbFile (Db:))
            (when (ge0 Fd)
               (rdLockWait Fd 1) )  # Lock for reading
            (prog1
               (let Blk (rdBlock N)  # Read first block
                  (if (<> 1 (& (val Blk) BLKTAG))  # ID-Block
                     $Nil
                     (set
                        $GetBin (fun (i32) getBlock)
                        $Extn (val $ExtN) )
                     (let
                        (L (cons (binRead) $Nil)  # Read symbol value
                           R (save L) )
                        (until (nil? (binRead))  # Property key
                           (setq L (set 2 L (cons @ $Nil)))
                           (unless (t? (binRead))  # Next property value
                              (set L (cons @ (car L))) ) )
                        R ) ) )
               (when (ge0 Fd)
                  (unLock @ 0 0) ) ) ) ) ) )

# (seq 'cnt|sym1) -> sym | NIL
(de _Seq (Exe)
   (let
      (X (eval (cadr Exe))
         F (dec (i32 (int X)))
         N 0
         Buf (b8 BLK) )
      (unless (cnt? X)
         (unless (sym? (val (tail (needSymb Exe X))))
            (extErr Exe X) )
         (let Nm (name (& (val (tail X)) -9))
            (setq
               F (objFile Nm)
               N (shl (objId Nm) 6) ) ) )
      (when (>= F (val $DBs))
         (dbfErr Exe) )
      (let Db:
         (dbFile
            (set $DbFile
               (ofs (val $DbFiles) (* F (dbFile T))) ) )
         (rdLockDb)  # Lock for reading
         (blkPeek BLK Buf BLK)  # Read 'next' from block zero
         (let Next (getAdr Buf)
            (prog1
               (loop
                  (? (>= (inc 'N BLKSIZE) Next) $Nil)
                  (blkPeek (shl N (i64 (Db: sh))) Buf BLK)  # Read link field
                  (? (== 1 (& (val Buf) BLKTAG))  # ID-Block
                     (extern (extNm F (shr N 6))) ) )
               (unLockDb 1) ) ) ) ) )  # Unlock

# (lieu 'any) -> sym | NIL
(de _Lieu (Exe)
   (let X (eval (cadr Exe))
      (nond
         ((symb? X) $Nil)
         ((sym? (val (tail X))) $Nil)
         (NIL
            (let Nm (name (& (val (tail X)) -9))
               (setq Nm (add Nm Nm))
               (cond
                  (@@  # Dirty
                     (setq Nm (add Nm Nm))
                     (if @@ $Nil X) )  # Deleted
                  (T
                     (setq Nm (add Nm Nm))
                     (if @@ X $Nil) ) ) ) ) ) ) )  # Loaded

# (lock ['sym]) -> cnt | NIL
(de _Lock (Exe)
   (if
      (if (nil? (eval (cadr Exe)))
         (tryLock (val $DbFiles) 0 0)  # Use first dbFile
         (let X (needSymb Exe @)
            (unless (sym? (val (tail (needSymb Exe X))))
               (extErr Exe X) )
            (let
               (Nm (name (& (val (tail X)) -9))
                  F (objFile Nm)
                  N (objId Nm) )
               (when (>= F (val $DBs))
                  (dbfErr Exe) )
               (let Db: (dbFile (ofs (val $DbFiles) (* F (dbFile T))))
                  (tryLock (Db:) (* N (i64 (Db: siz))) 1) ) ) ) )
      (cnt (i64 @))
      $Nil ) )

(local) (db dbFetch dbTouch dbZap)

(de void db (Exe Sym Nm)
   (save Sym)
   (let F (objFile Nm)  # Get file number
      (if (>= F (val $DBs))
         (let Ext (val $Ext)  # Non-local file
            (if
               (or
                  (atom Ext)  # First offset
                  (> (i32 (int (caar @))) (inc 'F)) )  # too big
               (dbfErr Exe)
               (while  # Find DB extension
                  (and
                     (pair (cdr Ext))
                     (>= F (i32 (int (caar @)))) )
                  (shift Ext) )
               (let
                  (V (push NIL $Nil ZERO Sym)  # [car cdr name arg]
                     E (push NIL V ZERO (cdar Ext)) )  # [car cdr name fun]
                  (set V (ofs V 3)  E (ofs E 3))
                  (let X (evList E)
                     (set Sym (++ X))  # Set value
                     (if (atom X)
                        (set (tail Sym) Nm)  # Set status/name
                        (set (tail Sym) (sym X))  # Set property list
                        (while (pair (cdr X))  # Find end
                           (setq X @) )
                        (set 2 X Nm) ) ) ) ) )  # Set status/name
         # Local file
         (set $DbFile
            (ofs (val $DbFiles) (* F (dbFile T))) )
         (rdLockDb)  # Lock for reading
         (let Blk (rdBlock (shl (objId Nm) 6))  # Read first block
            (unless (== 1 (& (val Blk) BLKTAG))  # ID-Block
               (err Exe Sym ($ "Bad ID") null) ) )
         (set
            $GetBin (fun (i32) getBlock)
            $Extn 0 )
         (set Sym (binRead))  # Read symbol value
         (if (nil? (binRead))  # First property key
            (set (tail Sym) Nm)  # Set status/name
            (set (tail Sym)  # Set tail
               (sym (setq Nm (cons @ Nm))) )
            (unless (t? (binRead))  # First property value
               (set Nm (cons @ (val Nm))) )  # Cons with key
            (until (nil? (binRead))  # Next property key
               (set 2 Nm (cons @ (cdr Nm)))
               (shift Nm)
               (unless (t? (binRead))  # Next property value
                  (set Nm (cons @ (val Nm))) ) ) )  # Cons with key
         (unLockDb 1) ) ) )  # Unlock

(de void dbFetch (Exe Sym)
   (let Nm (val (tail Sym))
      (when
         (and
            (num? Nm)  # No properties
            (prog (setq Nm (add Nm Nm)) (not @@))  # Not dirty
            (prog (setq Nm (add Nm Nm)) (not @@)) )  # Not loaded
         (set (tail Sym) (setq Nm (shr 1 Nm 2)))  # Set "loaded"
         (tailcall (db Exe Sym Nm)) ) ) )

(de void dbTouch (Exe Sym)
   (let (Q (tail Sym)  Nm (val Q))
      (unless (num? Nm)  # Has properties
         (setq Nm (any (& Nm -9)))  # Clear 'extern' tag
         (loop
            (setq Q (ofs Nm 1))  # Skip property
            (? (num? (setq Nm (val Q)))) ) )  # Find name
      (setq Nm (add Nm Nm))
      (unless @@  # Not yet dirty
         (setq Nm (add Nm Nm))
         (set Q (setq Nm (shr 2 Nm 2)))  # Set "dirty"
         (unless @@  # Not loaded
            (tailcall (db Exe Sym Nm)) ) ) ) )

# (touch 'sym) -> sym
(de _Touch (Exe)
   (let X (eval (cadr Exe))
      (when (and (symb? X) (sym? (val (tail X))))
         (dbTouch Exe X) )
      X ) )

(de void dbZap (Sym)
   (let Tail (val (tail Sym))  # Get tail
      (unless (num? Tail)  # Any properties
         (setq Tail (& Tail -9))  # Clear 'extern' tag
         (loop
            (? (num? (shift Tail))) )  # Find name
         (setq Tail (sym Tail)) )  # Set 'extern' tag
      (set (tail Sym) (shr 3 (shl Tail 2) 2))  # Set "deleted"
      (set Sym $Nil) ) )  # Clear value

# (commit ['any] [exe1] [exe2]) -> T
(de _Commit (Exe)
   (let (Args (cdr Exe)  Rpc (save (eval (++ Args)))  Notify NO)
      (set $Protect (inc (val $Protect)))
      (wrLockDb)
      (when (val $DbJnl)
         (lockJnl) )
      (when (val $DbLog)
         (let (Db (val $DbFiles)  C (val $DBs))  # Iterate DB files
            (loop
               (let Db: (dbFile Db)
                  (Db: drt NO)  # Clear dirty flag
                  (Db: flu 0) )  # and free list use count
               (? (=0 (dec 'C)))
               (setq Db (ofs Db (dbFile T))) ) )
         (let (Tos 0  P (val $Extern))  # Iterate external symbol tree
            (loop
               (loop
                  (let X (cdr P)  # Get subtrees
                     (? (atom (car X)))  # Left subtree
                     (let Y P  # Go left
                        (setq P @)  # Invert tree
                        (set X Tos)
                        (setq Tos Y) ) ) )
               (loop
                  (let
                     (Nm (name (& (val (tail (val P))) -9))  # Get external symbol name
                        N (add Nm Nm) )
                     (when @@  # Dirty or deleted
                        (let F (objFile Nm)  # Get file number
                           (when (> (val $DBs) F)  # Local file
                              (set $DbFile
                                 (ofs (val $DbFiles) (* F (dbFile T))) )
                              (rdBlock (shl (objId Nm) 6))
                              (loop
                                 (logBlock)
                                 (? (=0 (val $BlkLink)))
                                 (rdBlock @) )
                              (let Db: (dbFile (val $DbFile))
                                 (Db: drt YES)
                                 (add N N)
                                 (unless @@  # Not deleted
                                    (Db: flu (inc (Db: flu))) ) ) ) ) ) )
                  (let X (cdr P)
                     (? (pair (cdr X))  # Right subtree
                        (let Y P  # Go right
                           (setq P @)  # Invert tree
                           (set 2 X Tos)
                           (setq Tos (| Y 8)) ) ) )  # First visit
                  (loop
                     (unless Tos
                        (goto 1) )
                     (? (=0 (& Tos 8))  # Second visit
                        (let (X Tos  Y (cdr X))  # Nodes
                           (setq Tos (car Y))  # TOS on up link
                           (set Y P)
                           (setq P X) ) )
                     (setq Tos (& Tos -9))  # Clear visit bit
                     (let (X Tos  Y (cdr X))  # Nodes
                        (setq Tos (cdr Y))
                        (set 2 Y P)
                        (setq P X) ) ) ) ) )
         (: 1
            (let (P (val $DbFiles)  C (val $DBs))  # Iterate DB files
               (loop
                  (when ((dbFile P) flu)
                     (let N @
                        (set $DbFile P)
                        (rdBlock 0)  # Save Block 0
                        (loop  # and free list
                           (logBlock)
                           (? (=0 (dec 'N)))
                           (? (=0 (val $BlkLink)))
                           (rdBlock @) ) ) )
                  (? (=0 (dec 'C)))
                  (setq P (ofs P (dbFile T))) ) )
            (let Log (val $DbLog)
               (putc_unlocked (hex "FF") Log)  # Write end marker
               (putc_unlocked (hex "FF") Log)
               (fflush Log)
               (when (lt0 (fsync (fileno Log)))
                  (err Exe 0 ($ "Transaction fsync error: %s") (strErrno)) ) ) ) )
      (eval (++ Args)) # Eval pre-expression
      (when (and (not (nil? Rpc)) (or (val $Tell) (val $Children)))
         (setq Notify YES)
         (set
            $BufX (val $TellBuf)  # Save current 'tell' env
            $PtrX (val $Ptr)
            $EndX (val $End) )
         (tellBeg (b8 (val PipeBufSize)))  # Start 'tell' message
         (prTell Rpc) )
      (let (Tos 0  P (val $Extern))  # Iterate external symbol tree
         (loop
            (loop
               (let X (cdr P)  # Get subtrees
                  (? (atom (car X)))  # Left subtree
                  (let Y P  # Go left
                     (setq P @)  # Invert tree
                     (set X Tos)
                     (setq Tos Y) ) ) )
            (loop
               (let (Sym (val P)  Q (tail Sym)  Nm (val Q))  # Get external symbol
                  (unless (num? Nm)  # Any properties
                     (setq Nm (any (& Nm -9)))  # Clear 'extern' tag
                     (loop
                        (setq Q (ofs Nm 1))  # Skip property
                        (? (num? (setq Nm (val Q)))) ) )  # Find name
                  (let N (add Nm Nm)
                     (when @@  # Dirty or deleted
                        (let F (objFile Nm)  # Get file number
                           (setq N (add N N))
                           (cond
                              (@@  # Deleted
                                 (set Q (shr N 2))  # Set "not loaded"
                                 (when (> (val $DBs) F)  # Local file
                                    (set $DbFile
                                       (ofs (val $DbFiles) (* F (dbFile T))) )
                                    (cleanUp (shl (objId Nm) 6))
                                    (when Notify
                                       (let P (val $TellBuf)
                                          (when
                                             (>=  # Space for EXTERN+<8>+END
                                                (val $Ptr)
                                                (ofs P (- (val PipeBufSize) 10)) )
                                             (tellEnd -1)  # Send close 'tell' to all PIDs
                                             (set  # Partial 'tellBeg'
                                                (inc 'P 8) BEG  # 8 bytes space (PID and count)
                                                $Ptr (inc P) )  # Begin a list
                                             (prTell Rpc) ) )
                                       (prTell Sym) ) ) )  # Send external symbol to 'tell'
                              (T  # Dirty
                                 (set Q (shr 1 N 2))  # Set "loaded"
                                 (when (> (val $DBs) F)  # Local file
                                    (set $DbFile
                                       (ofs (val $DbFiles) (* F (dbFile T))) )
                                    (let Blk (rdBlock (shl (objId Nm) 6))  # Read first block
                                       (set
                                          Blk (| (val Blk) 1)  # First block in object (might be new)
                                          $PutBin (fun (void i8) putBlock)
                                          $Extn 0 )
                                       (binPrint (val Sym))  # Print value
                                       (let L (& (val (tail Sym)) -9)  # Get Properties
                                          (until (num? L)
                                             (let V (++ L)
                                                (nond
                                                   ((atom V)  # Not boolean
                                                      (unless (nil? (cdr V))  # Not volatile property
                                                         (binPrint @)  # Print key
                                                         (binPrint (car V)) ) )  # and value
                                                   ((nil? V)  # Not volatile property
                                                      (binPrint V)  # Print key
                                                      (binPrint $T) ) ) ) ) )  # and 'T'
                                       (putBlock NIX)
                                       (setAdr  # Clear link
                                          (i64 (& (val (val $DbBlock)) BLKTAG))  # Lowest byte of link field
                                          Blk )
                                       (wrBlock)  # Write block
                                       (when (val $BlkLink)  # More blocks
                                          (cleanUp @) )  # Clean up
                                       (when Notify
                                          (let P (val $TellBuf)
                                             (when
                                                (>=  # Space for EXTERN+<8>+END
                                                   (val $Ptr)
                                                   (ofs P (- (val PipeBufSize) 10)) )
                                                (tellEnd -1)  # Send close 'tell' to all PIDs
                                                (set  # Partial 'tellBeg'
                                                   (inc 'P 8) BEG  # 8 bytes space (PID and count)
                                                   $Ptr (inc P) )  # Begin a list
                                                (prTell Rpc) ) )
                                          (prTell Sym) ) ) ) ) ) ) ) ) )  # Send external symbol to 'tell'
               (let X (cdr P)
                  (? (pair (cdr X))  # Right subtree
                     (let Y P  # Go right
                        (setq P @)  # Invert tree
                        (set 2 X Tos)
                        (setq Tos (| Y 8)) ) ) )  # First visit
               (loop
                  (unless Tos
                     (goto 2) )
                  (? (=0 (& Tos 8))  # Second visit
                     (let (X Tos  Y (cdr X))  # Nodes
                        (setq Tos (car Y))  # TOS on up link
                        (set Y P)
                        (setq P X) ) )
                  (setq Tos (& Tos -9))  # Clear visit bit
                  (let (X Tos  Y (cdr X))  # Nodes
                     (setq Tos (cdr Y))
                     (set 2 Y P)
                     (setq P X) ) ) ) ) )
      (: 2
         (when Notify
            (tellEnd -1)
            (set
               $TellBuf (val $BufX)
               $Ptr (val $PtrX)
               $End (val $EndX) ) ) )
      (eval (car Args)) # Eval post-expression
      (when (val $DbJnl)
         (unLockJnl) )
      (when (pair (val $Zap))  # Objects to delete
         (let
            (Z @
               Out (val $OutFile)
               Nm (xName (cdr Z))
               S (pathString Nm (b8 (pathSize Nm)))
               Out: (outFile (b8+ (outFile T))) )
            (when (lt0 (openWrAppend S))
               (openErr Exe (cdr Z)) )
            (Out: fd @)
            (Out: ix 0)
            (Out: tty NO)
            (set
               $OutFile (Out:)
               $PutBin (fun (void i8) _putStdout)
               $Extn 0 )
            (let Y (car Z)  # Print zap list
               (while (pair Y)
                  (binPrint (++ Y) ) )
               (flush (Out:))
               (close (Out: fd))
               (set Z $Nil)  # Clear zap list
               (set $OutFile Out) ) ) )  # Restore output channel
      (when (val $DbLog)
         (fsyncDB Exe)
         (truncLog Exe) )
      (unLockDb 0)  # Unlock all
      (unsync)
      (set $Protect (dec (val $Protect)))
      (let (P (val $DbFiles)  C (val $DBs))  # Iterate DB files
         (loop
            ((dbFile P) flu -1)  # Init free list use count
            (? (=0 (dec 'C)))
            (setq P (ofs P (dbFile T))) ) )
      $T ) )

# (mark 'sym|0 [NIL | T | 0]) -> flg
(de _Mark (Exe)
   (let (X (cdr Exe)  Y (eval (++ X)))
      (if (== Y ZERO)  # Clear all marks
         (let (Db (val $DbFiles)  C (val $DBs))  # Iterate DB files
            (while (ge0 (dec 'C))
               (let Db: (dbFile Db)
                  (Db: mrks 0)  # Set mark vector size to zero
                  (free (Db: mark))  # Free mark bit vector
                  (Db: mark null) )  # and set to null
               (setq Db (ofs Db (dbFile T))) )
            $Nil )
         (unless (sym? (val (tail (needSymb Exe Y))))
            (extErr Exe Y) )
         (let
            (Nm (name (& (val (tail Y)) -9))
               F (objFile Nm)
               N (objId Nm) )
            (if (>= F (val $DBs))
               $T  # Non-local file
               (let
                  (Flg (eval (car X))  # Second arg
                     Db: (dbFile (ofs (val $DbFiles) (* F (dbFile T))))
                     P (Db: mark)  # Mark bit vector
                     I (shr N 3) )  # Byte index
                  (when (>= I (Db: mrks))  # Greater or equal to mark vector size
                     (let J (inc I)
                        (memset
                           (ofs
                              (setq P (Db: mark (alloc P J)))  # Increase mark bit vector
                              (Db: mrks) )
                           0  # Clear new area
                           (- J (Db: mrks)) )
                        (Db: mrks J) ) )  # New mark vector size
                  (setq
                     P (ofs P I)  # Byte position in bit vector
                     N (i8 (shl 1 (& N 7))) )  # Bit position
                  (let B (val P)  # Old value
                     (cond
                        ((& B N)  # Bit is set
                           (when (== ZERO Flg)
                              (set P (& B (x| N -1))) )  # Clear mark
                           $T )  # Return T
                        (T  # Bit is not set
                           (when (== $T Flg)
                              (set P (| B N)) )  # Set mark
                           $Nil ) ) ) ) ) ) ) ) )  # Return NIL

# (free 'cnt) -> (sym . lst)
(de _Free (Exe)
   (let
      (X (cdr Exe)
         F (dec (i32 (evCnt Exe X)))
         Buf (b8 (* BLK 2)) )
      (when (>= F (val $DBs))
         (dbfErr Exe) )
      (set $DbFile
         (ofs (val $DbFiles) (* F (dbFile T))) )
      (rdLockDb)  # Lock for reading
      (blkPeek 0 Buf (* 2 BLK))  # Read 'free' and 'next' from block zero
      (set $BlkLink (getAdr Buf))  # free' as next block
      (let
         (Y
            (cons  # CAR of result list
               (extern  # 'next' symbol
                  (extNm F (shr (getAdr (ofs Buf BLK)) 6)) )
               $Nil )
            R (save Y) )
         (while (val $BlkLink)  # Collect free list
            (setq Y
               (set 2 Y
                  (cons (extern (extNm F (shr @ 6))) $Nil) ) )
            (rdBlock @) )
         (unLockDb 1)  # Unlock
         R ) ) )

# (dbck ['cnt] 'flg) -> any
(de _Dbck (Exe)
   (let
      (X (cdr Exe)
         Y (eval (car X))
         Jnl (val $DbJnl)
         Buf (b8 (* BLK 2))
         Cnt BLKSIZE
         Syms 0
         Blks 0 )
      (if (cnt? Y)
         (let F (dec (i32 (int Y)))
            (when (>= F (val $DBs))
               (dbfErr Exe) )
            (set $DbFile
               (ofs (val $DbFiles) (* F (dbFile T))) )
            (setq Y (eval (cadr X))) )  # Use first dbFile
         (set $DbFile (val $DbFiles)) )
      (set $Protect (inc (val $Protect)))
      (wrLockDb)
      (when Jnl
         (lockJnl)  # Write lock journal
         (set $DbJnl null) )  # Disable Journal
      (blkPeek 0 Buf (* 2 BLK))  # Read 'free' and 'next' from block zero
      (set $BlkLink (getAdr Buf))  # free' as next block
      (let Next (getAdr (ofs Buf BLK))  # Get 'next'
         (while (val $BlkLink)  # Check free list
            (let Blk (rdBlock @)
               (set Blk (| (val Blk) BLKTAG)) )  # Mark free list
            (when (> (inc 'Cnt BLKSIZE) Next)
               (setq Y (mkStr ($ "Circular free list")))
               (goto 9) )
            (wrBlock) )
         (set $DbJnl Jnl)  # Restore Journal
         (let P BLKSIZE
            (until (== P Next)  # Check all chains
               (let Blk (rdBlock P)
                  (case (& (val Blk) BLKTAG)
                     (0  # Free block
                        (inc 'Cnt BLKSIZE)
                        (memcpy Blk Buf BLK T)
                        (wrBlock)
                        (setAdr P Buf)
                        (blkPoke 0 Buf BLK) )
                     (1  # ID-block of symbol
                        (inc 'Syms)
                        (let I (i8 2)
                           (loop  # Check chains
                              (inc 'Blks)
                              (inc 'Cnt BLKSIZE)
                              (? (=0 (val $BlkLink)))
                              (unless
                                 (== I
                                    (& (val (rdBlock @)) BLKTAG) )
                                 (setq Y (mkStr ($ "Bad chain")))
                                 (goto 9) )
                              (when (> BLKTAG I)
                                 (inc 'I) ) ) ) ) ) )
               (inc 'P BLKSIZE) ) )
         (set $BlkLink (getAdr Buf))
         (set $DbJnl null)  # Disable Journal
         (while (val $BlkLink)  # Unmark free list
            (let Blk (rdBlock @)
               (when (& (val Blk) BLKTAG)
                  (set Blk (& (val Blk) BLKMASK))
                  (wrBlock) ) ) )
         (nond
            ((== Cnt Next)
               (setq Y (mkStr ($ "Bad count"))) )
            ((nil? Y)
               (setq Y (cons (cnt Blks) (cnt Syms))) ) ) )
      (: 9
         (when (set $DbJnl Jnl)
            (unLockJnl) )
         (unLockDb 1)  # Unlock
         (set $Protect (dec (val $Protect)))
         Y ) ) )
pil21/src/apply.l0000644000000000000000000005266314464350566011015 0ustar  # 08aug23 Software Lab. Alexander Burger

(symbols '(llvm))

# (apply 'fun 'lst ['any ..]) -> any
(de _Apply (Exe)
   (let
      (X (cdr Exe)
         E (push NIL $Nil ZERO (eval (++ X)) NIL) )  # [car cdr name fun link]
      (set E (link (ofs E 3) T))
      (let (L (save (eval (car X)))  P E)
         (while (pair (shift X))
            (setq P
               (set 2 P
                  (push NIL $Nil ZERO (eval (car X)) NIL) ) )  # [car cdr name val link]
            (set P (link (ofs P 3))) )
         (while (pair L)
            (stkChk Exe)
            (setq P
               (set 2 P (push NIL $Nil ZERO (++ L) NIL)) )
            (set P (link (ofs P 3))) )
         (evList E) ) ) )

# (pass 'fun ['any ..]) -> any
(de _Pass (Exe)
   (let
      (X (cdr Exe)
         E (push NIL $Nil ZERO (eval (++ X)) NIL) )
      (set E (link (ofs E 3) T))
      (let P E
         (while (pair X)
            (setq P
               (set 2 P
                  (push NIL $Nil ZERO (eval (++ X)) NIL) ) )
            (set P (link (ofs P 3))) )
         (let L (val $Next)
            (while (pair L)
               (setq P
                  (set 2 P (push NIL $Nil ZERO (cdr L) NIL)) )
               (set P (link (ofs P 3)))
               (setq L (car L)) ) ) )
      (evList E) ) )

# (fun 'fun ['any ..]) -> any
(de _Fun (Exe)
   (evList (cdr Exe)) )

# (maps 'fun 'sym ['lst ..]) -> any
(de _Maps (Exe)
   (let
      (X (cdr Exe)
         R $Nil
         E (push NIL $Nil ZERO (eval (++ X)) NIL)
         A (push NIL NIL) )
      (set E (link (ofs E 3) T))
      (let
         (P E
            Q A
            Sym (save (needSymb Exe (eval (car X))))
            V Sym )
         (set Q V)
         (loop
            (setq P
               (set 2 P (push NIL $Nil ZERO V NIL)) )
            (set P (link (ofs P 3)))
            (? (atom (shift X)))
            (setq
               Q (set 2 Q (push NIL NIL))
               V (save (eval (car X))) )
            (set Q V)
            (when (pair V)
               (setq V (car V)) ) )
         (when (sym? (setq V (val (tail Sym))))
            (dbFetch Exe Sym)
            (setq V (& (val (tail Sym)) -9)) )
         (set 4 (cdr E)
            (if (pair V) (car V) V) )
         (set A V) )
      (when (pair (car A))
         (loop
            (setq R (evList E))
            (? (atom (set A (cdar A))))
            (let (P (cdr E)  Q A)
               (set 4 P (car @))
               (while (pair (shift P))
                  (set 4 P
                     (cond
                        ((atom (car (shift Q))) @)
                        ((atom (set Q (cdr @))) @)
                        (T (car @)) ) ) ) ) ) )
      R ) )

# (map 'fun 'lst ..) -> lst
(de _Map (Exe)
   (let
      (X (cdr Exe)
         R $Nil
         E (push NIL $Nil ZERO (eval (car X)) NIL) )
      (set E (link (ofs E 3) T))
      (let P E
         (while (pair (shift X))
            (setq P
               (set 2 P
                  (push NIL $Nil ZERO (eval (car X)) NIL) ) )
            (set P (link (ofs P 3))) ) )
      (loop
         (let P (cdr E)
            (? (atom (val 4 P)))
            (setq R (evList E))
            (loop
               (when (pair (val 4 P))
                  (set 4 P (cdr @)) )
               (? (atom (shift P))) ) ) )
      R ) )

# (mapc 'fun 'lst ..) -> lst
(de _Mapc (Exe)
   (let
      (X (cdr Exe)
         R $Nil
         E (push NIL $Nil ZERO (eval (++ X)) NIL)
         A (push NIL NIL) )
      (set E (link (ofs E 3) T))
      (let (P E  Q A)
         (loop
            (let V (set Q (save (eval (car X))))
               (when (pair V)
                  (setq V (car V)) )
               (setq P
                  (set 2 P (push NIL $Nil ZERO V NIL)) )
               (set P (link (ofs P 3))) )
            (? (atom (shift X)))
            (setq Q (set 2 Q (push NIL NIL))) ) )
      (when (pair (car A))
         (loop
            (setq R (evList E))
            (? (atom (set A (cdar A))))
            (let (P (cdr E)  Q A)
               (set 4 P (car @))
               (while (pair (shift P))
                  (set 4 P
                     (cond
                        ((atom (car (shift Q))) @)
                        ((atom (set Q (cdr @))) @)
                        (T (car @)) ) ) ) ) ) )
      R ) )

# (maplist 'fun 'lst ..) -> lst
(de _Maplist (Exe)
   (let
      (X (cdr Exe)
         R (save $Nil)
         L 0
         E (push NIL $Nil ZERO (eval (car X)) NIL) )
      (set E (link (ofs E 3)))
      (let P E
         (while (pair (shift X))
            (setq P
               (set 2 P
                  (push NIL $Nil ZERO (eval (car X)) NIL) ) )
            (set P (link (ofs P 3))) ) )
      (loop
         (let P (cdr E)
            (? (atom (val 4 P)))
            (let Y (cons (evList E) $Nil)
               (setq L
                  (if L
                     (set 2 L Y)
                     (setq R (safe Y)) ) ) )
            (loop
               (when (pair (val 4 P))
                  (set 4 P (cdr @)) )
               (? (atom (shift P))) ) ) )
      R ) )

# (mapcar 'fun 'lst ..) -> lst
(de _Mapcar (Exe)
   (let
      (X (cdr Exe)
         R (save $Nil)
         L 0
         E (push NIL $Nil ZERO (eval (++ X)) NIL)
         A (push NIL NIL) )
      (set E (link (ofs E 3)))
      (let (P E  Q A)
         (loop
            (let V (set Q (save (eval (car X))))
               (when (pair V)
                  (setq V (car V)) )
               (setq P
                  (set 2 P (push NIL $Nil ZERO V NIL)) )
               (set P (link (ofs P 3))) )
            (? (atom (shift X)))
            (setq Q (set 2 Q (push NIL NIL))) ) )
      (when (pair (car A))
         (loop
            (let Y (cons (evList E) $Nil)
               (setq L
                  (if L
                     (set 2 L Y)
                     (setq R (safe Y)) ) ) )
            (? (atom (set A (cdar A))))
            (let (P (cdr E)  Q A)
               (set 4 P (car @))
               (while (pair (shift P))
                  (set 4 P
                     (cond
                        ((atom (car (shift Q))) @)
                        ((atom (set Q (cdr @))) @)
                        (T (car @)) ) ) ) ) ) )
      R ) )

# (mapcon 'fun 'lst ..) -> lst
(de _Mapcon (Exe)
   (let
      (X (cdr Exe)
         R (save $Nil)
         L 0
         E (push NIL $Nil ZERO (eval (car X)) NIL) )
      (set E (link (ofs E 3)))
      (let P E
         (while (pair (shift X))
            (setq P
               (set 2 P
                  (push NIL $Nil ZERO (eval (car X)) NIL) ) )
            (set P (link (ofs P 3))) ) )
      (loop
         (let P (cdr E)
            (? (atom (val 4 P)))
            (let Y (evList E)
               (when (pair Y)
                  (setq L
                     (if L
                        (let Z L
                           (while (pair (cdr Z))
                              (setq Z @) )
                           (set 2 Z Y) )
                        (setq R (safe Y)) ) ) ) )
            (loop
               (when (pair (val 4 P))
                  (set 4 P (cdr @)) )
               (? (atom (shift P))) ) ) )
      R ) )

# (mapcan 'fun 'lst ..) -> lst
(de _Mapcan (Exe)
   (let
      (X (cdr Exe)
         R (save $Nil)
         L 0
         E (push NIL $Nil ZERO (eval (++ X)) NIL)
         A (push NIL NIL) )
      (set E (link (ofs E 3)))
      (let (P E  Q A)
         (loop
            (let V (set Q (save (eval (car X))))
               (when (pair V)
                  (setq V (car V)) )
               (setq P
                  (set 2 P (push NIL $Nil ZERO V NIL)) )
               (set P (link (ofs P 3))) )
            (? (atom (shift X)))
            (setq Q (set 2 Q (push NIL NIL))) ) )
      (when (pair (car A))
         (loop
            (let Y (evList E)
               (when (pair Y)
                  (setq L
                     (if L
                        (let Z L
                           (while (pair (cdr Z))
                              (setq Z @) )
                           (set 2 Z Y) )
                        (setq R (safe Y)) ) ) ) )
            (? (atom (set A (cdar A))))
            (let (P (cdr E)  Q A)
               (set 4 P (car @))
               (while (pair (shift P))
                  (set 4 P
                     (cond
                        ((atom (car (shift Q))) @)
                        ((atom (set Q (cdr @))) @)
                        (T (car @)) ) ) ) ) ) )
      R ) )

# (filter 'fun 'lst ..) -> lst
(de _Filter (Exe)
   (let
      (X (cdr Exe)
         R (save $Nil)
         L 0
         E (push NIL $Nil ZERO (eval (++ X)) NIL)
         A (push NIL NIL) )
      (set E (link (ofs E 3)))
      (let (P E  Q A)
         (loop
            (let V (set Q (save (eval (car X))))
               (when (pair V)
                  (setq V (car V)) )
               (setq P
                  (set 2 P (push NIL $Nil ZERO V NIL)) )
               (set P (link (ofs P 3))) )
            (? (atom (shift X)))
            (setq Q (set 2 Q (push NIL NIL))) ) )
      (when (pair (car A))
         (loop
            (unless (nil? (evList E))
               (let Y (cons (caar A) $Nil)
                  (setq L
                     (if L
                        (set 2 L Y)
                        (setq R (safe Y)) ) ) ) )
            (? (atom (set A (cdar A))))
            (let (P (cdr E)  Q A)
               (set 4 P (car @))
               (while (pair (shift P))
                  (set 4 P
                     (cond
                        ((atom (car (shift Q))) @)
                        ((atom (set Q (cdr @))) @)
                        (T (car @)) ) ) ) ) ) )
      R ) )

# (extract 'fun 'lst ..) -> lst
(de _Extract (Exe)
   (let
      (X (cdr Exe)
         R (save $Nil)
         L 0
         E (push NIL $Nil ZERO (eval (++ X)) NIL)
         A (push NIL NIL) )
      (set E (link (ofs E 3)))
      (let (P E  Q A)
         (loop
            (let V (set Q (save (eval (car X))))
               (when (pair V)
                  (setq V (car V)) )
               (setq P
                  (set 2 P (push NIL $Nil ZERO V NIL)) )
               (set P (link (ofs P 3))) )
            (? (atom (shift X)))
            (setq Q (set 2 Q (push NIL NIL))) ) )
      (when (pair (car A))
         (loop
            (unless (nil? (evList E))
               (let Y (cons @ $Nil)
                  (setq L
                     (if L
                        (set 2 L Y)
                        (setq R (safe Y)) ) ) ) )
            (? (atom (set A (cdar A))))
            (let (P (cdr E)  Q A)
               (set 4 P (car @))
               (while (pair (shift P))
                  (set 4 P
                     (cond
                        ((atom (car (shift Q))) @)
                        ((atom (set Q (cdr @))) @)
                        (T (car @)) ) ) ) ) ) )
      R ) )

# (seek 'fun 'lst ..) -> lst
(de _Seek (Exe)
   (let
      (X (cdr Exe)
         E (push NIL $Nil ZERO (eval (car X)) NIL) )
      (set E (link (ofs E 3) T))
      (let P E
         (while (pair (shift X))
            (setq P
               (set 2 P
                  (push NIL $Nil ZERO (eval (car X)) NIL) ) )
            (set P (link (ofs P 3))) ) )
      (loop
         (let P (cdr E)
            (? (atom (val 4 P)) $Nil)
            (? (not (nil? (evList E)))
               (set $At2 @)
               (val 4 P) )
            (loop
               (when (pair (val 4 P))
                  (set 4 P (cdr @)) )
               (? (atom (shift P))) ) ) ) ) )

# (find 'fun 'lst ..) -> any
(de _Find (Exe)
   (let
      (X (cdr Exe)
         E (push NIL $Nil ZERO (eval (++ X)) NIL)
         A (push NIL NIL) )
      (set E (link (ofs E 3) T))
      (let (P E  Q A)
         (loop
            (let V (set Q (save (eval (car X))))
               (when (pair V)
                  (setq V (car V)) )
               (setq P
                  (set 2 P (push NIL $Nil ZERO V NIL)) )
               (set P (link (ofs P 3))) )
            (? (atom (shift X)))
            (setq Q (set 2 Q (push NIL NIL))) ) )
      (if (atom (car A))
         $Nil
         (loop
            (? (not (nil? (evList E)))
               (set $At2 @)
               (caar A) )
            (? (atom (set A (cdar A))) $Nil)
            (let (P (cdr E)  Q A)
               (set 4 P (car @))
               (while (pair (shift P))
                  (set 4 P
                     (cond
                        ((atom (car (shift Q))) @)
                        ((atom (set Q (cdr @))) @)
                        (T (car @)) ) ) ) ) ) ) ) )

# (pick 'fun 'lst ..) -> any
(de _Pick (Exe)
   (let
      (X (cdr Exe)
         E (push NIL $Nil ZERO (eval (++ X)) NIL)
         A (push NIL NIL) )
      (set E (link (ofs E 3) T))
      (let (P E  Q A)
         (loop
            (let V (set Q (save (eval (car X))))
               (when (pair V)
                  (setq V (car V)) )
               (setq P
                  (set 2 P (push NIL $Nil ZERO V NIL)) )
               (set P (link (ofs P 3))) )
            (? (atom (shift X)))
            (setq Q (set 2 Q (push NIL NIL))) ) )
      (if (atom (car A))
         $Nil
         (loop
            (? (not (nil? (evList E))) @)
            (? (atom (set A (cdar A))) $Nil)
            (let (P (cdr E)  Q A)
               (set 4 P (car @))
               (while (pair (shift P))
                  (set 4 P
                     (cond
                        ((atom (car (shift Q))) @)
                        ((atom (set Q (cdr @))) @)
                        (T (car @)) ) ) ) ) ) ) ) )

# (fully 'fun 'lst ..) -> flg
(de _Fully (Exe)
   (let
      (X (cdr Exe)
         E (push NIL $Nil ZERO (eval (++ X)) NIL)
         A (push NIL NIL) )
      (set E (link (ofs E 3) T))
      (let (P E  Q A)
         (loop
            (let V (set Q (save (eval (car X))))
               (when (pair V)
                  (setq V (car V)) )
               (setq P
                  (set 2 P (push NIL $Nil ZERO V NIL)) )
               (set P (link (ofs P 3))) )
            (? (atom (shift X)))
            (setq Q (set 2 Q (push NIL NIL))) ) )
      (if (atom (car A))
         $T
         (loop
            (? (nil? (evList E)) @)
            (? (atom (set A (cdar A))) $T)
            (let (P (cdr E)  Q A)
               (set 4 P (car @))
               (while (pair (shift P))
                  (set 4 P
                     (cond
                        ((atom (car (shift Q))) @)
                        ((atom (set Q (cdr @))) @)
                        (T (car @)) ) ) ) ) ) ) ) )

# (cnt 'fun 'lst ..) -> cnt
(de _Cnt (Exe)
   (let
      (X (cdr Exe)
         R ZERO
         E (push NIL $Nil ZERO (eval (++ X)) NIL)
         A (push NIL NIL) )
      (set E (link (ofs E 3) T))
      (let (P E  Q A)
         (loop
            (let V (set Q (save (eval (car X))))
               (when (pair V)
                  (setq V (car V)) )
               (setq P
                  (set 2 P (push NIL $Nil ZERO V NIL)) )
               (set P (link (ofs P 3))) )
            (? (atom (shift X)))
            (setq Q (set 2 Q (push NIL NIL))) ) )
      (when (pair (car A))
         (loop
            (unless (nil? (evList E))
               (inc 'R (hex "10")) )  # Increment count
            (? (atom (set A (cdar A))))
            (let (P (cdr E)  Q A)
               (set 4 P (car @))
               (while (pair (shift P))
                  (set 4 P
                     (cond
                        ((atom (car (shift Q))) @)
                        ((atom (set Q (cdr @))) @)
                        (T (car @)) ) ) ) ) ) )
      R ) )

# (sum 'fun 'lst ..) -> num
(de _Sum (Exe)
   (let
      (X (cdr Exe)
         R (save ZERO)
         E (push NIL $Nil ZERO (eval (++ X)) NIL)
         A (push NIL NIL) )
      (set E (link (ofs E 3)))
      (let (P E  Q A)
         (loop
            (let V (set Q (save (eval (car X))))
               (when (pair V)
                  (setq V (car V)) )
               (setq P
                  (set 2 P (push NIL $Nil ZERO V NIL)) )
               (set P (link (ofs P 3))) )
            (? (atom (shift X)))
            (setq Q (set 2 Q (push NIL NIL))) ) )
      (when (pair (car A))
         (loop
            (when (num? (evList E))
               (save @
                  (setq R (safe (adds R @))) ) )
            (? (atom (set A (cdar A))))
            (let (P (cdr E)  Q A)
               (set 4 P (car @))
               (while (pair (shift P))
                  (set 4 P
                     (cond
                        ((atom (car (shift Q))) @)
                        ((atom (set Q (cdr @))) @)
                        (T (car @)) ) ) ) ) ) )
      R ) )

# (maxi 'fun 'lst ..) -> any
(de _Maxi (Exe)
   (let
      (X (cdr Exe)
         R $Nil
         R2 (save $Nil)
         E (push NIL $Nil ZERO (eval (++ X)) NIL)
         A (push NIL NIL) )
      (set E (link (ofs E 3)))
      (let (P E  Q A)
         (loop
            (let V (set Q (save (eval (car X))))
               (when (pair V)
                  (setq V (car V)) )
               (setq P
                  (set 2 P (push NIL $Nil ZERO V NIL)) )
               (set P (link (ofs P 3))) )
            (? (atom (shift X)))
            (setq Q (set 2 Q (push NIL NIL))) ) )
      (when (pair (car A))
         (loop
            (let Y (evList E)
               (when (gt0 (compare Y R2))
                  (setq R (caar A))
                  (setq R2 (safe Y)) ) )
            (? (atom (set A (cdar A))))
            (let (P (cdr E)  Q A)
               (set 4 P (car @))
               (while (pair (shift P))
                  (set 4 P
                     (cond
                        ((atom (car (shift Q))) @)
                        ((atom (set Q (cdr @))) @)
                        (T (car @)) ) ) ) ) ) )
      (set $At2 R2)
      R ) )

# (mini 'fun 'lst ..) -> any
(de _Mini (Exe)
   (let
      (X (cdr Exe)
         R $Nil
         R2 (save $T)
         E (push NIL $Nil ZERO (eval (++ X)) NIL)
         A (push NIL NIL) )
      (set E (link (ofs E 3)))
      (let (P E  Q A)
         (loop
            (let V (set Q (save (eval (car X))))
               (when (pair V)
                  (setq V (car V)) )
               (setq P
                  (set 2 P (push NIL $Nil ZERO V NIL)) )
               (set P (link (ofs P 3))) )
            (? (atom (shift X)))
            (setq Q (set 2 Q (push NIL NIL))) ) )
      (when (pair (car A))
         (loop
            (let Y (evList E)
               (when (lt0 (compare Y R2))
                  (setq R (caar A))
                  (setq R2 (safe Y)) ) )
            (? (atom (set A (cdar A))))
            (let (P (cdr E)  Q A)
               (set 4 P (car @))
               (while (pair (shift P))
                  (set 4 P
                     (cond
                        ((atom (car (shift Q))) @)
                        ((atom (set Q (cdr @))) @)
                        (T (car @)) ) ) ) ) ) )
      (set $At2 R2)
      R ) )

(local) fish

(de void fish (E V P R S)
   (set P V)
   (cond
      ((nil? (evList E))
         (when (pair V)
            (stkChk 0)
            (unless (nil? (cdr V))
               (fish E @ P R S) )
            (fish E (car V) P R S) ) )
      ((<> @ S)
         (set R (cons V (val R))) ) ) )

# (fish 'fun 'any ['any2] ..) -> lst
(de _Fish (Exe)
   (let
      (X (cdr Exe)
         R (link (push $Nil NIL) T)
         P (push NIL $Nil ZERO NIL)
         E (push NIL P ZERO (eval (++ X)) NIL) )
      (set
         P (ofs P 3)
         E (link (ofs E 3)) )
      (let
         (V (save (eval (++ X)))
            S (save (eval (car X)))
            Q P )
         (while (pair (shift X))
            (setq Q
               (set 2 Q
                  (push NIL $Nil ZERO (eval (car X)) NIL) ) )  # [car cdr name val link]
            (set Q (link (ofs Q 3))) )
         (fish E V (ofs P 3) R S)
         (val R) ) ) )

# (by 'fun1 'fun2 'lst ..) -> lst
(de _By (Exe)
   (let
      (X (cdr Exe)
         R (save $Nil)
         L 0
         E (push NIL $Nil ZERO (eval (++ X)) NIL)
         A (push NIL NIL)
         Fun2 (save (eval (++ X)))
         A2 A )
      (set E (link (ofs E 3)))
      (let (P E  Q A)
         (loop
            (let V (set Q (save (eval (car X))))
               (when (pair V)
                  (setq V (car V)) )
               (setq P
                  (set 2 P (push NIL $Nil ZERO V NIL)) )
               (set P (link (ofs P 3))) )
            (? (atom (shift X)))
            (setq Q (set 2 Q (push NIL NIL))) ) )
      (when (pair (car A))
         (loop
            (let Y (cons (cons (evList E) (caar A)) $Nil)
               (setq L
                  (if L
                     (set 2 L Y)
                     (setq R (safe Y)) ) ) )
            (? (atom (set A (cdar A))))
            (let (P (cdr E)  Q A)
               (set 4 P (car @))
               (while (pair (shift P))
                  (set 4 P
                     (cond
                        ((atom (car (shift Q))) @)
                        ((atom (set Q (cdr @))) @)
                        (T (car @)) ) ) ) ) )
         (set 4 E Fun2  4 (cdr E) R)
         (let Z (setq R (safe (evList E)))
            (loop
               (set Z (cdar Z))
               (? (atom (shift Z))) ) ) )
      R ) )

# Readline
(local) tabComplete

(de i8* tabComplete ((i8* . Text))
   (if (nil? (val $Complete))
      null
      (let
         (V (push NIL $Nil ZERO NIL NIL)  # [car cdr name arg link]
            E (push NIL V ZERO @ NIL) )  # [car cdr name fun link]
         (set 4 V
            (nond
               (Text $Nil)
               ((val Text) $T)
               (NIL (mkStr Text)) ) )
         (set
            V (link (ofs V 3) T)
            E (link (ofs E 3)) )
         (if (nil? (evList E))
            null
            (let Nm (name (val (tail (xSym @))))
               (strdup (bufString Nm (b8 (bufSize Nm)))) ) ) ) ) )
pil21/src/flow.l0000644000000000000000000016072214752046714010630 0ustar  # 09feb25 Software Lab. Alexander Burger

(symbols '(llvm))

(local) (redefMsg putSrc redefine)

(de void redefMsg (Sym Sym2)
   (let (Out (val $OutFile)  Put (val (i8** $Put)))
      (set
         $OutFile (val 3 (val $OutFiles))  # Stderr
         $Put (fun (void i8) _putStdout) )
      (outString ($ "# "))
      (print Sym)
      (when Sym2
         (space)
         (print @) )
      (outString ($ " redefined\n"))
      (set (i8** $Put) Put  $OutFile Out) ) )

(de void putSrc (Sym Key)
   (unless
      (or
         (nil? (val $Dbg))
         (sym? (val (tail Sym))) )
      (let In: (inFile (val $InFile))
         (when (and (In:) (In: name))
            (let
               (Dbg (get Sym $Dbg)
                  Src
                  (cons
                     (cnt (i64 (In: src)))
                     (cons (mkStr (In: name)) (val $Intern)) ) )
               (cond
                  ((=0 Key)
                     (if (nil? Dbg)
                        (put Sym $Dbg (cons Src $Nil))  # Put initial '*Dbg' properties
                        (set Dbg Src) ) )  # Set first '*Dbg' property
                  ((nil? Dbg)
                     (put Sym $Dbg
                        (cons $Nil (cons (cons Key Src) $Nil)) ) )
                  (T
                     (let X Dbg
                        (loop
                           (? (atom (shift X))
                              (set 2 Dbg (cons (cons Key Src) (cdr Dbg))) )
                           (? (== (caar X) Key)
                              (set 2 (car X) Src) ) ) ) ) ) ) ) ) ) )

(de void redefine (Exe Sym Val)
   (needChkVar Exe Sym)
   (let V (val Sym)
      (unless (or (nil? V) (== V Sym) (equal V Val))
         (redefMsg Sym 0) ) )
   (set Sym Val)
   (putSrc Sym 0) )

# (quote . any) -> any
(de _Quote (Exe)
   (cdr Exe) )

# (as 'any1 . any2) -> any2 | NIL
(de _As (Exe)
   (let X (cdr Exe)
      (if (nil? (eval (car X)))
         @
         (cdr X) ) ) )

# (lit 'any) -> any
(de _Lit (Exe)
   (let X (eval (cadr Exe))
      (if
         (or
            (num? X)
            (nil? X)
            (t? X)
            (and (pair X) (num? (car X))) )
         X
         (cons $Quote X) ) ) )

# (eval 'any ['cnt]) -> any
(de _Eval (Exe)
   (let (X (cdr Exe)  E (save (eval (car X))))
      (when (pair (cdr X))
         (let N (needCnt Exe (eval (car @)))
            (when (setq N (int N))
               (let Bnd (val $Bind)
                  (loop
                     (? (=0 Bnd))
                     (?
                        (and
                           (== $At (val 2 Bnd))
                           (prog
                              (set $At (val Bnd))
                              (=0 (dec 'N)) ) ) )
                     (setq Bnd (val 3 Bnd)) ) ) ) ) )
      (eval E) ) )

# (run 'any ['cnt]) -> any
(de _Run (Exe)
   (let (X (cdr Exe)  E (eval (car X)))
      (cond
         ((num? E) E)
         ((sym? E) (val E))
         (T
            (save E
               (when (pair (cdr X))
                  (let N (needCnt Exe (eval (car @)))
                     (when (setq N (int N))
                        (let Bnd (val $Bind)
                           (loop
                              (? (=0 Bnd))
                              (?
                                 (and
                                    (== $At (val 2 Bnd))
                                    (prog
                                       (set $At (val Bnd))
                                       (=0 (dec 'N)) ) ) )
                              (setq Bnd (val 3 Bnd)) ) ) ) ) )
               (runAt E) ) ) ) ) )

# (def 'sym 'any) -> sym
# (def 'sym 'sym|cnt 'any) -> sym
(de _Def (Exe)
   (let
      (X (cdr Exe)
         Sym (save (needSymb Exe (eval (++ X))))
         Y (save (eval (++ X))) )
      (if (pair X)
         (let Val (save (eval (car X)))
            (when (== Y ZERO)
               (setq Y Val)
               (goto 1) )
            (when (sym? (val (tail Sym)))
               (if (nil? Y)
                  (dbFetch Exe Sym)  # Volatile property
                  (dbTouch Exe Sym) ) )
            (let V (get Sym Y)
               (unless (or (nil? V) (equal V Val))
                  (redefMsg Sym Y) ) )
            (put Sym Y Val)
            (putSrc Sym Y) )
         (: 1
            (chkVar Exe Sym)
            (when (sym? (val (tail Sym)))
               (dbTouch Exe Sym) )
            (let V (val Sym)
               (unless (or (nil? V) (== V Sym) (equal V Y))
                  (redefMsg Sym 0) ) )
            (set Sym Y)
            (putSrc Sym 0) ) )
      Sym ) )

# (de sym . any) -> sym
(de _De (Exe)
   (let S (cadr Exe)
      (redefine Exe S (cddr Exe))
      S ) )

# (dm sym . fun|cls2) -> sym
# (dm (sym . cls) . fun|cls2) -> sym
# (dm (sym sym2 [. cls]) . fun|cls2) -> sym
(de _Dm (Exe)
   (let
      (X (cdr Exe)
         Y (car X)
         Fun (cdr X)
         Msg (if (atom Y) Y (car Y))
         Cls
         (cond
            ((atom Y) (val $Class))
            ((atom (cdr Y)) @)
            (T
               (let Z @
                  (get
                     (if (nil? (cdr Z)) (val $Class) @)
                     (needSymb Exe (car Z)) ) ) ) ) )
      (chkVar Exe Cls)
      (unless (t? Msg)
         (redefine Exe Msg (val $Meth)) )
      (when (symb? Fun)
         (let L (val Fun)
            (loop
               (when (or (atom L) (atom (car L)))
                  (err Exe Msg ($ "Bad message") null) )
               (? (== Msg (caar L))  # Found in 'cls2'
                  (setq
                     X (car L)
                     Fun (cdr X) ) )
               (shift L) ) ) )
      (let (V (val Cls)  L V)
         (loop
            (? (or (atom L) (atom (car L)))  # New method
               (set Cls
                  (cons
                     (if (atom (car X))
                        X
                        (cons Msg Fun) )
                     V ) ) )
            (? (== Msg (caar L))  # Redefine method
               (let Z (car L)
                  (unless (equal Fun (cdr Z))
                     (redefMsg Msg Cls) )
                  (set 2 Z Fun) ) )
            (shift L) ) )
      (putSrc Cls Msg)
      Msg ) )

# Apply METH to CDR of list
(local) (evMethod method)

(de evMethod (Obj Typ Key Exe X)
   (let
      (Y (car Exe)  # Parameters
         P (set $Bind (push (val $At) $At (val $Bind) Exe)) )  # [[@] @ LINK Expr]
      (set $Bind (setq P (push Obj $This P)))
      (while (pair Y)
         (let (V (eval (++ X))  Z (++ Y))  # Evaluate next argument
            (if (atom Z)
               (set $Bind
                  (setq P (push V (needChkVar Exe Z) P)) )  # [val sym LINK]
               (loop
                  (set $Bind
                     (setq P
                        (push  # [val sym LINK]
                           (if (pair V) (++ V) $Nil)
                           (needChkVar Exe (++ Z))
                           P ) ) )
                  (? (atom Z)) )
               (unless (nil? Z)
                  (set $Bind
                     (setq P (push V (needChkVar Exe Z) P)) ) ) ) ) )  # [val sym LINK]
      (prog1
         (if (== Y $At)  # VarArgs
            (if (pair X)
               (let (L (push NIL (eval (car X)) NIL)  Q L)
                  (link (ofs L 1))
                  (while (pair (shift X))
                     (setq L
                        (set L (push NIL (eval (car X)) NIL)) )
                     (link (ofs L 1)) )
                  (let Next (val $Next)
                     (set L $Nil  $Next Q)
                     (loop
                        (let Sym (val 2 P)
                           (xchg Sym P)  # Exchange symbol value
                           (? (== $At Sym))
                           (setq P (val 3 P)) ) )
                     (let (TypS (val $Typ)  KeyS (val $Key))
                        (prog2
                           (set $Typ Typ  $Key Key)
                           (run (cdr Exe))  # Run body
                           (set $Key KeyS  $Typ TypS  $Next Next)
                           (drop (ofs Q 1)) ) ) ) )
               (let Next (val $Next)
                  (set $Next $Nil)
                  (loop
                     (let Sym (val 2 P)
                        (xchg Sym P)  # Exchange symbol value
                        (? (== $At Sym))
                        (setq P (val 3 P)) ) )
                  (let (TypS (val $Typ)  KeyS (val $Key))
                     (prog2
                        (set $Typ Typ  $Key Key)
                        (run (cdr Exe))  # Run body
                        (set $Key KeyS  $Typ TypS  $Next Next) ) ) ) )
            (unless (nil? Y)
               (needChkVar Exe Y)
               (set
                  $Bind (push (val Y) Y P)  # Last parameter
                  Y X ) )  # Set to unevaluated argument(s)
            (loop
               (let Sym (val 2 P)
                  (xchg Sym P)  # Exchange symbol value
                  (? (== $At Sym))
                  (setq P (val 3 P)) ) )
            (let (TypS (val $Typ)  KeyS (val $Key))
               (prog2
                  (set $Typ Typ  $Key Key)
                  (run (cdr Exe))  # Run body
                  (set $Key KeyS  $Typ TypS) ) ) )
         (setq P (val $Bind))
         (loop
            (let Sym (val 2 P)
               (set Sym (val P))  # Restore values
               (? (== $At Sym))
               (setq P (val 3 P)) ) )
         (set $Bind (val 3 P)) ) ) )

(de method (Obj Key)
   (when (pair (val Obj))  # Class definition (methods and superclasses)
      (let L @
         (while (pair (car L))  # Method definition
            (let Y @
               (when (== Key (car Y))  # Found
                  (ret (cdr Y)) ) )
            (when (atom (shift L))
               (ret 0) ) )
         (stkChk 0)
         (loop
            (when (method (car (set $Ret L)) Key)  # Set class list
               (ret @) )
            (? (atom (shift L))) ) ) )
   0 )

# (meth 'obj ['any ..]) -> any
(de __Meth (Exe Key)
   (let (X (cdr Exe)  Obj (save (eval (car X))))
      (when (sym? (val (tail (needSymb Exe Obj))))
         (dbFetch Exe Obj) )
      (set $Ret 0)  # Preset to "No classes"
      (if (method Obj Key)
         (evMethod Obj (val $Ret) Key @ (cdr X))
         (err Exe Key ($ "Bad message") null) ) ) )

# (box 'any) -> sym
(de _Box (Exe)
   (consSym ZERO (eval (cadr Exe))) )

# (new ['flg|num|sym] ['typ ['any ..]]) -> obj
(de _New (Exe)
   (let
      (X (cdr Exe)
         Y (eval (++ X))
         Obj
         (save
            (cond
               ((pair Y) (consSym ZERO Y))  # Anonymous with type
               ((nil? Y) (consSym ZERO ZERO))  # Anonymous with placeholder
               ((or (t? Y) (num? Y))
                  (let Nm
                     (newId Exe  # External
                        (if (num? Y) (i32 (int @)) 1) )
                     (prog1
                        (extern Nm)
                        (set (tail @)
                           (sign (shr 1 (add Nm Nm) 1)) ) ) ) )  # Set "dirty"
               (T Y) ) ) )  # Explicit symbol
      (unless (pair Y)
         (set Obj (eval (++ X))) )
      (set $Ret 0)  # Preset to "No classes"
      (cond
         ((method Obj $T)
            (evMethod Obj (val $Ret) $T @ X) )
         ((pair X)
            (let K (link (push NIL NIL))
               (loop
                  (when (== ZERO (set K (eval (++ X))))
                     (argErr Exe ZERO) )
                  (put Obj (val K) (eval (++ X)))
                  (? (atom X)) ) ) ) )
      Obj ) )

# (type 'any) -> lst
(de _Type (Exe)
   (let (X (cdr Exe)  Y (eval (car X)))
      (ifn (symb? Y)
         $Nil
         (when (sym? (val (tail Y)))
            (dbFetch Exe Y) )
         (let (V (val Y)  Z V)
            (loop
               (? (atom V) $Nil)
               (? (atom (car V))  # Class
                  (let R V
                     (loop
                        (? (not (symb? (car V))) $Nil)
                        (? (atom (shift V))
                           (if (nil? V) R $Nil) )
                        (? (== Z V) $Nil) ) ) )
               (? (== Z (shift V)) $Nil) ) ) ) ) )

(local) isa

(de i1 isa (Cls Obj)
   (let (V (val Obj)  Z V)
      (loop
         (? (atom V) NO)
         (? (atom (car V))  # Class
            (stkChk 0)
            (loop
               (? (not (symb? (car V))) NO)
               (? (== @ Cls) YES)
               (? (isa Cls @) YES)
               (? (atom (shift V)) NO)
               (? (== Z V) NO) ) )
         (? (== Z (shift V)) NO) ) ) )

# (isa 'cls|typ 'any) -> obj | NIL
(de _Isa (Exe)
   (let
      (X (cdr Exe)
         Y (save (eval (++ X)))
         Z (eval (car X)) )
      (ifn (symb? Z)
         $Nil
         (when (sym? (val (tail Z)))
            (dbFetch Exe Z) )
         (cond
            ((pair Y)
               (loop
                  (? (not (isa (car Y) Z)) $Nil)
                  (? (atom (shift Y)) Z) ) )
            ((isa Y Z) Z)
            (T $Nil) ) ) ) )

# (method 'msg 'obj) -> fun
(de _Method (Exe)
   (let
      (X (cdr Exe)
         Msg (save (eval (++ X)))
         Obj (needSymb Exe (eval (car X))) )
      (when (sym? (val (tail Obj)))
         (dbFetch Exe Obj) )
      (if (method Obj Msg) @ $Nil) ) )

# (send 'msg 'obj ['any ..]) -> any
(de _Send (Exe)
   (let
      (X (cdr Exe)
         Msg (save (eval (++ X)))
         Obj (save (needSymb Exe (eval (car X)))) )
      (when (sym? (val (tail Obj)))
         (dbFetch Exe Obj) )
      (set $Ret 0)  # Preset to "No classes"
      (if (method Obj Msg)
         (evMethod Obj (val $Ret) Msg @ (cdr X))
         (err Exe Msg ($ "Bad message") null) ) ) )

# (try 'msg 'obj ['any ..]) -> any
(de _Try (Exe)
   (let
      (X (cdr Exe)
         Msg (save (eval (++ X)))
         Obj (save (eval (car X))) )
      (ifn (symb? Obj)
         $Nil
         (when (sym? (val (tail Obj)))
            (unless (isLife Obj)
               (goto 1) )
            (dbFetch Exe Obj) )
         (set $Ret 0)  # Preset to "No classes"
         (if (method Obj Msg)
            (evMethod Obj (val $Ret) Msg @ (cdr X))
            (: 1 $Nil) ) ) ) )

# (super ['any ..]) -> any
(de _Super (Exe)
   (let
      (Lst (val (if (val $Typ) (car @) (val $This)))
         Key (val $Key) )
      (while (pair (car Lst))  # Skip methods
         (shift Lst) )
      (loop
         (when (atom Lst)  # No classes
            (err Exe Key ($ "Bad super") null) )
         (? (method (car (set $Ret Lst)) Key)  # Found
            (let (TypS (val $Typ)  KeyS (val $Key))
               (set $Typ (val $Ret)  $Key Key)  # Set class and key
               (prog1
                  (evExpr @ Exe)  # Evaluate expression
                  (set $Key KeyS  $Typ TypS) ) ) )  # Restore class and key
         (shift Lst) ) ) )

(local) extra

(de extra (Obj Key)
   (let Lst (val Obj)
      (while (pair (car Lst))  # Skip methods
         (shift Lst) )
      (loop  # Classes
         (? (atom Lst) 1)  # Not found on this level
         (? (== Lst (val $Typ))  # Hit current class list
            (loop  # Locate method in extra classes
               (? (atom (shift Lst)) 0)  # Try further
               (? (method (car (set $Ret Lst)) Key) @) ) )  # Found in superclass
         (stkChk 0)
         (? (> (extra (car Lst) Key) 1) @)  # Found on this level
         (? (=0 @)
            (loop
               (? (atom (shift Lst)) 0)
               (? (method (car (set $Ret Lst)) Key) @) ) )  # Found in superclass
         (shift Lst) ) ) )  # Try next in class list

# (extra ['any ..]) -> any
(de _Extra (Exe)
   (let Key (val $Key)
      (unless (> (extra (val $This) Key) 1)
         (err Exe Key ($ "Bad extra") null) )
      (let (TypS (val $Typ)  KeyS (val $Key))
         (set $Typ (val $Ret)  $Key Key)  # Set class and key
         (prog1
            (evExpr @ Exe)  # Evaluate expression
            (set $Key KeyS  $Typ TypS) ) ) ) )  # Restore class and key

# (and 'any ..) -> any
(de _And (Exe)
   (let X (cdr Exe)
      (loop
         (let Y (eval (car X))
            (? (nil? Y) Y)
            (set $At Y)
            (? (atom (shift X)) Y) ) ) ) )

# (or 'any ..) -> any
(de _Or (Exe)
   (let X (cdr Exe)
      (loop
         (let Y (eval (car X))
            (? (not (nil? Y))
               (set $At Y) )
            (? (atom (shift X)) Y) ) ) ) )

# (nand 'any ..) -> flg
(de _Nand (Exe)
   (let X (cdr Exe)
      (loop
         (let Y (eval (car X))
            (? (nil? Y) $T)
            (set $At Y)
            (? (atom (shift X)) $Nil) ) ) ) )

# (nor 'any ..) -> flg
(de _Nor (Exe)
   (let X (cdr Exe)
      (loop
         (let Y (eval (car X))
            (? (not (nil? Y))
               (set $At Y)
               $Nil )
            (? (atom (shift X)) $T) ) ) ) )

# (xor 'any 'any) -> flg
(de _Xor (Exe)
   (let X (cdr Exe)
      (if (nil? (eval (++ X)))
         (if (nil? (eval (car X))) @ $T)
         (if (nil? (eval (car X))) $T $Nil) ) ) )

# (bool 'any) -> flg
(de _Bool (Exe)
   (if (nil? (eval (cadr Exe))) @ $T) )

# (not 'any) -> flg
(de _Not (Exe)
   (if (nil? (eval (cadr Exe)))
      $T
      (set $At @)
      $Nil ) )

# (nil . prg) -> NIL
(de _Nil (Exe)
   (exec (cdr Exe))
   $Nil )

# (t . prg) -> T
(de _T (Exe)
   (exec (cdr Exe))
   $T )

# (prog . prg) -> any
(de _Prog (Exe)
   (run (cdr Exe)) )

# (prog1 'any1 . prg) -> any1
(de _Prog1 (Exe)
   (let X (cdr Exe)
      (prog1
         (set $At (save (eval (++ X))))
         (exec X) ) ) )

# (prog2 'any1 'any2 . prg) -> any2
(de _Prog2 (Exe)
   (let X (cdr Exe)
      (prog2
         (eval (++ X))
         (set $At (save (eval (++ X))))
         (exec X) ) ) )

# (if 'any1 any2 . prg) -> any
(de _If (Exe)
   (let X (cdr Exe)
      (if (nil? (eval (++ X)))
         (run (cdr X))
         (set $At @)
         (eval (car X)) ) ) )

# (ifn 'any1 any2 . prg) -> any
(de _Ifn (Exe)
   (let X (cdr Exe)
      (if (nil? (eval (++ X)))
         (eval (car X))
         (set $At @)
         (run (cdr X)) ) ) )

# (if2 'any1 'any2 any3 any4 any5 . prg) -> any
(de _If2 (Exe)
   (let X (cdr Exe)
      (if (nil? (eval (++ X)))
         (if (nil? (eval (++ X)))
            (run (cdr (cddr X)))
            (set $At @)
            (eval (car (cddr X))) )
         (set $At @)
         (if (nil? (eval (++ X)))
            (eval (cadr X))
            (set $At @)
            (eval (car X)) ) ) ) )

# (if@@ 'any1 any2 . prg) -> any
(de _IfAt2 (Exe)
   (let X (cdr Exe)
      (set $At (eval (++ X)))
      (if (nil? (val $At2))
         (run (cdr X))
         (eval (car X)) ) ) )

# (when 'any . prg) -> any
(de _When (Exe)
   (let X (cdr Exe)
      (if (nil? (eval (++ X)))
         @
         (set $At @)
         (run X) ) ) )

# (unless 'any . prg) -> any
(de _Unless (Exe)
   (let X (cdr Exe)
      (if (nil? (eval (++ X)))
         (run X)
         (set $At @)
         $Nil ) ) )

# (cond ('any1 . prg1) ('any2 . prg2) ..) -> any
(de _Cond (Exe)
   (let X Exe
      (loop
         (? (atom (shift X)) $Nil)
         (let Y (car X)
            (? (not (nil? (eval (car Y))))
               (set $At @)
               (run (cdr Y)) ) ) ) ) )

# (nond ('any1 . prg1) ('any2 . prg2) ..) -> any
(de _Nond (Exe)
   (let X Exe
      (loop
         (? (atom (shift X)) $Nil)
         (let Y (car X)
            (? (nil? (eval (car Y)))
               (run (cdr Y)) ) )
         (set $At @) ) ) )

# (case 'any (any1 . prg1) (any2 . prg2) ..) -> any
(de _Case (Exe)
   (let (X (cdr Exe)  A (set $At (eval (car X))))
      (loop
         (? (atom (shift X)) $Nil)
         (let (Y (car X)  Z (car Y))
            (?
               (or
                  (t? Z)
                  (if (atom Z) (equal Z A) (member A Z)) )
               (run (cdr Y)) ) ) ) ) )

# (casq 'any (any1 . prg1) (any2 . prg2) ..) -> any
(de _Casq (Exe)
   (let (X (cdr Exe)  A (set $At (eval (car X))))
      (loop
         (? (atom (shift X)) $Nil)
         (let (Y (car X)  Z (car Y))
            (? (or (t? Z) (== Z A) (memq A Z))
               (run (cdr Y)) ) ) ) ) )

# (state 'var (sym|lst exe [. prg]) ..) -> any
(de _State (Exe)
   (let
      (X (cdr Exe)
         Var (save (needChkVar Exe (eval (car X)))) )
      (loop
         (? (atom (shift X)) $Nil)
         (let (Y (car X)  Z (car Y))
            (when
               (or
                  (t? Z)
                  (let V (val Var)
                     (or (== Z V) (memq V Z)) ) )
               (? (not (nil? (eval (car (shift Y)))))
                  (set Var (set $At @))
                  (run (cdr Y)) ) ) ) ) ) )

# (while 'any . prg) -> any
(de _While (Exe)
   (let (X (cdr Exe)  E (++ X)  R (save $Nil))
      (until (nil? (eval E))
         (set $At @)
         (setq R (safe (run X))) )
      R ) )

# (until 'any . prg) -> any
(de _Until (Exe)
   (let (X (cdr Exe)  E (++ X)  R (save $Nil))
      (while (nil? (eval E))
         (setq R (safe (run X))) )
      (set $At @)
      R ) )

# (at '(cnt1 . cnt2|NIL) . prg) -> any
(de _At (Exe)
   (let
      (X (cdr Exe)
         Y (needPair Exe (eval (car X)))
         Z (cdr Y) )
      (cond
         ((nil? Z) @)
         ((< (+ (car Y) (hex "10")) Z)  # Increment
            (set Y @)
            $Nil )
         (T
            (set Y ZERO)
            (run (cdr X)) ) ) ) )

(local) (loop1 loop2)

(de loop1 (X)
   (loop
      (let E (car X)
         (unless (num? E)
            (setq E
               (cond
                  ((sym? E) (val E))
                  ((nil? (car E))
                     (? (nil? (eval (car (shift E))))
                        (run (cdr E)) )
                     (set $At @)
                     $Nil )
                  ((t? (car E))
                     (? (not (nil? (eval (car (shift E)))))
                        (set $At @)
                        (run (cdr E)) )
                     @ )  # NIL
                  (T (evList E)) ) ) )
         (? (atom (shift X)) (| E 1)) ) ) )

(de loop2 (Y)
   (loop
      (let X Y
         (loop
            (let E (car X)
               (when (pair E)
                  (cond
                     ((nil? (car E))
                        (when (nil? (eval (car (shift E))))
                           (ret (run (cdr E))) )
                        (set $At @) )
                     ((t? (car E))
                        (unless (nil? (eval (car (shift E))))
                           (set $At @)
                           (ret (run (cdr E))) ) )
                     (T (evList E)) ) ) )
            (? (atom (shift X))) ) ) ) )

# (do 'flg|cnt ['any | (NIL 'any . prg) | (T 'any . prg) ..]) -> any
(de _Do (Exe)
   (let (X (cdr Exe)  Y (eval (++ X)))
      (cond
         ((nil? Y) Y)
         ((cnt? Y)
            (let N (int Y)
               (if (or (sign? Y) (=0 N))
                  $Nil
                  (loop
                     (let R (loop1 X)
                        (? (=0 (& R 1)) R)
                        (? (=0 (dec 'N)) (& R -2)) ) ) ) ) )
         (T (loop2 X)) ) ) )  # Non-NIL 'flg'

# (loop ['any | (NIL 'any . prg) | (T 'any . prg) ..]) -> any
(de _Loop (Exe)
   (tailcall (loop2 (cdr Exe))) )

# (for sym 'cnt ['any | (NIL 'any . prg) | (T 'any . prg) ..]) -> any
# (for sym|(sym2 . sym) 'lst ['any | (NIL 'any . prg) | (T 'any . prg) ..]) -> any
# (for (sym|(sym2 . sym) 'any1 'any2 [. prg]) ['any | (NIL 'any . prg) | (T 'any . prg) ..]) -> any
(de _For (Exe)
   (let
      (X (cdr Exe)
         Y (++ X)
         R $Nil )
      (cond
         ((atom Y)  # (for sym 'cnt|lst ..)
            (needChkVar Exe Y)
            (let P (set $Bind (push NIL NIL (val $Bind)))  # [[sym] sym LINK]
               (set P (val Y)  2 P Y)
               (let V (eval (++ X))
                  (if (num? V)  # (for sym 'cnt ..)
                     (unless (sign? V)
                        (set Y ZERO)
                        (loop
                           (? (> (+ (val Y) (hex "10")) V)  # Increment
                              (setq R (& R -2)) )
                           (set Y @)
                           (? (=0 (& (setq R (loop1 X)) 1))) ) )
                     (save V
                        (loop  # (for sym 'lst ..)
                           (? (atom V) (setq R (& R -2)))
                           (set Y (car V))
                           (? (=0 (& (setq R (loop1 X)) 1)))
                           (shift V) ) ) ) )
               (set Y (val P)  $Bind (val 3 P)) ) )
         ((atom (cdr Y))  # (for (sym2 . sym) 'lst ..)
            (let Sym2 (needChkVar Exe @)
               (needChkVar Exe (setq Y (car Y)))
               (let P (set $Bind (push NIL NIL (val $Bind)))  # [[sym] sym LINK]
                  (set P (val Y)  2 P Y)
                  (let
                     (Q (set $Bind (push (val Sym2) Sym2 (val $Bind)))  # [[sym] sym LINK]
                        V (save (eval (++ X))) )
                     (set Y ONE)
                     (loop
                        (? (atom V) (setq R (& R -2)))
                        (set Sym2 (car V))
                        (? (=0 (& (setq R (loop1 X)) 1)))
                        (set Y (+ (val Y) (hex "10")))
                        (shift V) )
                     (set Sym2 (val Q)) )
                  (set Y (val P)  $Bind (val 3 P)) ) ) )
         ((atom (car Y))  # (for (sym ..) ..)
            (let Z (cdr Y)
               (needChkVar Exe (setq Y @))
               (let P (set $Bind (push NIL NIL (val $Bind)))  # [[sym] sym LINK]
                  (set
                     P (val Y)
                     2 P Y
                     Y (eval (++ Z)) )
                  (save R
                     (loop  # (any2 . prg)
                        (? (nil? (eval (car Z))))
                        (set $At @)
                        (? (=0 (& (setq R (loop1 X)) 1)))
                        (safe (setq R (& R -2)))
                        (when (pair (cdr Z))
                           (set Y (run @)) ) ) )
                  (set Y (val P)  $Bind (val 3 P)) ) ) )
         (T  # (for ((sym2 . sym) ..) ..)
            (let (Sym2 (cdr @)  Z (cdr Y))
               (setq Y (car @))
               (needChkVar Exe Y)
               (needChkVar Exe Sym2)
               (let P (set $Bind (push NIL NIL (val $Bind)))  # [[sym] sym LINK]
                  (set P (val Y)  2 P Y)
                  (save R
                     (let Q (set $Bind (push (val Sym2) Sym2 (val $Bind)))  # [[sym] sym LINK]
                        (set
                           Sym2 (save (eval (++ Z)))
                           Y ONE )
                        (loop
                           (? (nil? (eval (car Z))))
                           (set $At @)
                           (? (=0 (& (setq R (loop1 X)) 1)))
                           (safe (setq R (& R -2)))
                           (when (pair (cdr Z))
                              (set Sym2 (run @)) )
                           (set Y (+ (val Y) (hex "10"))) )
                        (set Sym2 (val Q)) ) )
                  (set Y (val P)  $Bind (val 3 P)) ) ) ) )
      R ) )

# (with 'var . prg) -> any
(de _With (Exe)
   (let (X (cdr Exe)  Y (needVar Exe (eval (++ X))))
      (if (nil? Y)
         Y
         (let P (set $Bind (push (val $This) $This (val $Bind)))  # [[This] This LINK]
            (set $This Y)
            (prog1
               (run X)
               (set $This (val P)  $Bind (val 3 P)) ) ) ) ) )

# (bind 'sym|lst . prg) -> any
(de _Bind (Exe)
   (let (X (cdr Exe)  Y (eval (++ X)))
      (cond
         ((num? Y) (argErr Exe Y))
         ((nil? Y) (run X))
         ((sym? Y)  # Single symbol
            (chkVar Exe Y)
            (let P (set $Bind (push (val Y) Y (val $Bind)))  # [[sym] sym LINK]
               (prog1
                  (run X)
                  (set Y (val P)  $Bind (val 3 P)) ) ) )
         (T
            (let (P (val $Bind)  Q P)
               (loop
                  (let Z (++ Y)
                     (when (num? Z)
                        (argErr Exe Y) )
                     (if (sym? Z)
                        (set $Bind
                           (setq P (push (val Z) (chkVar Exe Z) P)) )
                        (let S (car Z)
                           (needChkVar Exe S)
                           (set
                              $Bind (setq P (push (val S) S P))
                              S (cdr Z) ) ) ) )
                  (? (atom Y)) )
               (prog1
                  (run X)
                  (loop
                     (set (val 2 P) (val P))  # Restore values
                     (? (== Q (setq P (val 3 P)) ) ) )
                  (set $Bind P) ) ) ) ) ) )

# (job 'lst . prg) -> any
(de _Job (Exe)
   (let
      (X (cdr Exe)
         Y (save (eval (++ X)))
         P (val $Bind)
         Q P )
      (while (pair Y)
         (let (Z (++ Y)  S (car Z))
            (needChkVar Exe S)
            (set
               $Bind (setq P (push (val S) S P Z))  # [[sym] sym LINK (sym . val)]
               S (cdr Z) ) ) )
      (prog1
         (run X)
         (until (== Q P)
            (let S (val 2 P)
               (set 2 (val 4 P) (val S))
               (set S (val P)) )  # Restore values
            (setq P (val 3 P)) )
         (set $Bind P) ) ) )

(local) setDestruct

(de void setDestruct (Pat Val)
   (loop
      (when (atom Val)  # Default non-list to NIL
         (setq Val $Nil) )
      (let (P (++ Pat)  V (++ Val))
         (if (atom P)
            (unless (nil? P)
               (set P V) )
            (setDestruct P V) ) )
      (? (atom Pat)
         (unless (nil? Pat)
            (set Pat Val) ) ) ) )

# (let sym 'any . prg) -> any
# (let (sym|lst 'any ..) . prg) -> any
(de _Let (Exe)
   (let (X (cdr Exe)  Y (++ X))
      (if (atom Y)
         (let P
            (set $Bind
               (push (val (needChkVar Exe Y)) Y (val $Bind)) )  # [[sym] sym LINK]
            (set Y (eval (++ X)))
            (prog1
               (run X)
               (set Y (val P)  $Bind (val 3 P)) ) )
         (let (P (val $Bind)  Q P)
            (loop
               (let Z (++ Y)
                  (if (atom Z)  # Single symbol
                     (set
                        $Bind (setq P (push (val (needChkVar Exe Z)) Z P))
                        Z (eval (car Y)) )
                     (let Tos 0  # List structure
                        (loop
                           (until (atom (car Z))
                              (let U Z  # Go left
                                 (setq Z @)  # Invert tree
                                 (set U Tos)
                                 (setq Tos U) ) )
                           (unless (nil? (car Z))  # Skip NIL
                              (let S (needChkVar Exe @)
                                 (set $Bind (setq P (push (val S) S P))) ) )
                           (loop
                              (? (pair (cdr Z))  # Right subtree
                                 (let U Z  # Go right
                                    (setq Z @)  # Invert tree
                                    (set 2 U Tos)
                                    (setq Tos (| U 8)) ) )
                              (unless (nil? @)  # Dotted structure symbol
                                 (let S (needChkVar Exe @)
                                    (set $Bind (setq P (push (val S) S P))) ) )
                              (loop
                                 (unless Tos
                                    (goto 1) )
                                 (? (=0 (& Tos 8))  # Second visit
                                    (let U Tos
                                       (setq Tos (car U))  # TOS on up link
                                       (set U Z)
                                       (setq Z U) ) )
                                 (let U (& Tos -9)  # Set second visit
                                    (setq Tos (cdr U))
                                    (set 2 U Z)
                                    (setq Z U) ) ) ) ) )
                     (: 1
                        (setDestruct Z (eval (car Y))) ) ) )
               (? (atom (shift Y))) )
            (prog1
               (run X)
               (loop
                  (set (val 2 P) (val P))  # Restore values
                  (? (== Q (setq P (val 3 P)) ) ) )
               (set $Bind P) ) ) ) ) )

# (let? sym 'any . prg) -> any
(de _LetQ (Exe)
   (let (X (cdr Exe)  Y (needChkVar Exe (++ X)))
      (if (nil? (eval (car X)))
         @
         (let P (set $Bind (push (val Y) Y (val $Bind)))  # [[sym] sym LINK]
            (set Y @)
            (prog1
               (run (cdr X))
               (set Y (val P)  $Bind (val 3 P)) ) ) ) ) )

# (use sym . prg) -> any
# (use (sym ..) . prg) -> any
(de _Use (Exe)
   (let (X (cdr Exe)  Y (++ X))
      (if (atom Y)
         (let P (set $Bind (push (val Y) Y (val $Bind)))  # [[sym] sym LINK]
            (prog1
               (run X)
               (set Y (val P)  $Bind (val 3 P)) ) )
         (let (P (val $Bind)  Q P)
            (loop
               (let Z (car Y)
                  (set $Bind (setq P (push (val Z) Z P))) )
               (? (atom (shift Y))) )
            (prog1
               (run X)
               (loop
                  (set (val 2 P) (val P))  # Restore values
                  (? (== Q (setq P (val 3 P)) ) ) )
               (set $Bind P) ) ) ) ) )

# (buf sym 'cnt . prg) -> any
(de _Buf (Exe)
   (let
      (X (cdr Exe)
         Y (needChkVar Exe (++ X))
         Z (needCnt Exe (eval (++ X)))
         P (set $Bind (push (val Y) Y (val $Bind))) )  # [[sym] sym LINK]
      (set Y (box64 (i64 (b8+ (int Z)))))
      (stkChk Exe)
      (prog1
         (run X)
         (set Y (val P)  $Bind (val 3 P)) ) ) )

# (tco lst . prg) -> any
(de _Tco (Exe)
   (let
      (X (cdr Exe)
         Y (car X)
         Z (val $Link)
         Par (val $TcoPar)
         Lnk (val $TcoLnk) )
      (set $TcoPar Y)
      (while (pair Y)
         (set $Link (push $Nil (val $Link)))
         (shift Y) )
      (set $TcoLnk (val $Link))
      (loop
         (setq Y (car X))
         (let V (run (cdr X))
            (? (not (prog1 (val $Tc) (set $Tc NO)))
               (set $TcoLnk Lnk  $TcoPar Par  $Link Z)
               V ) )
         (let L (val $Link)
            (while (pair Y)
               (set (++ Y) (++ L)) ) ) ) ) )

# (tc ['any ..])
(de _Tc (Exe)
   (let (X Exe  P (val $TcoPar)  L (val $TcoLnk))
      (set $Tc YES)
      (while (pair P)
         (set L (eval (car (shift X))))
         (shift L)
         (shift P) ) )
   $Nil )

# (catch 'any . prg) -> any
(de _Catch (Exe)
   (let
      (X (cdr Exe)
         Ca: (caFrame (b8+ (+ (val JmpBufSize) (caFrame T)))) )
      (stkChk Exe)
      (Ca: tag (eval (++ X)))
      (Ca: link (val $Catch))
      (set $Catch (Ca:))
      (Ca: fin ZERO)
      (Ca: co (val $Current))
      (putCaEnv (Ca:))
      (prog1
         (ifn (setjmp (Ca: (rst)))
            (prog1 (run X) (set $At2 $Nil))
            (set $At2 $T)
            (val $Ret) )
         (set $Catch (Ca: link)) ) ) )

# (throw 'sym 'any)
(de _Throw (Exe)
   (let
      (X (cdr Exe)
         Tag (save (eval (++ X)))
         R (save (eval (car X))) )
      (let Ca (val $Catch)
         (while Ca
            (let Ca: (caFrame Ca)
               (when (or (t? (Ca: tag)) (== Tag (Ca: tag)))
                  (unwind Ca)
                  (set $Ret R)
                  (longjmp (Ca: (rst)) 1) )
               (setq Ca (Ca: link)) ) ) )
      (err Exe Tag ($ "Tag not found") null) ) )

# (finally exe . prg) -> any
(de _Finally (Exe)
   (let
      (X (cdr Exe)
         Ca: (caFrame (b8+ (+ (val JmpBufSize) (caFrame T)))) )
      (stkChk Exe)
      (Ca: tag 0)
      (Ca: link (val $Catch))
      (set $Catch (Ca:))
      (Ca: fin (++ X))
      (Ca: co (val $Current))
      (putCaEnv (Ca:))
      (prog1
         (save (run X))
         (eval (Ca: fin))
         (set $Catch (Ca: link)) ) ) )

# Coroutines
(local) (coErr reentErr tagErr stkOverErr saveCoIO saveCoEnv loadCoEnv runCo)

(de NIL coErr (Exe Tag)
   (err Exe Tag ($ "Coroutine not found") null) )

(de NIL reentErr (Exe Tag)
   (err Exe Tag ($ "Reentrant coroutine") null) )

(de NIL tagErr (Exe)
   (err Exe 0 ($ "Tag expected") null) )

(de NIL stkOverErr (Tag)
   (set $StkLimit null)
   (err 0 Tag ($ "Stack overwritten") null) )

# Switch coroutines
(de void saveCoIO ()
   ((ioFrame (val $OutFrames)) fun (val (i8** $Put)))
   (let Io: (ioFrame (val $InFrames))
      (Io: fun (val (i8** $Get)))
      (if (Io: file)
         ((inFile @) chr (val $Chr))
         ((ioxFrame (Io:)) chr (val $Chr)) ) ) )

(de void saveCoEnv ((i8* . Crt))
   (let Crt: (coroutine Crt)
      (unless (== (hex "0707070707070707") (val (i64* (Crt: lim))))
         (stkOverErr (Crt: tag)) )
      (Crt: at (val $At))  # Not running
      (putCrtEnv (Crt:)) ) )

(de loadCoEnv ((i8* . Crt))
   (let Crt: (coroutine (set $Current Crt))
      (memcpy (env) (Crt: (env)) (env T) T)
      (set $StkLimit (+ (Crt: lim) 1024))
      (getCrtEnv (Crt:))
      (set $At (Crt: at))
      (Crt: at 0)  # Running
      (val $Ret) ) )

(de NIL runCo (Exe Tag (i8* . Src) (i8* . Dst) X)
   (let (Src: (coroutine Src)  Dst: (coroutine Dst))
      (Dst: tag Tag)
      (Dst: org (Src:))
      (Dst: otg (Src: tag))
      (Dst: prg X)
      (let (Siz (val $StkSize)  Stk (stack))
         (memset
            (Dst: lim (stack (ofs Dst (- Siz))))
            7 (- Siz 256) T )
         (stack Stk) )
      (Dst: at 0)
      (Dst: lnk (val $Link))
      (set $Bind
         (push (val $This) $This  # [[This] This LINK]
            (Dst: bnd (push ZERO $At (val $Bind) Exe)) ) )  # [0 @ LINK Expr]
      (Dst: ca (val $Catch))
      (Dst: in (val $InFrames))
      (Dst: out (val $OutFrames))
      (Dst: err (val $ErrFrames))
      (Dst: ctl (val $CtlFrames))
      (putCrtEnv (Dst:))
      (set  # Init local env
         $Next $Nil
         $Make 0
         $Yoke 0
         $Current (Dst:)
         $StkLimit (+ (Dst: lim) 1024) )
      (when (symb? Tag)
         (put Tag ZERO (| (i64 (Dst:)) 2)) )
      (set $Ret (run X))
      (unless (== (hex "0707070707070707") (val (i64* (Dst: lim))))
         (stkOverErr (Dst: tag)) )
      (set $This (val -3 (Dst: bnd)))
      (stop (Dst:))  # Stop coroutine
      (let Org: (coroutine (Dst: org))
         (unless (and (Org:) (== (Org: tag) (Dst: otg)))
            (coErr Exe (Dst: otg)) )
         (longjmp (Org: (rst)) 1) ) ) )

# (co ['any [. prg]]) -> any
(de _Co (Exe)
   (let X (cdr Exe)
      (if (atom X)
         (if (val $Current)
            ((coroutine @) tag)
            $Nil )
         (let Tag (eval (++ X))
            (let Crt (val $Current)
               (loop
                  (? (=0 Crt))
                  (when (== Tag ((coroutine Crt) tag))  # Found coroutine
                     (reentErr Exe Tag) )
                  (setq Crt ((coroutine Crt) org)) ) )
            (cond
               ((nil? Tag) (tagErr Exe))
               ((t? Tag) (reentErr Exe Tag))
               ((pair X)  # 'prg'
                  (unless (val $Coroutines)  # First call
                     (let Main: (coroutine (alloc null (+ (val JmpBufSize) (coroutine T))))
                        (Main: tag $T)  # Tag 'T'
                        (Main: nxt null)
                        (Main: org null)
                        (Main: otg $Nil)
                        (Main: prg $Nil)
                        (let (Siz (val $StkSizeT)  Stk (stack))
                           (memset
                              (Main: lim (stack (ofs Stk (- Siz))))
                              7 (- Siz 256) T )
                           (stack Stk) )
                        (Main: at 0)
                        (set $Coroutines (set $Current (set $CrtLast (Main:)))) ) )
                  (let (Src: (coroutine (val $Current))  Crt (val $Coroutines))
                     (saveCoIO)
                     (saveCoEnv (Src:))
                     (cond
                        ((not (symb? Tag))
                           (loop
                              (let Crt: (coroutine Crt)
                                 (when (== Tag (Crt: tag))  # Found running coroutine
                                    (when (setjmp (Src: (rst)))
                                       (ret (loadCoEnv (Src:))) )
                                    (set $Ret $Nil)
                                    (Crt: org (Src:))
                                    (Crt: otg (Src: tag))
                                    (longjmp (Crt: (rst)) 1) )
                                 (? (=0 (Crt: nxt)))
                                 (setq Crt @) ) ) )
                        ((cnt? (get Tag ZERO))  # Already running
                           (let Crt: (coroutine (i8* (& @ -3)))
                              (unless (== Tag (Crt: tag))
                                 (coErr Exe Tag) )
                              (when (setjmp (Src: (rst)))
                                 (ret (loadCoEnv (Src:))) )
                              (set $Ret $Nil)
                              (Crt: org (Src:))
                              (Crt: otg (Src: tag))
                              (longjmp (Crt: (rst)) 1) ) ) )
                     # Start new coroutine
                     (when (setjmp (Src: (rst)))
                        (ret (loadCoEnv (Src:))) )
                     (let P (val $CrtFree)
                        (if P
                           (set $CrtFree ((coroutine (stack P)) lim))  # Use free slot
                           (stack ((coroutine (setq Crt (val $CrtLast))) lim))  # Allocate new slot
                           (set $CrtLast
                              (setq P (b8+ (+ (val JmpBufSize) (coroutine T)))) )
                           ((coroutine Crt) nxt P)
                           ((coroutine P) nxt null) )
                        (runCo Exe Tag (Src:) P X) ) ) )
               ((val $Coroutines)  # Stop coroutine
                  (let Crt @
                     (if (symb? Tag)
                        (when (cnt? (get Tag ZERO))
                           (setq Crt (i8* (& @ -3)))
                           (unless (== Tag ((coroutine Crt) tag))
                              (coErr Exe Tag) )
                           (: 1
                              (let P ((coroutine Crt) (env $ErrFrames i8*))  # Close ErrFrames
                                 (while P
                                    (let Err: (ctFrame P)
                                       (when (ge0 (Err: fd))
                                          (close @) )
                                       (setq P (Err: link)) ) ) )
                              (let P ((coroutine Crt) (env $OutFrames i8*))  # Close OutFrames
                                 (until (== P (val $Stdout))
                                    (let Io: (ioFrame P)
                                       (when (Io: file)
                                          (let Out: (outFile @)
                                             (flush (Out:))
                                             (when (and (ge0 (Out: fd)) (Io: pid))
                                                (close (Out: fd))
                                                (closeOutFile (Out: fd))
                                                (when (> (Io: pid) 1)
                                                   (waitFile @) ) ) ) )
                                       (setq P (Io: link)) ) ) )
                              (let P ((coroutine Crt) (env $InFrames i8*))  # Close InFrames
                                 (until (== P (val $Stdin))
                                    (let Io: (ioFrame P)
                                       (when (Io: file)
                                          (let In: (inFile @)
                                             (when (and (ge0 (In: fd)) (Io: pid))
                                                (close (In: fd))
                                                (closeInFile (In: fd))
                                                (when (> (Io: pid) 1)
                                                   (waitFile @) ) ) ) )
                                       (setq P (Io: link)) ) ) )
                              (stop Crt) ) )  # Stop it
                        (loop
                           (when (== Tag ((coroutine Crt) tag))  # Found coroutine
                              (goto 1) )
                           (? (=0 (setq Crt ((coroutine Crt) nxt)))) ) ) )
                  Tag )
               (T $Nil) ) ) ) ) )

# (yield 'any ['any2]) -> any
(de _Yield (Exe)
   (let
      (X (cdr Exe)
         Val (save (eval (++ X)))
         Tag (eval (++ X))
         Crt (val $Coroutines) )
      (unless Crt
         (err Exe 0 ($ "No coroutines") null) )
      (let
         (Src: (coroutine (val $Current))
            Org: (coroutine (Src: org))
            Dst:
            (coroutine
               (cond
                  ((not (nil? Tag))
                     (cond
                        ((t? Tag) (val $Coroutines))
                        ((not (symb? Tag))
                           (loop
                              (let Crt: (coroutine Crt)
                                 (? (== Tag (Crt: tag)) Crt)
                                 (unless (setq Crt (Crt: nxt))
                                    (coErr Exe Tag) ) ) ) )
                        ((cnt? (get Tag ZERO))
                           (prog1
                              (i8* (& @ -3))
                              (unless (== Tag ((coroutine @) tag))
                                 (coErr Exe Tag) ) ) )
                        (T (coErr Exe Tag)) ) )
                  ((Org:)
                     (prog1
                        @
                        (unless (== (Org: tag) (Src: otg))
                           (coErr Exe (Src: otg)) ) ) )
                  (T (tagErr Exe)) ) )
            Lnk (any 0)
            Bnd (any 0)
            Ca (i8* null)
            In (val $Stdin)
            Out (val $Stdout)
            Err (i8* null)
            Ctl (i8* null) )
         (saveCoIO)
         (unless (t? (Src: tag))
            (let P (val $Link)  # Reverse Stack(s)
               (until (== P (Src: lnk))
                  (let Q P
                     (setq P (val 2 Q))
                     (set 2 Q Lnk)
                     (setq Lnk Q) ) )
               (set $Link Lnk) )
            (let P (val $Bind)  # Reverse bindings
               (until (== P (Src: bnd))
                  (let Q P
                     (xchg (val 2 Q) Q)
                     (setq P (val 3 Q))
                     (set 3 Q Bnd)
                     (setq Bnd Q) ) )
               (set 3 P Bnd  $Bind P) )
            (let P (val $Catch)  # Reverse CaFrames
               (until (== P (Src: ca))
                  (let Ca: (caFrame P)
                     (setq P (Ca: link))
                     (Ca: link Ca)
                     (setq Ca (Ca:)) ) )
               (set $Catch Ca) )
            (let P (val $InFrames)  # Reverse InFrames
               (until (== P (Src: in))
                  (let In: (ioFrame P)
                     (setq P (In: link))
                     (In: link In)
                     (setq In (In:)) ) )
               (set $InFrames In) )
            (let P (val $OutFrames)  # Reverse OutFrames
               (until (== P (Src: out))
                  (let Out: (ioFrame P)
                     (setq P (Out: link))
                     (Out: link Out)
                     (setq Out (Out:)) ) )
               (set $OutFrames Out) )
            (let P (val $ErrFrames)  # Reverse ErrFrames
               (until (== P (Src: err))
                  (let Err: (ctFrame P)
                     (setq P (Err: link))
                     (Err: link Err)
                     (setq Err (Err:)) ) )
               (set $ErrFrames Err) )
            (let P (val $CtlFrames)  # Reverse CtlFrames
               (until (== P (Src: ctl))
                  (let Ctl: (ctFrame P)
                     (setq P (Ctl: link))
                     (Ctl: link Ctl)
                     (setq Ctl (Ctl:)) ) )
               (set $CtlFrames Ctl) ) )
         (saveCoEnv (Src:))
         (unless (setjmp (Src: (rst)))
            (set $Ret Val)
            (longjmp (Dst: (rst)) 1) )
         (unless (t? (Src: tag))
            (unless
               (and
                  ((setq Org: (coroutine (Src: org))))
                  (== (Org: tag) (Src: otg)) )
               (loadCoEnv (Src:))  # Originator terminated
               (coErr Exe (Src: otg)) )
            (let P (Org: (env $CtlFrames i8*))  # Restore CtlFrames
               (Src: ctl P)
               (while Ctl
                  (let Ctl: (ctFrame Ctl)
                     (setq Ctl (Ctl: link))
                     (Ctl: link P)
                     (setq P (Ctl:)) ) )
               (Src: (env $CtlFrames i8*) P) )
            (let P (Org: (env $ErrFrames i8*))  # Restore ErrFrames
               (Src: err P)
               (while Err
                  (let Err: (ctFrame Err)
                     (setq Err (Err: link))
                     (Err: link P)
                     (setq P (Err:)) ) )
               (Src: (env $ErrFrames i8*) P) )
            (let P (Org: (env $OutFrames i8*))  # Restore OutFrames
               (Src: out P)
               (until (== Out (val $Stdout))
                  (let Out: (ioFrame Out)
                     (setq Out (Out: link))
                     (Out: link P)
                     (setq P (Out:)) ) )
               (Src: (env $OutFrames i8*) P) )
            (let P (Org: (env $InFrames i8*))  # Restore InFrames
               (Src: in P)
               (until (== In (val $Stdin))
                  (let In: (ioFrame In)
                     (setq In (In: link))
                     (In: link P)
                     (setq P (In:)) ) )
               (Src: (env $InFrames i8*) P) )
            (let P (Org: (env $Catch i8*))  # Restore CaFrames
               (Src: ca P)
               (while Ca
                  (let Ca: (caFrame Ca)
                     (setq Ca (Ca: link))
                     (Ca: link P)
                     (setq P (Ca:)) ) )
               (Src: (env $Catch i8*) P) )
            (let P (Src: bnd)  # Restore bindings
               (set 3 P (Org: (env $Bind any)))
               (while Bnd
                  (let Q Bnd
                     (xchg (val 2 Q) Q)
                     (setq Bnd (val 3 Q))
                     (set 3 Q P)
                     (setq P Q) ) )
               (Src: (env $Bind any) P) )
            (let P (Org: (env $Link any))  # Restore Stack(s)
               (Src: lnk P)
               (while Lnk
                  (let Q Lnk
                     (setq Lnk (val 2 Q))
                     (set 2 Q P)
                     (setq P Q) ) )
               (Src: (env $Link any) P) ) )
         (loadCoEnv (Src:)) ) ) )

(de brkLoad (Exe)
   (when
      (and
         ((inFile (val (val $InFiles))) tty)
         ((outFile (val 2 (val $OutFiles))) tty)
         (=0 (val $Break)) )
      (let P (val $Bind)
         (setq P (push (val $At) $At P 0))  # [[@] @ LINK Expr]
         (setq P (push (val $Up) $Up P))
         (set $Up Exe)
         (set $Break (set $Bind (push (val $Run) $Run P)))
         (set $Run $Nil) )
      (pushOutFile (b8+ (ioFrame T)) (val 2 (val $OutFiles)) 0)  # Stdout
      (print Exe)
      (newline)
      (repl 0 ($ "! ") $Nil)
      (popOutFiles)
      (setq Exe (val $Up))
      (let P (val $Bind)
         (set $Run (val P))
         (setq P (val 3 P))
         (set $Up (val P))
         (setq P (val 3 P))
         (set $At (val P))
         (set $Bind (val 3 P)) )
      (set $Break 0) )
   Exe )

# (! . exe) -> any
(de _Break (Exe)
   (let X (cdr Exe)
      (unless (nil? (val $Dbg))
         (setq X (brkLoad X)) )
      (eval X) ) )

# (e . prg) -> any
(de _E (Exe)
   (let P (val $Break)
      (unless P
         (err Exe 0 ($ "No Break")  null) )
      (let
         (Dbg (save (val $Dbg))
            At (save (val $At))
            Run (save (val $Run)) )
         (set
            $Dbg $Nil
            $Run (val P)
            $At (val (val 3 (val 3 P))) )
         (let (In: (ioFrame (val $InFrames))  Out: (ioFrame (val $OutFrames)))
            (popInFiles)
            (popOutFiles)
            (prog1
               (if (pair (cdr Exe))
                  (run @)
                  (eval (val $Up)) )
               (if (Out: file)
                  (pushOutFile (Out:) (Out: file) (Out: pid))
                  (pushOutput (Out:) ((ioxFrame (Out:)) exe)) )
               (if (In: file)
                  (pushInFile (In:) (In: file) (In: pid))
                  (pushInput (In:) ((ioxFrame (In:)) exe)) )
               (set $Run Run  $At At  $Dbg Dbg) ) ) ) ) )

(local) trace

(de void trace ((i32 . C) X)
   (when (> C 64)
      (setq C 64) )
   (while (ge0 (dec 'C))
      (space) )
   (if (atom X)  # Symbol
      (print @)
      (print (car X))  # Method
      (space)
      (print (cdr X))  # Class
      (space)
      (print (val $This)) ) )  # 'This'

# ($ sym|lst lst . prg) -> any
(de _Trace (Exe)
   (let X (cdr Exe)
      (if (nil? (val $Dbg))
         (run (cddr X))
         (let (Out (val $OutFile)  Put (val (i8** $Put)))
            (set
               $OutFile (val 3 (val $OutFiles))  # Stderr
               $Put (fun (void i8) _putStdout) )
            (let (Y (++ X)  Z (++ X))
               (trace (set $Trace (inc (val $Trace))) Y)
               (outString ($ " :"))
               (while (pair Z)
                  (space)
                  (print (val (++ Z))) )
               (cond
                  ((== Z $At)
                     (setq Z (val $Next))
                     (while (pair Z)
                        (space)
                        (print (cdr Z))
                        (setq Z (car Z)) ) )
                  ((not (nil? Z))
                     (space)
                     (print (val Z)) ) )
               (newline)
               (set (i8** $Put) Put  $OutFile Out)
               (prog1
                  (run X)
                  (set
                     $OutFile (val 3 (val $OutFiles))  # Stderr
                     $Put (fun (void i8) _putStdout) )
                  (let I (val $Trace)
                     (trace I Y)
                     (set $Trace (dec I)) )
                  (outString ($ " = "))
                  (print @)
                  (newline)
                  (set (i8** $Put) Put  $OutFile Out) ) ) ) ) ) )

# (exec 'any ..)
(de _Exec (Exe)
   (let
      (X (cdr Exe)
         Av (b8* (inc (length X)))
         Cmd (xName (evSym X)) )
      (set Av (pathString Cmd (b8 (pathSize Cmd))))
      (stkChk Exe)
      (let A Av
         (while (pair (shift X))
            (let Nm (xName (evSym X))
               (set (inc 'A)
                  (bufString Nm (b8 (bufSize Nm))) ) )
            (stkChk Exe) )
         (set (inc 'A) null) )
      (flushAll)
      (execvp (val Av) Av)  # Execute program
      (execErr (val Av)) ) )  # Error if failed

# (call 'any ..) -> flg
(de _Call (Exe)
   (let
      (X (cdr Exe)
         Av (b8* (inc (length X)))
         Cmd (xName (evSym X)) )
      (set Av (pathString Cmd (b8 (pathSize Cmd))))
      (stkChk Exe)
      (let A Av
         (while (pair (shift X))
            (let Nm (xName (evSym X))
               (set (inc 'A)
                  (bufString Nm (b8 (bufSize Nm))) ) )
            (stkChk Exe) )
         (set (inc 'A) null) )
      (flushAll)
      (let
         (Tc (tcgetpgrp 0)
            Fg (and (val Tio) (== Tc (getpgrp))) )
         (cond
            ((lt0 (fork)) (forkErr Exe))
            ((=0 @)  # In child
               (setpgid 0 0)  # Set process group
               (when Fg
                  (tcsetpgrp 0 (getpid)) )
               (execvp (val Av) Av)  # Execute program
               (execErr (val Av)) ) )  # Error if failed
         # In parent
         (let (Pid @  Res (b32 1))
            (setpgid Pid 0)  # Set process group
            (when Fg
               (tcsetpgrp 0 Pid) )
            (loop
               (while (lt0 (waitWuntraced Pid Res))
                  (unless (== (gErrno) EINTR)
                     (err Exe 0 ($ "wait pid") null) )
                  (sigChk Exe) )
               (when Fg
                  (tcsetpgrp 0 Tc) )
               (? (=0 (wifStopped Res))
                  (set $At2 (cnt (i64 (val Res))))
                  (if (val Res) $Nil $T) )
               (repl 0 ($ "+ ") $Nil)
               (when Fg
                  (tcsetpgrp 0 Pid) )
               (kill Pid (val SIGCONT Sig)) ) ) ) ) )

# (ipid) -> pid | NIL
(de _Ipid (Exe)
   (let Io: (ioFrame (val $InFrames))
      (if (and (Io: file) (> (Io: pid) 1))
         (cnt (i64 (Io: pid)))
         $Nil ) ) )

# (opid) -> pid | NIL
(de _Opid (Exe)
   (let Io: (ioFrame (val $OutFrames))
      (if (and (Io: file) (> (Io: pid) 1))
         (cnt (i64 (Io: pid)))
         $Nil ) ) )

# (kill 'pid ['cnt]) -> flg
(de _Kill (Exe)
   (let (X (cdr Exe)  Pid (i32 (evCnt Exe X)))
      (if
         (kill
            Pid
            (if (atom (shift X))
               (val SIGTERM Sig)
               (i32 (evCnt Exe X)) ) )
         $Nil
         $T ) ) )

# (fork) -> pid | NIL
(de _Fork (Exe)
   (if (forkLisp Exe)
      (cnt (i64 @))
      $Nil ) )

# (detach) -> pid | NIL
(de _Detach (Exe)
   (prog1
      (val $PPid)
      (unless (nil? @)
         (set $PPid $Nil)
         (close (val $Tell))
         (set $Tell 0)
         (let H (val $Hear)
            (close H)
            (closeInFile H)
            (closeOutFile H) )
         (set $Hear 0)
         (close (val $Mic))
         (set $Mic 0)
         (set $Slot 0)
         (setsid) ) ) )

# (bye ['cnt])
(de _Bye (Exe)
   (bye
      (if (nil? (eval (cadr Exe)))
         0
         (i32 (xCnt Exe @)) ) ) )
pil21/src/subr.l0000644000000000000000000015034714717332364010636 0ustar  # 20nov24 Software Lab. Alexander Burger

(symbols '(llvm))

(local) (chkA chkD makeErr)

(inline (Exe) chkA (X)
   (car (needVar Exe X)) )

(inline (Exe) chkD (X)
   (cdr (needLst Exe X)) )

(de NIL makeErr (Exe)
   (err Exe 0 ($ "Not making") null) )

# (car 'var) -> any
(de _Car (Exe)
   (chkA (eval (cadr Exe))) )

# (cdr 'lst) -> any
(de _Cdr (Exe)
   (chkD (eval (cadr Exe))) )

(de _Caar (Exe)
   (chkA (chkA (eval (cadr Exe)))) )

(de _Cadr (Exe)
   (chkA (chkD (eval (cadr Exe)))) )

(de _Cdar (Exe)
   (chkD (chkA (eval (cadr Exe)))) )

(de _Cddr (Exe)
   (chkD (chkD (eval (cadr Exe)))) )

(de _Caaar (Exe)
   (chkA (chkA (chkA (eval (cadr Exe))))) )

(de _Caadr (Exe)
   (chkA (chkA (chkD (eval (cadr Exe))))) )

(de _Cadar (Exe)
   (chkA (chkD (chkA (eval (cadr Exe))))) )

(de _Caddr (Exe)
   (chkA (chkD (chkD (eval (cadr Exe))))) )

(de _Cdaar (Exe)
   (chkD (chkA (chkA (eval (cadr Exe))))) )

(de _Cdadr (Exe)
   (chkD (chkA (chkD (eval (cadr Exe))))) )

(de _Cddar (Exe)
   (chkD (chkD (chkA (eval (cadr Exe))))) )

(de _Cdddr (Exe)
   (chkD (chkD (chkD (eval (cadr Exe))))) )

(de _Caaaar (Exe)
   (chkA (chkA (chkA (chkA (eval (cadr Exe)))))) )

(de _Caaadr (Exe)
   (chkA (chkA (chkA (chkD (eval (cadr Exe)))))) )

(de _Caadar (Exe)
   (chkA (chkA (chkD (chkA (eval (cadr Exe)))))) )

(de _Caaddr (Exe)
   (chkA (chkA (chkD (chkD (eval (cadr Exe)))))) )

(de _Cadaar (Exe)
   (chkA (chkD (chkA (chkA (eval (cadr Exe)))))) )

(de _Cadadr (Exe)
   (chkA (chkD (chkA (chkD (eval (cadr Exe)))))) )

(de _Caddar (Exe)
   (chkA (chkD (chkD (chkA (eval (cadr Exe)))))) )

(de _Cadddr (Exe)
   (chkA (chkD (chkD (chkD (eval (cadr Exe)))))) )

(de _Cdaaar (Exe)
   (chkD (chkA (chkA (chkA (eval (cadr Exe)))))) )

(de _Cdaadr (Exe)
   (chkD (chkA (chkA (chkD (eval (cadr Exe)))))) )

(de _Cdadar (Exe)
   (chkD (chkA (chkD (chkA (eval (cadr Exe)))))) )

(de _Cdaddr (Exe)
   (chkD (chkA (chkD (chkD (eval (cadr Exe)))))) )

(de _Cddaar (Exe)
   (chkD (chkD (chkA (chkA (eval (cadr Exe)))))) )

(de _Cddadr (Exe)
   (chkD (chkD (chkA (chkD (eval (cadr Exe)))))) )

(de _Cdddar (Exe)
   (chkD (chkD (chkD (chkA (eval (cadr Exe)))))) )

(de _Cddddr (Exe)
   (chkD (chkD (chkD (chkD (eval (cadr Exe)))))) )

# (nth 'lst 'cnt ..) -> lst
(de _Nth (Exe)
   (let (X (cdr Exe)  Y (save (eval (++ X))))
      (loop
         (? (atom Y) Y)
         (let C (evCnt Exe X)
            (? (lt0 (dec 'C)) $Nil)
            (while (ge0 (dec 'C))
               (shift Y) ) )
         (? (atom (shift X)) Y)
         (setq Y (car Y)) ) ) )

# (con 'lst 'any) -> any
(de _Con (Exe)
   (let X (cdr Exe)
      (set 2
         (save (needPair Exe (eval (++ X))))
         (eval (car X)) ) ) )

# (cons 'any ['any ..]) -> lst
(de _Cons (Exe)
   (let
      (X (cdr Exe)
         Y (cons (eval (car X)) $Nil)
         R (save Y) )
      (while (pair (cdr (shift X)))
         (setq Y
            (set 2 Y (cons (eval (car X)) $Nil)) ) )
      (set 2 Y (eval (car X)))
      R ) )

# (conc 'lst ..) -> lst
(de _Conc (Exe)
   (let
      (X (cdr Exe)
         Y (eval (car X))
         R (save Y) )
      (while (pair (shift X))
         (let Z (eval (car X))
            (if (atom Y)
               (setq Y (setq R (safe Z)))
               (while (pair (cdr Y))
                  (setq Y @) )
               (set 2 Y Z) ) ) )
      R ) )

# (circ 'any ..) -> lst
(de _Circ (Exe)
   (let
      (X (cdr Exe)
         Y (cons (eval (car X)) $Nil)
         R (save Y) )
      (while (pair (shift X))
         (setq Y
            (set 2 Y (cons (eval (car X)) $Nil)) ) )
      (set 2 Y R) ) )

# (rot 'lst ['cnt]) -> lst
(de _Rot (Exe)
   (let (X (cdr Exe)  R (eval (car X)))
      (when (pair R)
         (let (Y R  A (++ Y))
            (if (pair (shift X))
               (let N (save R (evCnt Exe X))
                  (while (and (pair Y) (gt0 (dec 'N)))
                     (let B (car Y)
                        (set Y A)
                        (setq A B) )
                     (? (== R (shift Y))) )
                  (set R A) )
               (while (pair Y)
                  (let B (car Y)
                     (set Y A)
                     (setq A B) )
                  (? (== R (shift Y))) )
               (set R A) ) ) )
         R ) )

# (list 'any ['any ..]) -> lst
(de _List (Exe)
   (let
      (X (cdr Exe)
         Y (cons (eval (car X)) $Nil)
         R (save Y) )
      (while (pair (shift X))
         (setq Y
            (set 2 Y (cons (eval (car X)) $Nil)) ) )
      R ) )

# (need 'cnt ['lst ['any]]) -> lst
# (need 'cnt ['num|sym]) -> lst
(de _Need (Exe)
   (let
      (X (cdr Exe)
         C (evCnt Exe X)
         R (save (eval (car (shift X))))
         Y
         (save
            (if (or (pair R) (nil? R))
               (eval (cadr X))
               (prog1
                  R
                  (setq R $Nil) ) ) )
         Z R )
      (when C
         (cond
            ((gt0 C)
               (while (pair Z)
                  (dec 'C)
                  (shift Z) )
               (while (ge0 (dec 'C))
                  (setq R (safe (cons Y R))) ) )
            (T
               (if (atom R)
                  (setq Z (setq R (safe (cons Y $Nil))))
                  (while (pair (cdr Z))
                     (inc 'C)
                     (shift Z) ) )
               (while (lt0 (inc 'C))
                  (setq Z (set 2 Z (cons Y $Nil))) ) ) ) )
      R ) )

# (range 'num1 'num2 ['num3]) -> lst
(de _Range (Exe)
   (let
      (X (cdr Exe)
         N (needNum Exe (eval (++ X)))
         R (save (cons N $Nil))
         Lim (save (needNum Exe (eval (++ X))))
         Inc
         (if (nil? (eval (car X)))
            ONE
            (save (needNum Exe @)) ) )
      (when (or (== Inc ZERO) (sign? Inc))
         (argErr Exe Inc) )
      (let P R
         (if (le0 (cmpNum N Lim))
            (while (le0 (cmpNum (setq N (adds N Inc)) Lim))
               (setq P (set 2 P (cons N $Nil))) )
            (while (ge0 (cmpNum (setq N (subs N Inc)) Lim))
               (setq P (set 2 P (cons N $Nil))) ) ) )
      R ) )

# (full 'any) -> bool
(de _Full (Exe)
   (let X (eval (cadr Exe))
      (loop
         (? (atom X) $T)
         (? (nil? (car X)) $Nil)
         (shift X) ) ) )

# (make .. [(made 'lst ..)] .. [(link 'any ..)] ..) -> any
(de _Make (Exe)
   (let
      (Make (val $Make)
         Yoke (val $Yoke)
         R (link (push $Nil NIL)) )
      (set $Make (set $Yoke R))
      (exec (cdr Exe))
      (set $At2
         (if (pair (val R))
            (ofs (val $Make) -1)
            $Nil ) )
      (set $Make Make  $Yoke Yoke)
      (pop R) ) )

# (made ['lst1 ['lst2]]) -> lst
(de _Made (Exe)
   (let X (cdr Exe)
      (unless (val $Make)
         (makeErr Exe) )
      (when (pair X)
         (if (atom (set (val $Yoke) (eval (++ X))))
            (set $Make (val $Yoke))
            (let Y (eval (car X))
               (when (atom Y)
                  (setq Y (val (val $Yoke)))
                  (while (pair (cdr Y))
                     (setq Y @) ) )
               (set $Make (ofs Y 1)) ) ) )
      (val (val $Yoke)) ) )

# (chain 'any ..) -> any
(de _Chain (Exe)
   (let X (cdr Exe)
      (unless (val $Make)
         (makeErr Exe) )
      (loop
         (let Y (set (val $Make) (eval (++ X)))
            (when (pair Y)
               (let Z Y
                  (while (pair (cdr Z))
                     (setq Z @) )
                  (set $Make (ofs Z 1)) ) )
            (? (atom X) Y) ) ) ) )

# (link 'any ..) -> any
(de _Link (Exe)
   (let X (cdr Exe)
      (unless (val $Make)
         (makeErr Exe) )
      (loop
         (let Y (eval (++ X))
            (set $Make
               (ofs
                  (set (val $Make) (cons Y $Nil))
                  1 ) )
            (? (atom X) Y) ) ) ) )

# (yoke 'any ..) -> any
(de _Yoke (Exe)
   (let X (cdr Exe)
      (unless (val $Make)
         (makeErr Exe) )
      (loop
         (let Y (eval (++ X))
            (let P (val $Yoke)
               (set P (cons Y (val P))) )
            (? (atom X)
               (let Z (val $Make)
                  (while (pair (val Z))
                     (setq Z (ofs @ 1)) )
                  (set $Make Z) )
               Y ) ) ) ) )

# (copy 'any) -> any
(de _Copy (Exe)
   (let X (cdr Exe)
      (if (atom (setq X (eval (car X))))
         X
         (let
            (Y (cons (car X) (cdr X))
               R (save Y)
               Z X )
            (while (pair (setq X (cdr Y)))
               (? (== X Z) (set 2 Y R))
               (setq Y
                  (set 2 Y (cons (car X) (cdr X))) ) )
            R ) ) ) )

# (mix 'lst cnt|'any ..) -> lst
(de _Mix (Exe)
   (let (X (cdr Exe)  Y (eval (car X)))
      (nond
         ((or (pair Y) (nil? Y)) Y)
         ((pair (shift X)) $Nil)
         (NIL
            (save Y
               (let
                  (Z
                     (cons
                        (if (cnt? (car X))
                           (nth @ Y)
                           (eval @) )
                        $Nil )
                     R (save Z) )
                  (while (pair (shift X))
                     (setq Z
                        (set 2 Z
                           (cons
                              (if (cnt? (car X))
                                 (nth @ Y)
                                 (eval @) )
                              $Nil ) ) ) )
                  R ) ) ) ) ) )

# (append 'lst ..) -> lst
(de _Append (Exe)
   (let X Exe
      (loop
         (? (atom (cdr (shift X)))
            (eval (car X)) )
         (? (pair (eval (car X)))
            (let
               (Y @
                  R (save (cons (++ Y) Y))
                  Z R )
               (while (pair Y)
                  (setq Z (set 2 Z (cons (++ Y) Y))) )
               (while (pair (cdr (shift X)))
                  (save (setq Y (eval (car X)))
                     (while (pair Y)
                        (setq Z (set 2 Z (cons (++ Y) Y))) ) ) )
               (set 2 Z (eval (car X)))
               R ) ) ) ) )

# (delete 'any 'lst ['flg]) -> lst
(de _Delete (Exe)
   (let
      (X (cdr Exe)
         Y (save (eval (++ X)))
         L (save (eval (++ X)))
         F (nil? (eval (car X))) )
      (loop
         (? (atom L) L)
         (? (not (equal Y (car L)))
            (let R (save (setq X (cons (car L) $Nil)))
               (loop
                  (? (atom (shift L))
                     (set 2 X L) )
                  (ifn (equal Y (car L))
                     (setq X (set 2 X (cons (car L) $Nil)))
                     (? F (set 2 X (cdr L))) ) )
               R ) )
         (shift L)
         (? F L) ) ) )

# (delq 'any 'lst ['flg]) -> lst
(de _Delq (Exe)
   (let
      (X (cdr Exe)
         Y (save (eval (++ X)))
         L (save (eval (++ X)))
         F (nil? (eval (car X))) )
      (loop
         (? (atom L) L)
         (? (<> Y (car L))
            (let R (save (setq X (cons (car L) $Nil)))
               (loop
                  (? (atom (shift L))
                     (set 2 X L) )
                  (if (<> Y (car L))
                     (setq X (set 2 X (cons (car L) $Nil)))
                     (? F (set 2 X (cdr L))) ) )
               R ) )
         (shift L)
         (? F L) ) ) )

# (replace 'lst 'any1 'any2 ..) -> lst
(de _Replace (Exe)
   (let (X (cdr Exe)  L (save (eval (car X))))
      (if (atom L)
         @
         (let (A $Nil  N 0  R (push NIL NIL))
            (while (pair (shift X))
               (link (push (eval (++ X)) NIL))
               (setq A (link (push (eval (car X)) NIL)))
               (inc 'N) )
            (let (Y (++ L)  Z A  I N)
               (until (lt0 (dec 'I))
                  (let (V (++ Z)  K (++ Z))
                     (? (equal Y K)
                        (setq Y V) ) ) )
               (let P (set (link R) (cons Y $Nil))
                  (while (pair L)
                     (setq Y (++ L)  Z A  I N)
                     (until (lt0 (dec 'I))
                        (let (V (++ Z)  K (++ Z))
                           (? (equal Y K)
                              (setq Y V) ) ) )
                     (setq P (set 2 P (cons Y $Nil))) ) ) )
            (val R) ) ) ) )

# (insert 'cnt 'lst 'any) -> lst
(de _Insert (Exe)
   (let
      (X (cdr Exe)
         N (evCnt Exe X)
         L (save (eval (car (shift X)))) )
      (setq X (eval (car (shift X))))
      (if (or (atom L) (le0 (dec 'N)))
         (cons X L)
         (let (Y (cons (car L) $Nil)  R (save Y))
            (while (and (pair (shift L)) (dec 'N))
               (setq Y (set 2 Y (cons (car L) $Nil))) )
            (set 2 Y (cons X L))
            R ) ) ) )

# (remove 'cnt 'lst) -> lst
(de _Remove (Exe)
   (let
      (X (cdr Exe)
         N (evCnt Exe X)
         L (save (eval (car (shift X)))) )
      (cond
         ((or (atom L) (lt0 (dec 'N))) L)
         ((=0 N) (cdr L))
         (T
            (let (Y (cons (car L) $Nil)  R (save Y))
               (loop
                  (? (atom (shift L))
                     (set 2 Y L) )
                  (? (=0 (dec 'N))
                     (set 2 Y (cdr L)) )
                  (setq Y (set 2 Y (cons (car L) $Nil))) )
               R ) ) ) ) )

# (place 'cnt 'lst 'any) -> lst
(de _Place (Exe)
   (let
      (X (cdr Exe)
         N (evCnt Exe X)
         L (save (eval (car (shift X))))
         Y (save (eval (car (shift X)))) )
      (cond
         ((atom L) (cons Y $Nil))
         ((le0 (dec 'N)) (cons Y (cdr L)))
         (T
            (let (Z (cons (car L) $Nil)  R (save Z))
               (loop
                  (? (atom (shift L))
                     (set 2 Z (cons Y L)) )
                  (? (=0 (dec 'N))
                     (set 2 Z (cons Y (cdr L))) )
                  (setq Z (set 2 Z (cons (car L) $Nil))) )
               R ) ) ) ) )

# (strip 'any) -> any
(de _Strip (Exe)
   (let X (eval (cadr Exe))
      (while (and (pair X) (== $Quote (car X)))
         (? (== (cdr X) X))  # Circular
         (setq X @) )
      X ) )

# (split 'lst 'any ..) -> lst
(de _Split (Exe)
   (let (X (cdr Exe)  L (save (eval (car X))))
      (if (atom L)
         @
         (let (A $Nil  N 0)
            (while (pair (shift X))
               (setq A (link (push (eval (car X)) NIL)))
               (inc 'N) )
            (let
               (P $Nil
                  R (link (push P NIL))
                  Q $Nil
                  S (link (push Q NIL)) )
               (loop
                  (let (Y (++ L)  Z A  I N)
                     (loop
                        (? (lt0 (dec 'I))  # Not a delimiter
                           (let C (cons Y $Nil)
                              (setq Q
                                 (if (nil? Q)
                                    (set S C)
                                    (set 2 Q C) ) ) ) )
                        (? (equal Y (++ Z))  # Delimiter
                           (let C (cons (val S) $Nil)
                              (setq P
                                 (if (nil? P)
                                    (set R C)
                                    (set 2 P C) ) ) )
                           (setq Q (set S $Nil)) ) ) )
                  (? (atom L)) )
               (let C (cons (val S) $Nil)
                  (if (nil? P)
                     C
                     (set 2 P C)
                     (val R) ) ) ) ) ) ) )

# (reverse 'lst) -> lst
(de _Reverse (Exe)
   (let
      (X (cdr Exe)
         Y (save (eval (car X)))
         Z $Nil )
      (while (pair Y)
         (setq Z (cons (++ Y) Z)) )
      Z ) )

# (flip 'lst ['cnt]) -> lst
(de _Flip (Exe)
   (let (X (cdr Exe)  Y (eval (car X)))
      (if (atom Y)
         Y
         (let Z (cdr Y)
            (cond
               ((atom Z) Y)
               ((atom (shift X))
                  (set 2 Y $Nil)
                  (loop
                     (setq X (cdr Z))
                     (set 2 Z Y)
                     (? (atom X) Z)
                     (setq Y Z  Z X) ) )
               (T
                  (let N (save Y (evCnt Exe X))
                     (if (le0 (dec 'N))
                        Y
                        (set 2 Y (cdr Z)  2 Z Y)
                        (until
                           (or
                              (=0 (dec 'N))
                              (atom (setq X (cdr Y))) )
                           (set 2 Y (cdr X)  2 X Z)
                           (setq Z X) )
                        Z ) ) ) ) ) ) ) )

(local) trim

(de trim (X)
   (if (atom X)
      X
      (stkChk 0)
      (let Y (trim (cdr X))
         (if (and (nil? Y) (isBlank (car X)))
            $Nil
            (cons (car X) Y) ) ) ) )

# (trim 'lst) -> lst
(de _Trim (Exe)
   (trim (save (eval (cadr Exe)))) )

# (clip 'lst) -> lst
(de _Clip (Exe)
   (let (X (cdr Exe)  Y (eval (car X)))
      (while (and (pair Y) (isBlank (car Y)))
         (shift Y) )
      (trim (save Y)) ) )

# (head 'cnt|lst 'lst) -> lst
(de _Head (Exe)
   (let (X (cdr Exe)  Y (eval (++ X)))
      (cond
         ((nil? Y) Y)
         ((pair Y)
            (save Y
               (let (Z Y  L (eval (car X)))
                  (loop
                     (?
                        (or
                           (atom L)
                           (not (equal (car Z) (car L))) )
                        $Nil )
                     (? (atom (shift Z)) Y)
                     (shift L) ) ) ) )
         ((=0 (xCnt Exe Y)) $Nil)
         (T
            (let (N @  L (eval (car X)))
               (cond
                  ((atom L) L)
                  ((and
                        (lt0 N)
                        (le0 (inc 'N (length L))) )
                     $Nil )
                  (T
                     (save L
                        (let (Z (cons (car L) $Nil)  R (save Z))
                           (while (and (dec 'N) (pair (shift L)))
                              (setq Z
                                 (set 2 Z (cons (car L) $Nil)) ) )
                           R ) ) ) ) ) ) ) ) )

# (tail 'cnt|lst 'lst) -> lst
(de _Tail (Exe)
   (let (X (cdr Exe)  Y (eval (++ X)))
      (cond
         ((nil? Y) Y)
         ((pair Y)
            (save Y
               (let L (eval (car X))
                  (loop
                     (? (atom L) $Nil)
                     (? (equal L Y) Y)
                     (? (atom (shift L)) $Nil) ) ) ) )
         ((=0 (xCnt Exe Y)) $Nil)
         (T
            (let (N @  L (eval (car X)))
               (cond
                  ((atom L) L)
                  ((lt0 N)
                     (loop
                        (shift L)
                        (? (=0 (inc 'N)) L) ) )
                  (T
                     (let Z L
                        (loop
                           (? (=0 (dec 'N)))
                           (? (atom (shift Z))) )
                        (while (pair (shift Z))
                           (shift L) )
                        L ) ) ) ) ) ) ) )

# (stem 'lst 'any ..) -> lst
(de _Stem (Exe)
   (let (X (cdr Exe)  L (save (eval (++ X))))
      (if (atom X)
         L
         (let (R L  N 1  A T)
            (loop
               (setq A (link (push (eval (car X)) NIL)))
               (? (atom (shift X)))
               (inc 'N) )
            (loop
               (let (P A  I N)
                  (loop
                     (? (equal (car L) (car P))
                        (setq R (cdr L)) )
                     (? (=0 (dec 'I)))
                     (shift P) ) )
               (? (atom (shift L))) )
            R ) ) ) )

# (fin 'any) -> num|sym
(de _Fin (Exe)
   (let X (eval (cadr Exe))
      (while (pair X)
         (shift X) )
      X ) )

# (last 'lst) -> any
(de _Last (Exe)
   (let X (eval (cadr Exe))
      (if (atom X)
         X
         (while (pair (cdr X))
            (setq X @) )
         (car X) ) ) )

# (== 'any ..) -> flg
(de _Eq (Exe)
   (let (X (cdr Exe)  Y (save (eval (car X))))
      (loop
         (? (atom (shift X)) $T)
         (? (<> Y (eval (car X))) $Nil) ) ) )

# (n== 'any ..) -> flg
(de _Neq (Exe)
   (let (X (cdr Exe)  Y (save (eval (car X))))
      (loop
         (? (atom (shift X)) $Nil)
         (? (<> Y (eval (car X))) $T) ) ) )

# (= 'any ..) -> flg
(de _Equal (Exe)
   (let (X (cdr Exe)  Y (save (eval (car X))))
      (loop
         (? (atom (shift X)) $T)
         (? (not (equal Y (eval (car X)))) $Nil) ) ) )

# (<> 'any ..) -> flg
(de _Nequal (Exe)
   (let (X (cdr Exe)  Y (save (eval (car X))))
      (loop
         (? (atom (shift X)) $Nil)
         (? (not (equal Y (eval (car X)))) $T) ) ) )

# (=0 'any) -> 0 | NIL
(de _Eq0 (Exe)
   (if (== (eval (cadr Exe)) ZERO) @ $Nil) )

# (=1 'any) -> 1 | NIL
(de _Eq1 (Exe)
   (if (== (eval (cadr Exe)) ONE) @ $Nil) )

# (=T 'any) -> flg
(de _EqT (Exe)
   (if (t? (eval (cadr Exe))) @ $Nil) )

# (n0 'any) -> flg
(de _Neq0 (Exe)
   (if (== (eval (cadr Exe)) ZERO) $Nil $T) )

# (nT 'any) -> flg
(de _NeqT (Exe)
   (if (t? (eval (cadr Exe))) $Nil $T) )

# (< 'any ..) -> flg
(de _Lt (Exe)
   (let (X (cdr Exe)  Y (save (eval (car X))))
      (loop
         (? (atom (shift X)) $T)
         (let Z (eval (car X))
            (? (ge0 (compare Y Z)) $Nil)
            (setq Y (safe Z)) ) ) ) )

# (<= 'any ..) -> flg
(de _Le (Exe)
   (let (X (cdr Exe)  Y (save (eval (car X))))
      (loop
         (? (atom (shift X)) $T)
         (let Z (eval (car X))
            (? (gt0 (compare Y Z)) $Nil)
            (setq Y (safe Z)) ) ) ) )

# (> 'any ..) -> flg
(de _Gt (Exe)
   (let (X (cdr Exe)  Y (save (eval (car X))))
      (loop
         (? (atom (shift X)) $T)
         (let Z (eval (car X))
            (? (le0 (compare Y Z)) $Nil)
            (setq Y (safe Z)) ) ) ) )

# (>= 'any ..) -> flg
(de _Ge (Exe)
   (let (X (cdr Exe)  Y (save (eval (car X))))
      (loop
         (? (atom (shift X)) $T)
         (let Z (eval (car X))
            (? (lt0 (compare Y Z)) $Nil)
            (setq Y (safe Z)) ) ) ) )

# (max 'any ..) -> any
(de _Max (Exe)
   (let (X (cdr Exe)  R (save (eval (car X))))
      (while (pair (shift X))
         (let Z (eval (car X))
            (when (gt0 (compare Z R))
               (setq R (safe Z)) ) ) )
      R ) )

# (min 'any ..) -> any
(de _Min (Exe)
   (let (X (cdr Exe)  R (save (eval (car X))))
      (while (pair (shift X))
         (let Z (eval (car X))
            (when (lt0 (compare Z R))
               (setq R (safe Z)) ) ) )
      R ) )

# (atom 'any) -> flg
(de _Atom (Exe)
   (if (atom (eval (cadr Exe))) $T $Nil) )

# (pair 'any) -> any
(de _Pair (Exe)
   (if (pair (eval (cadr Exe))) @ $Nil) )

# (circ? 'any) -> any
(de _CircQ (Exe)
   (if (circ (eval (cadr Exe))) @ $Nil) )

# (lst? 'any) -> flg
(de _LstQ (Exe)
   (if (or (pair (eval (cadr Exe))) (nil? @))
      $T
      $Nil ) )

# (num? 'any) -> num | NIL
(de _NumQ (Exe)
   (if (num? (eval (cadr Exe))) @ $Nil) )

# (sym? 'any) -> flg
(de _SymQ (Exe)
   (if (symb? (eval (cadr Exe)))
      $T
      $Nil ) )

# (flg? 'any) -> flg
(de _FlgQ (Exe)
   (if (or (t? (eval (cadr Exe))) (nil? @))
      $T
      $Nil ) )

# (member 'any 'lst) -> any
(de _Member (Exe)
   (let
      (X (cdr Exe)
         Y (save (eval (++ X)))
         Z (eval (car X))
         H Z )
      (loop
         (? (atom Z)
            (if (equal Y Z) Z $Nil) )
         (? (equal Y (car Z)) Z)
         (? (== H (shift Z)) $Nil) ) ) )

# (memq 'any 'lst) -> any
(de _Memq (Exe)
   (let
      (X (cdr Exe)
         Y (save (eval (++ X)))
         Z (eval (car X))
         H Z )
      (loop
         (? (atom Z)
            (if (== Y Z) Z $Nil) )
         (? (== Y (car Z)) Z)
         (? (== H (shift Z)) $Nil) ) ) )

# (mmeq 'lst 'lst) -> any
(de _Mmeq (Exe)
   (let
      (X (cdr Exe)
         Y (save (eval (++ X)))
         Z (eval (car X)) )
      (while (pair Y)
         (let (U (++ Y)  V Z)
            (while (pair V)
               (when (== U (car V))
                  (ret V) )
               (when (== Z (shift V))  # Hit head
                  (ret $Nil) ) )
            (? (== U V) V) ) )
      $Nil ) )

# (sect 'lst 'lst) -> lst
(de _Sect (Exe)
   (let
      (X (cdr Exe)
         Y (save (eval (++ X)))
         Z (save (eval (car X)))
         P 0
         R (link (push $Nil NIL)) )
      (while (pair Y)
         (let U (++ Y)
            (when (member U Z)
               (let V (cons U $Nil)
                  (setq P
                     (if P
                        (set 2 P V)
                        (set R V) ) ) ) ) ) )
      (val R) ) )

# (diff 'lst 'lst) -> lst
(de _Diff (Exe)
   (let
      (X (cdr Exe)
         Y (save (eval (++ X)))
         Z (save (eval (car X)))
         P 0
         R (link (push $Nil NIL)) )
      (while (pair Y)
         (let U (++ Y)
            (unless (member U Z)
               (let V (cons U $Nil)
                  (setq P
                     (if P
                        (set 2 P V)
                        (set R V) ) ) ) ) ) )
      (val R) ) )

# (index 'any 'lst) -> cnt | NIL
(de _Index (Exe)
   (let
      (X (cdr Exe)
         Y (save (eval (++ X)))
         Z (eval (car X))
         Cnt 1
         U Z )
      (loop
         (? (atom Z) $Nil)
         (? (equal Y (car Z)) (cnt Cnt))
         (inc 'Cnt)
         (? (== U (shift Z)) $Nil) ) ) )

# (offset 'lst1 'lst2) -> cnt | NIL
(de _Offset (Exe)
   (let
      (X (cdr Exe)
         Y (save (eval (++ X)))
         Z (eval (car X))
         Cnt 1 )
      (loop
         (? (atom Z) $Nil)
         (? (equal Y Z) (cnt Cnt))
         (inc 'Cnt)
         (shift Z) ) ) )

# (prior 'lst1 'lst2) -> lst | NIL
(de _Prior (Exe)
   (let
      (X (cdr Exe)
         Y (save (eval (++ X)))
         Z (eval (car X)) )
      (when (and (pair Y) (<> Y Z))
         (while (pair Z)
            (when (== (cdr Z) Y)
               (ret Z) )
            (setq Z @) ) )
      $Nil ) )

# (length 'any) -> cnt | T
(de _Length (Exe)
   (let X (eval (cadr Exe))
      (cond
         ((num? X) (fmtNum X -1 0 0 null))
         ((pair X)
            (let (C ONE  Y X)
               (loop
                  (set X (| (car X) 1))
                  (? (atom (shift X))  # Normal list
                     (loop
                        (set Y (& (car Y) -2))
                        (? (== X (shift Y))) )
                     C )
                  (? (& (car X) 1)
                     (until (== X Y)
                        (set Y (& (car Y) -2))
                        (shift Y) )
                     (loop
                        (set Y (& (car Y) -2))
                        (? (== X (shift Y))) )
                     $T )  # Infinite
                  (inc 'C (hex "10")) ) ) )
         ((nil? X) ZERO)
         ((sym? (val (tail X))) ZERO)
         (T
            (let (C ZERO  P (push 0 (name @)))
               (while (symChar P)
                  (inc 'C (hex "10")) )
               C ) ) ) ) )

(local) (size binSize)

(de size (L)
   (let (C 1  X L  Y (car X))
      (loop
         (when (pair Y)
            (stkChk 0)
            (inc 'C (size Y)) )
         (set X (| Y 1))
         (? (atom (shift X))
            (loop
               (set L (& (car L) -2))
               (? (== X (shift L))) )
            C )
         (? (& (setq Y (car X)) 1)
            (until (== X L)
               (set L (& (car L) -2))
               (shift L) )
            (loop
               (set L (& (car L) -2))
               (? (== X (shift L))) )
            C )
         (inc 'C) ) ) )

(de binSize (X)
   (cond
      ((cnt? X)
         (setq X (shr X 3))  # Normalize short, keep sign bit
         (: 1
            (let C 2  # Count significant bytes plus 1
               (while (setq X (shr X 8))
                  (inc 'C) )
               C ) ) )
      ((big? X)
         (setq X (pos X))
         (let C 9  # Count 8 significant bytes plus 1
            (loop
               (setq D (val (dig X)))
               (? (cnt? (setq X (val (big X)))))
               (inc 'C 8) )  # Increment count by 8
            (setq X (int X))
            (add D D)  # Get most significant bit of last digit
            (setq X (+ X X @@))
            (: 2
               (when X
                  (loop
                     (inc 'C)
                     (? (=0 (setq X (shr X 8)))) ) )
               (if (>= C (+ 63 1))  # More than one chunk
                  (+ C (/ (- C 64) 255) 1)
                  C ) ) ) )
      ((sym? X)
         (cond
            ((nil? X) 1)
            ((== (name (& (val (tail X)) -9)) ZERO) 1)
            ((cnt? (setq X @))
               (setq X (shr (shl X 2) 6))  # Strip status bits
               (goto 1) )
            (T
               (let C 9  # Count 8 significant bytes plus 1
                  (until (cnt? (setq X (val (big X))))
                     (inc 'C 8) )  # Increment count by 8
                  (setq X (int X))
                  (goto 2) ) ) ) )
      (T
         (let (C 2  Y X)
            (loop
               (inc 'C (binSize (++ X)))
               (? (nil? X) C)
               (? (== Y X) (inc C))  # Circular
               (? (atom X) (+ C (binSize X))) ) ) ) ) )

# (size 'any) -> cnt
(de _Size (Exe)
   (let X (eval (cadr Exe))
      (cond
         ((cnt? X)
            (setq X (shr X 3))  # Normalize short, keep sign bit
            (let C ONE
               (while (setq X (shr X 8))
                  (inc 'C (hex "10")) )
               C ) )
         ((big? X)
            (setq X (pos X))
            (let (C (hex "82")  D T)  # Count '8' significant bytes
               (loop
                  (setq D (val (dig X)))
                  (? (cnt? (setq X (val (big X)))))
                  (inc 'C (hex "80")) )  # Increment count by '8'
               (setq X (int X))
               (add D D)  # Get most significant bit of last digit
               (when (setq X (+ X X @@))
                  (loop
                     (inc 'C (hex "10"))
                     (? (=0 (setq X (shr X 8)))) ) )
               C ) )
         ((pair X) (cnt (size X)))
         ((nil? X) ZERO)
         ((sym? (val (tail X)))
            (dbFetch Exe X)
            (let
               (C (+ (binSize (val X)) (inc BLK))  # Value
                  Y (& (val (tail X)) -9) )
               (while (pair Y)  # Properties
                  (let Z (++ Y)
                     (setq C
                        (+ C
                           (if (atom Z)
                              (+ (binSize Z) 2)
                              (+
                                 (binSize (car Z))
                                 (binSize (cdr Z)) ) ) ) ) ) )
               (cnt C) ) )
         ((== (name @) ZERO) @)
         ((cnt? @)
            (let (C ONE  Z (int @))
               (while (setq Z (shr Z 8))
                  (inc 'C (hex "10")) )
               C ) )
         (T
            (let (C (hex "82")  Z @)  # Count '8' significant bytes
               (until (cnt? (setq Z (val (big Z))))
                  (inc 'C (hex "80")) )  # Increment count by '8'
               (when (setq Z (int Z))
                  (loop
                     (inc 'C (hex "10"))
                     (? (=0 (setq Z (shr Z 8)))) ) )
               C ) ) ) ) )

# (bytes 'any) -> cnt
(de _Bytes (Exe)
   (cnt (binSize (eval (cadr Exe)))) )

# (assoc 'any 'lst) -> lst
(de _Assoc (Exe)
   (let
      (X (cdr Exe)
         Y (save (eval (++ X)))
         Z (eval (car X))
         H Z )
      (loop
         (? (atom Z) $Nil)
         (let C (car Z)
            (? (and (pair C) (equal Y (car C))) C) )
         (? (== H (shift Z)) $Nil) ) ) )

# (rassoc 'any 'lst) -> lst
(de _Rassoc (Exe)
   (let
      (X (cdr Exe)
         Y (save (eval (++ X)))
         Z (eval (car X))
         H Z )
      (loop
         (? (atom Z) $Nil)
         (let C (car Z)
            (? (and (pair C) (equal Y (cdr C))) C) )
         (? (== H (shift Z)) $Nil) ) ) )

# (asoq 'any 'lst) -> lst
(de _Asoq (Exe)
   (let
      (X (cdr Exe)
         Y (save (eval (++ X)))
         Z (eval (car X))
         H Z )
      (loop
         (? (atom Z) $Nil)
         (let C (car Z)
            (? (and (pair C) (== Y (car C))) C) )
         (? (== H (shift Z)) $Nil) ) ) )

# (rasoq 'any 'lst) -> lst
(de _Rasoq (Exe)
   (let
      (X (cdr Exe)
         Y (save (eval (++ X)))
         Z (eval (car X))
         H Z )
      (loop
         (? (atom Z) $Nil)
         (let C (car Z)
            (? (and (pair C) (== Y (cdr C))) C) )
         (? (== H (shift Z)) $Nil) ) ) )

# (rank 'any 'lst ['flg]) -> lst
(de _Rank (Exe)
   (let
      (X (cdr Exe)
         Y (save (eval (++ X)))
         Z (save (eval (++ X)))
         R $Nil )
      (if (nil? (eval (car X)))
         (until (gt0 (compare (caar Z) Y))
            (setq R Z)
            (? (atom (shift Z))) )
         (until (lt0 (compare (caar Z) Y))
            (setq R Z)
            (? (atom (shift Z))) ) )
      (car R) ) )

(local) match

(de i1 match (Pat Dat)
   (loop
      (? (atom Pat)
         (if (or (num? Pat) (<> (firstByte Pat) (char "@")))
            (equal Pat Dat)
            (set Pat Dat)
            YES ) )
      (stkChk 0)
      (let X (car Pat)
         (when (and (symb? X) (== (firstByte X) (char "@")))
            (? (atom Dat)
               (and
                  (equal (cdr Pat) Dat)
                  (prog (set X $Nil) YES) ) )
            (? (match (cdr Pat) (cdr Dat))
               (set X (cons (car Dat) $Nil))
               YES )
            (? (match (cdr Pat) Dat)
               (set X $Nil)
               YES )
            (? (match Pat (cdr Dat))
               (set X (cons (car Dat) (val X)))
               YES ) )
         (? (or (atom Dat) (not (match X (car Dat))))
            NO ) )
      (shift Pat)
      (shift Dat) ) )

# (match 'lst1 'lst2) -> flg
(de _Match (Exe)
   (let X (cdr Exe)
      (if
         (match
            (save (eval (++ X)))
            (save (eval (car X))) )
         $T
         $Nil ) ) )

(local) (fill2 fill3)

(de fill2 (X Y)
   (cond
      ((num? X) 0)
      ((sym? X)
         (let V (val X)
            (cond
               ((== X V) 0)  # Auto-quoting
               ((nil? Y)
                  (cond
                     ((== X $At) 0)
                     ((== (firstByte X) (char "@")) V)
                     (T 0) ) )
               ((or (== X Y) (memq X Y)) V)
               (T 0) ) ) )
      (T
         (stkChk 0)
         (let Z (++ X)
            (if (== Z $Up)  # Expand expression
               (let V (eval (++ X))
                  (if (nil? V)
                     (if (fill2 X Y) @ X)
                     (save (setq Z V)
                        (if (atom V)
                           (safe (setq Z (setq V (cons V $Nil))))
                           (while (pair (cdr V))
                              (setq V @) ) )
                        (set 2 V
                           (if (fill2 X Y) @ X) )
                        Z ) ) )
               (cond
                  ((fill2 Z Y)
                     (save @
                        (cons @ (if (fill2 X Y) @ X)) ) )
                  ((fill2 X Y) (cons Z @))
                  (T 0) ) ) ) ) ) )

(de fill3 (X Y Z)
   (if (atom X)
      (if (== X Y) Z 0)
      (stkChk 0)
      (let A (++ X)
         (cond
            ((fill3 A Y Z)
               (save @
                  (cons @ (if (fill3 X Y Z) @ X)) ) )
            ((fill3 X Y Z) (cons A @))
            (T 0) ) ) ) )

# (fill 'any ['sym|lst]) -> any
# (fill 'any ['cnt|sym] 'any2) -> any
(de _Fill (Exe)
   (let
      (X (cdr Exe)
         Y (save (eval (++ X)))
         Z (save (eval (++ X))) )
      (if
         (if (pair X)
            (fill3 Y Z (save (eval (car X))))
            (fill2 Y Z) )
         @
         Y ) ) )

(local) ($Penv $Pnl unify lup lookup uniFill uniRun)

(var $Penv 0)
(var $Pnl 0)

(de i1 unify (N1 X1 N2 X2)
   (let Penv (val $Penv)
      (: 1
         (when (and (symb? X1) (== (firstByte X1) (char "@")))
            (let X (val Penv)
               (while (pair (car X))
                  (let (Y @  Z (car Y))
                     (when (and (== N1 (car Z)) (== X1 (cdr Z)))
                        (setq
                           Z (cdr Y)
                           N1 (car Z)
                           X1 (cdr Z) )
                        (goto 1) ) )
                  (shift X) ) ) ) )
      (: 2
         (when (and (symb? X2) (== (firstByte X2) (char "@")))
            (let X (val Penv)
               (while (pair (car X))
                  (let (Y @  Z (car Y))
                     (when (and (== N2 (car Z)) (== X2 (cdr Z)))
                        (setq
                           Z (cdr Y)
                           N2 (car Z)
                           X2 (cdr Z) )
                        (goto 2) ) )
                  (shift X) ) ) ) )
      (cond
         ((and (== N1 N2) (equal X1 X2)) YES)
         ((and (symb? X1) (== (firstByte X1) (char "@")))
            (unless (== X1 $At)
               (set Penv  # (((n1 . x1) . (n2 . x2)) . Penv)
                  (cons (cons3 N1 X1 N2 X2) (val Penv)) ) )
            YES )
         ((and (symb? X2) (== (firstByte X2) (char "@")))
            (unless (== X2 $At)
               (set Penv  # (((n2 . x2) . (n1 . x1)) . Penv)
                  (cons (cons3 N2 X2 N1 X1) (val Penv)) ) )
            YES )
         ((or (atom X1) (atom X2)) (equal X1 X2))
         (T
            (stkChk 0)
            (let Env (val Penv)
               (or
                  (and
                     (unify N1 (car X1) N2 (car X2))
                     (unify N1 (cdr X1) N2 (cdr X2)) )
                  (prog (set Penv Env) NO) ) ) ) ) ) )

(de lup (N X)
   (let Penv (val $Penv)
      (: 1
         (when (and (symb? X) (== (firstByte X) (char "@")))
            (let V (val Penv)
               (while (pair (car V))
                  (let (Y @  Z (car Y))
                     (when
                        (and
                           (== N (car Z))
                           (== X (cdr Z)) )
                        (setq
                           Z (cdr Y)
                           N (car Z)
                           X (cdr Z) )
                        (goto 1) ) )
                  (shift V) ) ) ) ) )
   (if
      (or
         (atom X)
         (cnt? (car X))
         (== @ $Up) )
      X
      (stkChk 0)
      (let Z (save (lup N (car X)))
         (cons Z (lup N (cdr X))) ) ) )

(de lookup (N X)
   (if
      (and
         (symb? (setq X (lup N X)))
         (== (firstByte X) (char "@")) )
      $Nil
      X ) )

(de uniFill (X)
   (cond
      ((num? X) X)
      ((sym? X)
         (lup (car (val (val $Pnl))) X) )
      (T
         (stkChk 0)
         (let Y (save (uniFill (car X)))
            (cons Y (uniFill (cdr X))) ) ) ) )

(de uniRun (Prg)
   (let (P (val $Bind)  Q P  Z Prg  Tos 0)
      (loop
         (until (atom (car Z))
            (let U Z  # Go left
               (setq Z @)  # Invert tree
               (set U Tos)
               (setq Tos U) ) )
         (let Y (car Z)
            (when
               (and
                  (symb? Y)
                  (<> -ZERO (val Y))
                  (== (firstByte Y) (char "@")) )
               (set $Bind (setq P (push (val Y) Y P)))
               (set Y -ZERO) ) )
         (loop
            (? (pair (cdr Z))  # Right subtree
               (let U Z  # Go right
                  (setq Z @)  # Invert tree
                  (set 2 U Tos)
                  (setq Tos (| U 8)) ) )
            (let Y @  # Dotted structure symbol?
               (when
                  (and
                     (symb? Y)
                     (<> -ZERO (val Y))
                     (== (firstByte Y) (char "@")) )
                  (set $Bind (setq P (push (val Y) Y P)))
                  (set Y -ZERO) ) )
            (loop
               (unless Tos
                  (let (X P  N (car (val (val $Pnl))))
                     (until (== Q X)
                        (let Y (val 2 X)
                           (set Y (lookup N Y)) )
                        (setq X (val 3 X)) ) )
                  (loop
                     (let X (++ Prg)
                        (when (atom Prg)
                           (setq X (eval X))
                           (until (== Q P)
                              (set (val 2 P) (val P))  # Restore values
                              (setq P (val 3 P)) )
                           (set $Bind P)
                           (ret X) )
                        (and (pair X) (evList X)) ) ) )
               (? (=0 (& Tos 8))  # Second visit
                  (let U Tos
                     (setq Tos (car U))  # TOS on up link
                     (set U Z)
                     (setq Z U) ) )
               (let U (& Tos -9)  # Set second visit
                  (setq Tos (cdr U))
                  (set 2 U Z)
                  (setq Z U) ) ) ) ) ) )

# (prove 'lst ['lst]) -> lst
(de _Prove (Exe)
   (let X (cdr Exe)
      (if (atom (eval (car X)))
         $Nil
         (let
            (Q (save @)
               Dbg (if (nil? (eval (cadr X))) 0 (save @))
               P (prog1 (caar Q) (set Q (cdar Q)))
               N (++ P)
               Nl (link (push (++ P) NIL))
               Alt (link (push (++ P) NIL))
               Tp1 (link (push (++ P) NIL))
               Tp2 (link (push (++ P) NIL))
               Env (link (push P NIL))
               E (link (push $Nil NIL))
               At (save (val $At))
               Penv (val $Penv)
               Pnl (val $Pnl) )
            (set $Penv Env  $Pnl Nl)
            (while (or (pair (val Tp1)) (pair (val Tp2)))
               (sigChk Exe)
               (cond
                  ((pair (val Alt))
                     (set E (val Env))
                     (ifn
                        (unify
                           (car (val Nl))
                           (cdar (val Tp1))
                           N
                           (caar (val Alt)) )
                        (when (atom (set Alt (cdr (val Alt))))
                           (setq P (caar Q))
                           (set Q (cdar Q))
                           (setq N (++ P))
                           (set
                              Nl (++ P)
                              Alt (++ P)
                              Tp1 (++ P)
                              Tp2 (++ P)
                              Env P ) )
                        (when Dbg
                           (let Y (car (val Tp1))
                              (when (memq (car Y) Dbg)
                                 (let (L (get (car Y) $T)  I 1)
                                    (until (equal (car (val Alt)) (car L))
                                       (inc 'I)
                                       (shift L) )
                                    (outWord I) )
                                 (space)
                                 (print (uniFill Y))
                                 (newline) ) ) )
                        (when (pair (cdr (val Alt)))
                           (set Q
                              (cons
                                 (cons N
                                    (cons (val Nl)
                                       (cons @
                                          (cons (val Tp1) (cons (val Tp2) (val E))) ) ) )
                                 (car Q) ) ) )
                        (set
                           Nl (cons N (val Nl))
                           Tp2 (cons (cdr (val Tp1)) (val Tp2))
                           Tp1 (cdar (val Alt))
                           Alt $Nil )
                        (inc 'N (hex "10")) ) )  # Increment
                  ((atom (setq X (val Tp1)))
                     (set
                        Tp1 (car (val Tp2))
                        Tp2 (cdr (val Tp2))
                        Nl (cdr (val Nl)) ) )
                  ((atom (car X))  # Cut operator
                     (while
                        (and
                           (pair (car Q))
                           (>= (caar @) (car (val Nl))) )
                        (set Q (cdar Q)) )
                     (set Tp1 (cdr X)) )
                  ((cnt? (car @))
                     (set E (uniRun (cdar X)))
                     (let (I (int (caar X))  Y (val Nl))
                        (while (gt0 (dec 'I))
                           (shift Y) )
                        (set
                           Nl (cons (car Y) (val Nl))
                           Tp2 (cons (cdr X) (val Tp2))
                           Tp1 (val E) ) ) )
                  ((== @ $Up)
                     (if
                        (and
                           (not
                              (nil? (set E (uniRun (cddr (car X))))) )
                           (unify
                              (car (val Nl))
                              (cadr (car X))
                              (car (val Nl))
                              (val E) ) )
                        (set Tp1 (cdr X))
                        (setq P (caar Q))
                        (set Q (cdar Q))
                        (setq N (++ P))
                        (set
                           Nl (++ P)
                           Alt (++ P)
                           Tp1 (++ P)
                           Tp2 (++ P)
                           Env P ) ) )
                  ((atom (set Alt (get (caar X) $T)))
                     (setq P (caar Q))
                     (set Q (cdar Q))
                     (setq N (++ P))
                     (set
                        Nl (++ P)
                        Alt (++ P)
                        Tp1 (++ P)
                        Tp2 (++ P)
                        Env P ) ) ) )
            (set E $Nil)
            (let Y (val Env)
               (while (pair (cdr Y))
                  (let Z (caar Y)
                     (when (== (car Z) ZERO)
                        (set E
                           (cons
                              (cons (shift Z) (lookup ZERO Z))
                              (val E) ) ) ) )
                  (shift Y) ) )
            (set $Pnl Pnl  $Penv Penv  $At At)
            (cond
               ((pair (val E)) @)
               ((pair (val Env)) $T)
               (T $Nil) ) ) ) ) )

# (-> any [cnt]) -> any
(de _Arrow (Exe)
   (let (X (cdr Exe)  L (val (val $Pnl)))
      (when (cnt? (cadr X))
         (let I (int @)
            (while (gt0 (dec 'I))
               (shift L) ) ) )
      (lookup (car L) (car X)) ) )

# (unify 'any) -> lst
# (unify 'cnt) -> cnt
(de _Unify (Exe)
   (let
      (X (eval (cadr Exe))
         Pnl (val (val $Pnl))
         N (car Pnl) )
      (ifn (cnt? X)
         (save X
            (if (unify (cadr Pnl) X N X)
               (val (val $Penv))
               $Nil ) )
         (let (I (int @)  Penv (val (val $Penv)))
            (while (gt0 (dec 'I))
               (shift Pnl) )
            (let M (car Pnl)
               (while (pair (car Penv))
                  (let Y (car @)
                     (when (== (car Y) M)
                        (let S (cdr Y)
                           (unify M S N S) ) ) )
                  (shift Penv) ) )
            X ) ) ) )

# (group 'lst) -> lst
(de _Group (Exe)
   (let X (save (eval (cadr Exe)))
      (if (atom X)
         $Nil
         (let Y (cons (cdar X) $Nil)
            (setq Y
               (cons (cons (caar X) (cons Y Y)) $Nil) )
            (let R (save Y)
               (while (pair (shift X))
                  (let (L (car X)  K (car L))
                     (setq Y (cons (cdr L) $Nil))
                     (let Z R
                        (loop
                           (let V (car Z)
                              (? (equal K (car V))
                                 (set
                                    (shift V)
                                    (set 2 (car V) Y) ) )
                              (? (atom (cdr Z))
                                 (set 2 Z
                                    (cons (cons K (cons Y Y)) $Nil) ) )
                              (setq Z @) ) ) ) ) )
               (let Z R
                  (loop
                     (let V (car Z)
                        (set 2 V (cddr V)) )
                     (? (atom (shift Z))) ) )
               R ) ) ) ) )

(local) cmpSort

(inline (E A B) cmpSort (X Y)
   (set 4 A X  4 B Y)
   (if (nil? (evList E)) 0 -1) )

# (sort 'lst ['fun]) -> lst
(de _Sort (Exe)
   (let (X (cdr Exe)  Y (eval (++ X)))
      (cond
         ((atom Y) @)
         ((atom X)
            (let (Out0 Y  Out1 $Nil)
               (loop
                  (let (In0 Out0  In1 Out1  P)
                     (if
                        (and
                           (pair In1)
                           (ge0 (compare (car In0) (car In1))) )
                        (setq In1 (cdr (setq P In1)))
                        (setq In0 (cdr (setq P In0))) )
                     (let (Tail0 (ofs P 1)  Tail1 0  Last (car P))
                        (setq Out0 P  Out1 $Nil)
                        (set 2 P $Nil)
                        (while (or (pair In0) (pair In1))
                           (cond
                              ((atom In1)
                                 (setq In0 (cdr (setq P In0)))
                                 (when (lt0 (compare (car P) Last))
                                    (xchg 'Tail0 'Tail1) ) )
                              ((atom In0)
                                 (setq In1 (cdr (setq P In1)))
                                 (when (lt0 (compare (car P) Last))
                                    (xchg 'Tail0 'Tail1) ) )
                              ((lt0 (compare (car In0) Last))
                                 (if (ge0 (compare (car In1) Last))
                                    (setq In1 (cdr (setq P In1)))
                                    (if (lt0 (compare (car In0) (car In1)))
                                       (setq In0 (cdr (setq P In0)))
                                       (setq In1 (cdr (setq P In1))) )
                                    (xchg 'Tail0 'Tail1) ) )
                              ((lt0 (compare (car In1) Last))
                                 (setq In0 (cdr (setq P In0))) )
                              ((lt0 (compare (car In0) (car In1)))
                                 (setq In0 (cdr (setq P In0))) )
                              (T (setq In1 (cdr (setq P In1)))) )
                           (setq Tail0
                              (ofs
                                 (if Tail0
                                    (set Tail0 P)
                                    (setq Out1 P) )
                                 1 ) )
                           (set 2 P $Nil)
                           (setq Last (car P)) ) ) )
                  (? (atom Out1) Out0) ) ) )
         (T
            (let
               (Out0 (link (push Y NIL) T)
                  Out1 (link (push $Nil NIL))
                  In0 (link (push -ZERO NIL))
                  In1 (link (push -ZERO NIL))
                  P (link (push -ZERO NIL))
                  B (push NIL $Nil ZERO NIL NIL)  # [car cdr name arg2 link]
                  A (push NIL B ZERO NIL NIL)  # [car cdr name arg1 link]
                  E (push NIL A ZERO (eval (car X)) NIL) )  # [car cdr name fun link]
               (set
                  B (link (ofs B 3))
                  A (link (ofs A 3))
                  E (link (ofs E 3)) )
               (loop
                  (set In0 (val Out0)  In1 (val Out1))
                  (if
                     (and
                        (pair (val In1))
                        (ge0 (cmpSort (caar In0) (caar In1))) )
                     (set In1 (cdr (set P (val In1))))
                     (set In0 (cdr (set P (val In0)))) )
                  (let (Tail0 (ofs (val P) 1)  Tail1 0  Last (caar P))
                     (set Out0 (val P)  Out1 $Nil)
                     (set 2 (val P) $Nil)
                     (while (or (pair (val In0)) (pair (val In1)))
                        (cond
                           ((atom (val In1))
                              (set In0 (cdr (set P (val In0))))
                              (when (lt0 (cmpSort (caar P) Last))
                                 (xchg 'Tail0 'Tail1) ) )
                           ((atom (val In0))
                              (set In1 (cdr (set P (val In1))))
                              (when (lt0 (cmpSort (caar P) Last))
                                 (xchg 'Tail0 'Tail1) ) )
                           ((lt0 (cmpSort (caar In0) Last))
                              (if (ge0 (cmpSort (caar In1) Last))
                                 (set In1 (cdr (set P (val In1))))
                                 (if (lt0 (cmpSort (caar In0) (caar In1)))
                                    (set In0 (cdr (set P (val In0))))
                                    (set In1 (cdr (set P (val In1)))) )
                                 (xchg 'Tail0 'Tail1) ) )
                           ((lt0 (cmpSort (caar In1) Last))
                              (set In0 (cdr (set P (val In0)))) )
                           ((lt0 (cmpSort (caar In0) (caar In1)))
                              (set In0 (cdr (set P (val In0)))) )
                           (T (set In1 (cdr (set P (val In1))))) )
                        (setq Tail0
                           (ofs
                              (if Tail0
                                 (set Tail0 (val P))
                                 (set Out1 (val P)) )
                              1 ) )
                        (set 2 (val P) $Nil)
                        (setq Last (caar P)) ) )
                  (? (atom (val Out1)) (val Out0)) ) ) ) ) ) )
pil21/src/pico.h0000644000000000000000000000267214224260222010570 0ustar  // 09apr22 Software Lab. Alexander Burger

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

typedef void (*sighandler_t)(int);

// Lisp data access
typedef uint64_t any;

#define cnt(x) ((x) & 2)
#define num(x) ((x) & 6)
#define sym(x) ((x) & 8)
#define sign(x) ((x) & 8)
#define atom(x) ((x) & 15)

#define car(x) (*(uint64_t*)(x))
#define cdr(x) (*(uint64_t*)((x) + 8))
#define set(p,x) (*(uint64_t*)(p) = (x))
#define val(x) (*(uint64_t*)(x))
#define dig(x) ((x) - 4)
#define big(x) ((x) + 4)
#define tail(x) ((x) - 8)

any name(any);
any number(any);
any length(any);
any box64(any);

extern uint64_t SymTab[];
#define Nil (0+1)
// Sync src/glob.l 'T'
#define T (17*2+1)
#define N (18*2+1)
#define C (19*2+1)
#define S (20*2+1)
#define B (21*2+1)
#define I (22*2+1)
#define P (23*2+1)
#define W (24*2+1)

uint64_t boxNum(uint64_t);
int32_t bufSize(uint64_t);
char *bufString(uint64_t, char*);
uint64_t natBuf(uint64_t, char*);
uint64_t natRetBuf(uint64_t, char**);

void argErr(uint64_t, uint64_t) __attribute__ ((noreturn));
void err(uint64_t, uint64_t, char*, char*) __attribute__ ((noreturn));
pil21/src/lib.c0000644000000000000000000023736614603277174010430 0ustar  // 03apr24 Software Lab. Alexander Burger

#include "pico.h"

const char TgOS[] = _OS;
const char TgCPU[] = _CPU;

// I/O
const int32_t PipeBufSize = PIPE_BUF;

char *stderrMsg(char *fmt, char *s) {
   fprintf(stderr, fmt, s);
   return s;
}

void gPrintf(char *buf, int32_t siz, char *fmt, char *arg) {
   if (snprintf(buf, siz, fmt, arg) >= siz)
      fprintf(stderr, "!! gPrintf() truncated !!\n");
}

char *strErrno(void) {
   return strerror(errno);
}

int32_t openRd(char *nm) {
   return (int32_t)open(nm, O_RDONLY);
}

int32_t openWr(char *nm) {
   return (int32_t)open(nm, O_CREAT|O_TRUNC|O_WRONLY, 0666);
}

int32_t openRdWr(char *nm) {
   return (int32_t)open(nm, O_RDWR);
}

int32_t openRdWrExcl(char *nm) {
   return (int32_t)open(nm, O_CREAT|O_EXCL|O_RDWR, 0666);
}

int32_t openRdWrCreate(char *nm) {
   return (int32_t)open(nm, O_CREAT|O_RDWR, 0666);
}

int32_t openRdWrAppend(char *nm) {
   return (int32_t)open(nm, O_APPEND|O_CREAT|O_RDWR, 0666);
}

int32_t openWrAppend(char *nm) {
   return (int32_t)open(nm, O_APPEND|O_CREAT|O_WRONLY, 0666);
}

int fseekOfs(FILE *fp, int32_t ofs) {
   return fseek(fp, (long)ofs, SEEK_CUR) == 0;
}

int fseek0(FILE *fp) {
   return fseek(fp, 0L, SEEK_SET) == 0;
}

int seek0(int32_t fd) {
   return lseek(fd, 0L, SEEK_SET) == 0;
}

int truncate0(int32_t fd) {
   return ftruncate(fd, 0) == 0;
}

int32_t socketPair(int32_t *sv) {
   return (int32_t)socketpair(AF_UNIX, SOCK_STREAM, 0, sv);
}

int32_t fcntlCloExec(int32_t fd) {
   return (int32_t)fcntl(fd, F_SETFD, FD_CLOEXEC);
}

void fcntlSetFl(int32_t fd, int32_t flg) {
   fcntl(fd, F_SETFL, flg);
}

int32_t nonBlocking(int32_t fd) {
   int flg = fcntl(fd, F_GETFL, 0);

   fcntlSetFl(fd, flg | O_NONBLOCK);
   return (int32_t)flg;
}

void fcntlSetOwn(int32_t fd, int32_t pid) {
   fcntl(fd, F_SETOWN, pid);
   fcntlSetFl(fd, fcntl(fd, F_GETFL, 0) | O_NONBLOCK|O_ASYNC);
}

char *getDir(char *nm) {
   static DIR *dp;
   struct dirent *p;

   if (nm  &&  (dp = opendir(nm)) == NULL)
      return NULL;
   if ((p = readdir(dp)) != NULL)
      return p->d_name;
   closedir(dp);
   return NULL;
}

// Readline
#include 
#include 

static char *tabEntry(const char *text, int stat) {
   extern char *tabComplete(const char*);

   rl_completion_append_character = '\0';
   return tabComplete(stat? NULL : text);
}

void initReadline(void) {
   extern int rlGetc(FILE*);
   extern int rlAvail(void);

   rl_catch_signals = 0;
   rl_getc_function = rlGetc;
   rl_input_available_hook = rlAvail;
   rl_completion_entry_function = tabEntry;
   rl_special_prefixes = "$%&*+-<=>?@";
   rl_basic_quote_characters = NULL;
}

char *gReadline(const char *prompt) {
   int e = errno;
   char *p = readline(prompt);

   errno = e;
   return p;
}

void rlHide(void) {
   if (rl_readline_state & RL_STATE_INITIALIZED  &&  !(rl_readline_state & RL_STATE_DONE)) {
      rl_clear_visible_line();
      fflush(stdout);
   }
}

void rlShow(void) {
   if (rl_readline_state & RL_STATE_INITIALIZED  &&  !(rl_readline_state & RL_STATE_DONE))
      rl_forced_update_display();
}

void rlSigBeg(void) {
   if (rl_readline_state & RL_STATE_INITIALIZED) {
      rl_save_prompt();
      rl_free_line_state();
      rl_cleanup_after_signal();
   }
}

void rlSigEnd(void) {
   if (rl_readline_state & RL_STATE_SIGHANDLER) {
      rl_reset_after_signal();
      rl_restore_prompt();
   }
}

char *currentLine(void) {
   HIST_ENTRY *h;

   return (h = history_get(history_length))? h->line : NULL;
}

// Signals
const int32_t Sig[] = {
   SIGHUP, SIGINT, SIGUSR1, SIGUSR2, SIGPIPE, SIGALRM, SIGTERM, SIGCHLD,
   SIGCONT, SIGSTOP, SIGTSTP, SIGTTIN, SIGTTOU, SIGWINCH, SIGIO
};

const sighandler_t SigDfl = SIG_DFL;
const sighandler_t SigIgn = SIG_IGN;

// Sync src/defs.l 'SIGHUP' and src/glob.l '$Signal'
int32_t gSignal(int32_t n) {
   switch (n) {
   case SIGHUP:   return 1;
   case SIGINT:   return 2;
   case SIGUSR1:  return 3;
   case SIGUSR2:  return 4;
   case SIGPIPE:  return 5;
   case SIGALRM:  return 6;
   case SIGTERM:  return 7;
   case SIGCHLD:  return 8;
   case SIGCONT:  return 9;
   case SIGSTOP:  return 10;
   case SIGTSTP:  return 11;
   case SIGTTIN:  return 12;
   case SIGTTOU:  return 13;
   case SIGWINCH: return 14;
   case SIGIO:    return 15;
   }
   return 0;
}

void iSignal(int32_t n, void (*fun)(int)) {
   struct sigaction act;

   act.sa_handler = fun;
   sigemptyset(&act.sa_mask);
   act.sa_flags = 0;
   sigaction((int)n, &act, NULL);
}

void sigUnblock(int32_t sig) {
   sigset_t mask;

   if (sig == 0)
      sigfillset(&mask);
   else {
      sigemptyset(&mask);
      sigaddset(&mask, (int)sig);
   }
   sigprocmask(SIG_UNBLOCK, &mask, NULL);
}

void sigChld(int n __attribute__((unused))) {
   int e, stat;
   pid_t pid;

   e = errno;
   while ((pid = waitpid(0, &stat, WNOHANG)) > 0)
      if (WIFSIGNALED(stat))
         fprintf(stderr, "%d SIG-%d\n", (int)pid, WTERMSIG(stat));
   errno = e;
}

int32_t waitWuntraced(int32_t pid, int32_t *res) {
   return waitpid((pid_t)pid, (int*)res, WUNTRACED);
}

int32_t wifStopped(int32_t *res) {
   return WIFSTOPPED(*(int*)res);
}

int32_t nErrno(void) {
   return errno;
}

// Sync src/defs.l 'ENOENT'
int32_t gErrno(void) {
   switch (errno) {
   case ENOENT:     return 1;
   case EINTR:      return 2;
   case EBADF:      return 3;
   case EAGAIN:     return 4;
   case EACCES:     return 5;
   case EPIPE:      return 6;
   case ECONNRESET: return 7;
   }
   return 0;
}

// Terminal
char Tio;
struct termios OrgTermio;
struct termios *Termio;

static void tcSet(struct termios *p) {
   while (tcsetattr(STDIN_FILENO, TCSADRAIN, p)  &&  errno == EINTR);
}

void stopTerm(void) {
   sigset_t mask;

   if (Tio) {
      sigUnblock(SIGTSTP);
      signal(SIGTSTP, SIG_DFL),  raise(SIGTSTP);
      if (Termio)
         tcSet(Termio);
      else
         tcSet(&OrgTermio);
   }
}

void setRaw(void) {
   if (Tio && !Termio) {
      *(Termio = malloc(sizeof(struct termios))) = OrgTermio;
      tcgetattr(STDIN_FILENO, Termio);
      Termio->c_iflag = 0;
      Termio->c_lflag = ISIG;
      Termio->c_cc[VMIN] = 1;
      Termio->c_cc[VTIME] = 0;
      tcSet(Termio);
   }
}

void setCooked(void) {
   if (Termio) {
      tcSet(&OrgTermio);
      free(Termio),  Termio = NULL;
   }
}

int reopenTty(char* tty) {
   return
      freopen(tty, "r", stdin) != NULL  &&
      freopen(tty, "w", stdout) != NULL  &&
      freopen(tty, "w", stderr) != NULL;
}

// System
static struct timeval Tv;
static struct tm *Time;

int64_t getUsec(int flg) {
   if (flg) {
      struct timeval tim;

      if (gettimeofday(&tim, NULL))
         return 0;
      return (int64_t)tim.tv_sec * 1000000 + (int64_t)tim.tv_usec;
   }
   return (int64_t)Tv.tv_usec;
}

int64_t getMsec(void) {
   struct timeval tim;

   if (gettimeofday(&tim, NULL))
      return 0;
   return (int64_t)tim.tv_sec * 1000 + ((int64_t)tim.tv_usec + 500) / 1000;
}

int64_t getDate(void) {
   if (gettimeofday(&Tv, NULL))
      return 0;
   Time = localtime(&Tv.tv_sec);
   return Time->tm_year+1900 | (Time->tm_mon+1) << 16 | Time->tm_mday << 24;
}

int64_t getGmDate(void) {
   if (gettimeofday(&Tv, NULL))
      return 0;
   Time = gmtime(&Tv.tv_sec);
   return Time->tm_year+1900 | (Time->tm_mon+1) << 16 | Time->tm_mday << 24;
}

int64_t getTime(void) {
   struct tm *p;

   if (gettimeofday(&Tv, NULL))
      return 0;
   p = localtime(&Tv.tv_sec);
   return p->tm_hour * 3600 + p->tm_min * 60 + p->tm_sec;
}

int64_t getGmTime(void) {
   return Time? (Time->tm_hour * 3600 + Time->tm_min * 60 + Time->tm_sec) : -1;
}

char *ulimStk(void) {
   struct rlimit stk;

   if (getrlimit(RLIMIT_STACK, &stk) < 0)
      return NULL;
   if (stk.rlim_cur == RLIM_INFINITY)
      return (char*)1;
   return (char*)&stk - stk.rlim_cur + 16384;
}

int64_t fileInfo(int lnk, int loc, char *nm, int64_t *siz) {
   int64_t n;
   struct tm *p;
   struct stat st;

   if ((lnk? stat(nm, &st) : lstat(nm, &st)) < 0)
      return -1;
   p = loc? localtime(&st.st_mtime) : gmtime(&st.st_mtime);
   n = (p->tm_year+1900 | (p->tm_mon+1) << 16 | p->tm_mday << 24 |
         (int64_t)(p->tm_hour * 3600 + p->tm_min * 60 + p->tm_sec) << 32 ) << 2;
   if ((st.st_mode & S_IFMT) == S_IFDIR)
      return n + 1;
   if ((st.st_mode & S_IFMT) != S_IFREG)
      return n + 2;
   *siz = st.st_size;
   return n;
}

// Polling
void pollIn(int32_t fd, struct pollfd *p) {
   p->fd = fd;
   p->events = POLLIN;
}

void pollOut(int32_t fd, struct pollfd *p) {
   p->fd = fd;
   p->events = POLLOUT;
}

void pollIgn(struct pollfd *p) {
   p->fd = -1;
}

int32_t gPoll(struct pollfd *fds, int32_t nfds, int64_t timeout) {
#ifdef __linux__
   struct timespec ts, *tp;
   extern int ppoll(struct pollfd *fds, nfds_t nfds, const struct timespec *tmo_p, const sigset_t *sigmask);

   if (timeout == 9223372036854775807) {  // 292MY
      int i = nfds;
      do
         if (--i < 0)
            return 0;
      while (fds[i].fd < 0);
      tp = NULL;
   }
   else {
      ts.tv_sec = timeout / 1000;
      ts.tv_nsec = timeout % 1000 * 1000000;
      tp = &ts;
   }
   return (int32_t)ppoll(fds, (nfds_t)nfds, tp, NULL);
#else
   int to;

   if (timeout > 2147483647) {  // Fit into 32 bits (max 24 days)
      int i = nfds;
      do
         if (--i < 0)
            return 0;
      while (fds[i].fd < 0);
      to = -1;
   }
   else
      to = (int)timeout;
   return (int32_t)poll(fds, (nfds_t)nfds, to);
#endif
}

int readyIn(struct pollfd *p) {
   if (p->fd < 0)
      return 0;
   p->fd = -1;
   return (p->revents & (POLLIN | POLLHUP | POLLERR | POLLNVAL)) != 0;
}

int readyOut(struct pollfd *p) {
   if (p->fd < 0)
      return 0;
   p->fd = -1;
   return (p->revents & POLLOUT | POLLERR | POLLNVAL) != 0;
}

// Locking
int32_t rdLock(int32_t fd, off_t n, off_t len, int wait) {
   struct flock fl;

   fl.l_type = F_RDLCK;
   fl.l_whence = SEEK_SET;
   fl.l_start = n;
   fl.l_len = len;
   return (int32_t)fcntl(fd, wait? F_SETLKW : F_SETLK, &fl);
}

int32_t wrLock(int32_t fd, off_t n, off_t len, int wait) {
   struct flock fl;

   fl.l_type = F_WRLCK;
   fl.l_whence = SEEK_SET;
   fl.l_start = n;
   fl.l_len = len;
   return (int32_t)fcntl(fd, wait? F_SETLKW : F_SETLK, &fl);
}

int32_t unLock(int32_t fd, off_t n, off_t len) {
   struct flock fl;

   fl.l_type = F_UNLCK;
   fl.l_whence = SEEK_SET;
   fl.l_start = n;
   fl.l_len = len;
   return (int32_t)fcntl(fd, F_SETLK, &fl);
}

int32_t getLock(int32_t fd, off_t n, off_t len) {
   struct flock fl;

   fl.l_type = F_WRLCK;
   fl.l_whence = SEEK_SET;
   fl.l_start = n;
   fl.l_len = len;
   if (fcntl(fd, F_GETLK, &fl) < 0)
      return -1;
   return fl.l_type == F_UNLCK? 0 : fl.l_pid;
}

// Catch and Throw
const int64_t JmpBufSize = sizeof(jmp_buf);
jmp_buf QuitRst;

// Lisp data access from C
any name(any x) {
   while (!num(x))
      x = cdr(x);
   return x;
}

any number(any x) {
   any n = cnt(x)? x >> 4 : val(dig(x));
   return sign(x)? -n : n;
}

any length(any x) {
   int n = 0;

   while (!atom(x))
      ++n,  x = cdr(x);
   return (int32_t)n;
}

any box64(any x) {
   return x & 0xF000000000000000? boxNum(x) : x << 4 | 2;
}

// Native library interface
#define FMAX ((float)UINT64_MAX)
#define DMAX ((double)UINT64_MAX)

char Fsign;
uint64_t Fdigit;

static union {
   float f;
   double d;
} Fval;

uint64_t boxFloat(uint32_t value, int64_t scl) {
   float f = *(float*)&value * (float)scl;

   if (isnan(f) || isinf(f) < 0)
      return (uint64_t)(SymTab + Nil);
   if (isinf(f) > 0)
      return (uint64_t)(SymTab + T);
   Fsign = 0;
   if (f < 0.0)
      Fsign = 1,  f = -f;
   f += 0.5;
   if (f < FMAX)
      return box64((uint64_t)f);
   Fdigit = (uint64_t)fmod(f, FMAX);
   Fval.f = f / FMAX;
   return 0;
}

uint64_t boxFlt(void) {
   if (Fval.f < FMAX)
      return box64((uint64_t)Fval.f);
   Fdigit = (uint64_t)fmod(Fval.f, FMAX);
   Fval.f /= FMAX;
   return 0;
}

uint64_t boxDouble(uint64_t value, int64_t scl) {
   double d = *(double*)&value * (double)scl;

   if (isnan(d) || isinf(d) < 0)
      return (uint64_t)(SymTab + Nil);
   if (isinf(d) > 0)
      return (uint64_t)(SymTab + T);
   Fsign = 0;
   if (d < 0.0)
      Fsign = 1,  d = -d;
   d += 0.5;
   if (d < DMAX)
      return box64((uint64_t)d);
   Fdigit = (uint64_t)fmod(d, DMAX);
   Fval.d = d / DMAX;
   return 0;
}

uint64_t boxDbl(void) {
   if (Fval.d < DMAX)
      return box64((uint64_t)Fval.d);
   Fdigit = (uint64_t)fmod(Fval.d, DMAX);
   Fval.d /= DMAX;
   return 0;
}

void bufFloat(uint64_t value, int64_t scl, char *p) {
   float f, m;
   uint64_t x;

   if (cnt(value))
      f = (float)(value >> 4);
   else {
      f = (float)val(dig(x = value)),  m = FMAX;
      while (!cnt(x = val(big(x))))
         f += m * (float)val(dig(x)),  m *= FMAX;
      f += m * (float)(x >> 4);
   }
   f /= (float)scl;
   *(float*)p = sign(value)? -f : f;
}

void bufDouble(uint64_t value, int64_t scl, char *p) {
   double d, m;
   uint64_t x;

   if (cnt(value))
      d = (double)(value >> 4);
   else {
      d = (double)val(dig(x = value)),  m = DMAX;
      while (!cnt(x = val(big(x))))
         d += m * (double)val(dig(x)),  m *= DMAX;
      d += m * (double)(x >> 4);
   }
   d /= (double)scl;
   *(double*)p = sign(value)? -d : d;
}

#define _GNU_SOURCE
#define __USE_GNU
#include 

#include 

typedef struct ffi {
   ffi_cif cif;
   void (*fun)(void);
   ffi_type *args[0];
} ffi;

void *dlOpen(char *lib) {
   return dlopen(lib, RTLD_LAZY | RTLD_GLOBAL);
}

ffi *ffiPrep(char *lib, char *fun, uint64_t lst) {
   uint64_t x = car(lst);
   uint64_t y = cdr(lst);
   int i, nargs = length(y);
   ffi *p = malloc(sizeof(ffi) + nargs * sizeof(ffi_type*));
   ffi_type *rtype;

   if (x == (uint64_t)(SymTab + Nil))
      rtype = &ffi_type_void;
   else if (x == (uint64_t)(SymTab + T))
      rtype = &ffi_type_sint64;
   else if (x == (uint64_t)(SymTab + N))
      rtype = &ffi_type_sint64;
   else if (x == (uint64_t)(SymTab + P))
      rtype = &ffi_type_uint64;
   else if (x == (uint64_t)(SymTab + I))
      rtype = &ffi_type_sint32;
   else if (x == (uint64_t)(SymTab + C))
      rtype = &ffi_type_uint32;
   else if (x == (uint64_t)(SymTab + W))
      rtype = &ffi_type_sint16;
   else if (x == (uint64_t)(SymTab + B))
      rtype = &ffi_type_uint8;
   else if (cnt(x))
      rtype = (x & 8)? &ffi_type_float : &ffi_type_double;
   else
      rtype = &ffi_type_pointer;
   for (i = 0; i < nargs; ++i, y = cdr(y)) {
      x  = car(y);
      if (num(x))
         p->args[i] = &ffi_type_sint64;
      else if (sym(x) || car(x) == (uint64_t)(SymTab + T))
         p->args[i] = &ffi_type_pointer;
      else if (cnt(cdr(x)))
         p->args[i] = (cdr(x) & 8)? &ffi_type_float : &ffi_type_double;
      else
         p->args[i] = &ffi_type_pointer;
   }
   if (ffi_prep_cif(&p->cif, FFI_DEFAULT_ABI, nargs, rtype, p->args) == FFI_OK  &&
         (p->fun = dlsym(lib ?: RTLD_DEFAULT, fun)) )
      return p;
   free(p);
   return NULL;
}

uint64_t ffiCall(ffi *p, uint64_t lst) {
   uint64_t x, y, z;
   int i, nargs = length(lst);
   uint64_t value[nargs];
   void *ptr[nargs];
   uint64_t rc;

   for (i = 0, z = lst;  i < nargs;  ++i, z = cdr(z)) {
      x  = car(z);
      ptr[i] = &value[i];
      if (num(x))  // Number
         value[i] = number(x);
      else if (sym(x)) {  // String
         if (x == (uint64_t)(SymTab + Nil))
            value[i] = (uint64_t)"";
         else {
            uint64_t nm = name(val(tail(x)));
            bufString(nm, (char*)(value[i] = (uint64_t)alloca(bufSize(nm))));
         }
      }
      else if (car(x) == (uint64_t)(SymTab + T))  // Direct Lisp value
         value[i] = cdr(x);
      else if (cnt(y = cdr(x))) {  // Fixpoint
         if (y & 8)
            bufFloat(car(x), y >> 4, &value[i]);
         else
            bufDouble(car(x), y >> 4, &value[i]);
      }
      else if (!atom(y)) {  // Structure
         int64_t d, n = car(car(y)) >> 4;
         char *q = alloca(n);

         value[i] = (uint64_t)q;
         for (;;) {
            if (cnt(y = cdr(y))) {
               char b = y >> 4;  // Byte value

               while (--n >= 0)
                  *q++ = b;
               break;
            }
            if (atom(y))
               break;
            if (n <= 0)
               err(0, 0, "Init oversize", NULL);
            d = natBuf(car(y), q);
            n -= d, q += d;
         }
      }
      else
         argErr(0, x);
   }
   ffi_call(&p->cif, p->fun, &rc, ptr);
   for (i = 0;  i < nargs;  ++i, lst = cdr(lst)) {
      x = car(lst);
      if (!atom(x)  &&  !num(y = cdr(x))  &&  (z = car(x)) != (uint64_t)(SymTab + Nil)  &&  z != (uint64_t)(SymTab + T))
         set(z, natRetBuf(cdr(car(y)), (char**)&value[i]));
   }
   return rc;
}

void *arg(void *p) {
   return p;
}

// Util
int chance(int64_t m) {
   static uint32_t seed = 1664525;

   return (((seed = seed * 1664525 + 1) >> 16) & (int32_t)m) != 0;
}


// Case mappings from the GNU Kaffe Project
#define CHAR_UPPERCASE  1
#define CHAR_LOWERCASE  2
#define CHAR_LETTER    62
#define CHAR_DIGIT    512

static uint16_t Blocks[] = {
   0x1C2, 0x1C2, 0x1C1, 0x12C, 0x12B, 0x1A0, 0x1F8, 0x2DC, 0x25F, 0x2EE, 0x215, 0x346, 0x2DC, 0x326, 0x2BC, 0x216,
   0x15F, 0x2D4, 0x376, 0x376, 0x376, 0x369, 0xFE8F, 0x344, 0xFF85, 0xFF65, 0xFDB5, 0xFDA1, 0x1B, 0x2C4, 0x1C, 0x47,
   0xFEA8, 0xFF8C, 0x235, 0xFEFF, 0x1A, 0xFEBF, 0x26, 0xFB20, 0xFE28, 0x113, 0x104, 0xFB61, 0xFB5A, 0x10B, 0x109, 0xFE,
   0xFF08, 0x229, 0x25E, 0x1C7, 0x1FC, 0x1DC, 0xFC46, 0x229, 0xFE27, 0xFB55, 0x169, 0xFBC8, 0xFC, 0x103, 0xFB68, 0xFB48,
   0xFB28, 0xFB08, 0xFAE8, 0xFAC8, 0xFAA8, 0xFA88, 0xFA68, 0xFA48, 0x65, 0x50, 0xAB, 0x139, 0xFE0E, 0x63, 0x155, 0x1A8,
   0xF669, 0x129, 0x128, 0xF91F, 0xFE56, 0x108, 0x107, 0xFAC0, 0xFC8E, 0xFEAD, 0xC6, 0xFCA7, 0xFB95, 0xF47D, 0x9F, 0xFB17,
   0xFE20, 0xFD28, 0xFB2F, 0x3B, 0xF3B9, 0xFE57, 0xFCCE, 0xFFBB, 0xF339, 0xFA98, 0xFF8B, 0xFF3B, 0xFA54, 0xF7E3, 0xFF2B, 0xFAD7,
   0xFB69, 0xFC3A, 0xFEE5, 0xF4C8, 0xFCB0, 0xFA88, 0xFDBF, 0xF448, 0xFE45, 0xFCC7, 0xFE4F, 0xF7F1, 0xF715, 0xF2E8, 0xFD9F, 0xF348,
   0xF96A, 0xFC02, 0xFD97, 0xF2C8, 0xF2A8, 0xF4B9, 0xF4B3, 0xEF6B, 0xF86A, 0xF84A, 0xFC58, 0xF80A, 0xF7EA, 0xFC0F, 0xF7AA, 0xEE9C,
   0xFB90, 0xF74A, 0xF7FA, 0xF70A, 0xF7CA, 0xF792, 0xF471, 0xF4D2, 0xF732, 0xF64A, 0xF401, 0xF64D, 0xEFA8, 0xF5CA, 0xF5AA, 0xECA1,
   0xF569, 0xF54A, 0xF52A, 0xF50A, 0xF4EA, 0xF4CA, 0xF4AA, 0xF48A, 0xF46A, 0xF44A, 0xF42A, 0xF40A, 0xF3EA, 0xF3CA, 0xF3AA, 0xF38A,
   0xF36A, 0xF34A, 0xF32A, 0xF289, 0xF777, 0xF2CA, 0xF2AA, 0xF737, 0xEC28, 0xEC08, 0xEBE8, 0xEBC8, 0xF1EA, 0xF4A2, 0xF545, 0xEDC6,
   0xF2D7, 0xF14A, 0xE8ED, 0xE81E, 0xF0EA, 0xF597, 0xEA68, 0xEA48, 0xEA28, 0xEA08, 0xE9E8, 0xE9C8, 0xE9A8, 0xE988, 0xE968, 0xE948,
   0xE928, 0xE908, 0xE8E8, 0xE8C8, 0xE8A8, 0xE888, 0xE868, 0xE848, 0xE828, 0xE808, 0xE7E8, 0xE7C8, 0xE7A8, 0xE788, 0xE768, 0xE748,
   0xE728, 0xE708, 0xE6E8, 0xE6C8, 0xE6A8, 0xE688, 0xE668, 0xE648, 0xE628, 0xE608, 0xE5E8, 0xE5C8, 0xE5A8, 0xE588, 0xE568, 0xE548,
   0xE55F, 0xE53F, 0xE51F, 0xE4FF, 0xEFD7, 0xE4BF, 0xE49F, 0xE485, 0xEF87, 0xEF57, 0xEF57, 0xEF57, 0xEF57, 0xEF47, 0xE1AD, 0xEF46,
   0xEF46, 0xEF46, 0xE1E0, 0xE3DD, 0xEF06, 0xE9D9, 0xEBEB, 0xE244, 0xEED4, 0xEF65, 0xE1F5, 0xEF45, 0xEEE9, 0xEF7C, 0xEE74, 0xEF70,
   0xEF7D, 0xEF78, 0xEE91, 0xEFD3, 0xEE7D, 0xEE25, 0xEE27, 0xEF65, 0xEFDD, 0xEE96, 0xEFD3, 0xEFE1, 0xEF69, 0xDF88, 0xDF68, 0xDF48,
   0xED2B, 0xED3D, 0xED19, 0xEF1C, 0xEF08, 0xED47, 0xED3D, 0xED33, 0xEC2B, 0xEC0B, 0xEBEB, 0xEBCB, 0xEBCE, 0xEA7C, 0xEB69, 0xEB6C,
   0xE9B6, 0xEB0B, 0xEAEB, 0xE9E9, 0xDCA8, 0xDC88, 0xDC68, 0xDC48, 0xE910, 0xEA23, 0xEB58, 0xEB4F, 0xEB45, 0xEAE5, 0xDB68, 0xDB48,
   0xE92B, 0xE90B, 0xE8EB, 0xE8CB, 0xE8AB, 0xE88B, 0xE86B, 0xE84B, 0xDA28, 0xDA08, 0xD9E8, 0xD9C8, 0xD9A8, 0xD988, 0xD968, 0xD948,
   0xD928, 0xD908, 0xD8E8, 0xD8C8, 0xD8A8, 0xD888, 0xD868, 0xD848, 0xD828, 0xD808, 0xD7E8, 0xD7C8, 0xD7A8, 0xD788, 0xD768, 0xD748,
   0xD728, 0xD708, 0xD6E8, 0xD6C8, 0xD6A8, 0xD688, 0xD668, 0xD648, 0xD628, 0xD608, 0xD5E8, 0xD5C8, 0xD5A8, 0xD588, 0xD568, 0xD548,
   0xD528, 0xD508, 0xD4E8, 0xD4C8, 0xE2B1, 0xE28B, 0xE26B, 0xE270, 0xE22B, 0xE20B, 0xE1EB, 0xE1CB, 0xE1AB, 0xE18B, 0xE18E, 0xDD8F,
   0xE3A8, 0xDFD3, 0xD929, 0xD90A, 0xE348, 0xD8C9, 0xD8AA, 0xDCD7, 0xDCB2, 0xD681, 0xD82A, 0xD80A, 0xE268, 0xCEDE, 0xD168, 0xD148,
   0xE116, 0xE0E9, 0xE1CB, 0xE0B7, 0xE0B7, 0xE15E, 0xDF17, 0xE034, 0xE013, 0xDFF3, 0xDFD3, 0xDE6C, 0xDF93, 0xDF73, 0xDF55, 0xDF34,
   0xD56A, 0xD54A, 0xD52A, 0xD50A, 0xD4EA, 0xD4CA, 0xD4AA, 0xD48A, 0xD46A, 0xD44A, 0xD42A, 0xD40A, 0xD3EA, 0xD3CA, 0xD3AA, 0xD38A,
   0xD36A, 0xD34A, 0xD32A, 0xD30A, 0xD2EA, 0xD2CA, 0xD2AA, 0xD28A, 0xD26A, 0xD24A, 0xD22A, 0xD20A, 0xD1EA, 0xD1CA, 0xD1AA, 0xD18A,
   0xD16A, 0xD14A, 0xD12A, 0xD10A, 0xD0EA, 0xD0CA, 0xD0AA, 0xD08A, 0xD06A, 0xD04A, 0xD02A, 0xD00A, 0xCFEA, 0xCFCA, 0xCFAA, 0xCF8A,
   0xCF6A, 0xCF4A, 0xCF2A, 0xCF0A, 0xCEEA, 0xCECA, 0xCEAA, 0xCE8A, 0xCE6A, 0xCE4A, 0xCE2A, 0xCE0A, 0xCDEA, 0xCDCA, 0xCDAA, 0xCD8A,
   0xCD6A, 0xCD4A, 0xCD2A, 0xCD0A, 0xCCEA, 0xCCCA, 0xCCAA, 0xCC8A, 0xCC6A, 0xCC4A, 0xCC2A, 0xCC0A, 0xCBEA, 0xCBCA, 0xCBAA, 0xCB8A,
   0xCB6A, 0xCB4A, 0xCB2A, 0xCB0A, 0xCAEA, 0xCACA, 0xCAAA, 0xCA8A, 0xCA6A, 0xCA4A, 0xCA2A, 0xCA0A, 0xC9EA, 0xC9CA, 0xC9AA, 0xC98A,
   0xC96A, 0xC94A, 0xC92A, 0xC90A, 0xC8EA, 0xC8CA, 0xC8AA, 0xC88A, 0xC86A, 0xC84A, 0xC82A, 0xC80A, 0xC7EA, 0xC7CA, 0xC7AA, 0xC78A,
   0xC76A, 0xC74A, 0xC72A, 0xC70A, 0xC6EA, 0xC6CA, 0xC6AA, 0xC68A, 0xC66A, 0xC64A, 0xC62A, 0xC60A, 0xC5EA, 0xC5CA, 0xC5AA, 0xC58A,
   0xC56A, 0xC54A, 0xC52A, 0xC50A, 0xC4EA, 0xC4CA, 0xC4AA, 0xC48A, 0xC46A, 0xC44A, 0xC42A, 0xC40A, 0xC3EA, 0xC3CA, 0xC3AA, 0xC38A,
   0xC36A, 0xC34A, 0xC32A, 0xC30A, 0xC2EA, 0xC2CA, 0xC2AA, 0xC28A, 0xC26A, 0xC24A, 0xC22A, 0xC20A, 0xC1EA, 0xC1CA, 0xC1AA, 0xC18A,
   0xC16A, 0xC14A, 0xC12A, 0xC10A, 0xC0EA, 0xC0CA, 0xC0AA, 0xC08A, 0xC06A, 0xC04A, 0xC02A, 0xC00A, 0xBFEA, 0xBFCA, 0xBFAA, 0xBF8A,
   0xBF6A, 0xBF4A, 0xBF2A, 0xBF0A, 0xBEEA, 0xBECA, 0xBEAA, 0xBE8A, 0xBE6A, 0xBE4A, 0xBE2A, 0xBE0A, 0xBDEA, 0xBDCA, 0xBDAA, 0xBD8A,
   0xBD6A, 0xBD4A, 0xBD2A, 0xBD0A, 0xBCEA, 0xBCCA, 0xBCAA, 0xBC8A, 0xBC6A, 0xBC4A, 0xBC2A, 0xBC0A, 0xBBEA, 0xB2E0, 0xB568, 0xB548,
   0xBB6A, 0xBB4A, 0xBB2A, 0xBB0A, 0xBAEA, 0xBACA, 0xBAAA, 0xBA8A, 0xBA6A, 0xBA4A, 0xBA2A, 0xBA0A, 0xB9EA, 0xB9CA, 0xB9AA, 0xB98A,
   0xB96A, 0xB94A, 0xB92A, 0xB90A, 0xB8EA, 0xB8CA, 0xB8AA, 0xB88A, 0xB86A, 0xB84A, 0xB82A, 0xB80A, 0xB7EA, 0xB7CA, 0xB7AA, 0xB78A,
   0xB76A, 0xB74A, 0xB72A, 0xB70A, 0xB6EA, 0xB6CA, 0xB6AA, 0xB68A, 0xB66A, 0xB64A, 0xB62A, 0xB60A, 0xB5EA, 0xB5CA, 0xB5AA, 0xB58A,
   0xB56A, 0xB54A, 0xB52A, 0xB50A, 0xB4EA, 0xB4CA, 0xB4AA, 0xB48A, 0xB46A, 0xB44A, 0xB42A, 0xB40A, 0xB3EA, 0xB3CA, 0xB3AA, 0xB38A,
   0xB36A, 0xB34A, 0xB32A, 0xB30A, 0xB2EA, 0xB2CA, 0xB2AA, 0xB28A, 0xB26A, 0xB24A, 0xB22A, 0xB20A, 0xB1EA, 0xB1CA, 0xB1AA, 0xB18A,
   0xB16A, 0xB14A, 0xB12A, 0xB10A, 0xB0EA, 0xB0CA, 0xB0AA, 0xB08A, 0xB06A, 0xB04A, 0xB02A, 0xB00A, 0xAFEA, 0xAFCA, 0xAFAA, 0xAF8A,
   0xAF6A, 0xAF4A, 0xAF2A, 0xAF0A, 0xAEEA, 0xAECA, 0xAEAA, 0xAE8A, 0xAE6A, 0xAE4A, 0xAE2A, 0xAE0A, 0xADEA, 0xADCA, 0xADAA, 0xAD8A,
   0xAD6A, 0xAD4A, 0xAD2A, 0xAD0A, 0xACEA, 0xACCA, 0xACAA, 0xAC8A, 0xAC6A, 0xAC4A, 0xAC2A, 0xAC0A, 0xABEA, 0xABCA, 0xABAA, 0xAB8A,
   0xAB6A, 0xAB4A, 0xAB2A, 0xAB0A, 0xAAEA, 0xAACA, 0xAAAA, 0xAA8A, 0xAA6A, 0xAA4A, 0xAA2A, 0xAA0A, 0xA9EA, 0xA9CA, 0xA9AA, 0xA98A,
   0xA96A, 0xA94A, 0xA92A, 0xA90A, 0xA8EA, 0xA8CA, 0xA8AA, 0xA88A, 0xA86A, 0xA84A, 0xA82A, 0xA80A, 0xA7EA, 0xA7CA, 0xA7AA, 0xA78A,
   0xA76A, 0xA74A, 0xA72A, 0xA70A, 0xA6EA, 0xA6CA, 0xA6AA, 0xA68A, 0xA66A, 0xA64A, 0xA62A, 0xA60A, 0xA5EA, 0xA5CA, 0xA5AA, 0xA58A,
   0xA56A, 0xA54A, 0xA52A, 0xA50A, 0xA4EA, 0xA4CA, 0xA4AA, 0xA48A, 0xA46A, 0xA44A, 0xA42A, 0xA40A, 0xA3EA, 0xA3CA, 0xA3AA, 0xA38A,
   0xA36A, 0xA34A, 0xA32A, 0xA30A, 0xA2EA, 0xA2CA, 0xA2AA, 0xA28A, 0xA26A, 0xA24A, 0xA22A, 0xA20A, 0xA1EA, 0xA1CA, 0xA1AA, 0xA18A,
   0xA16A, 0xA14A, 0xA12A, 0xA10A, 0xA0EA, 0xA0CA, 0xA0AA, 0xA08A, 0xA06A, 0xA04A, 0xA02A, 0xA00A, 0x9FEA, 0x9FCA, 0x9FAA, 0x9F8A,
   0x9F6A, 0x9F4A, 0x9F2A, 0x9F0A, 0x9EEA, 0x9ECA, 0x9EAA, 0x9E8A, 0x9E6A, 0x9E4A, 0x9E2A, 0x9E0A, 0x9DEA, 0x9DCA, 0x9DAA, 0x9D8A,
   0x9D6A, 0x9D4A, 0x9D2A, 0x9D0A, 0x9CEA, 0x9CCA, 0x9CAA, 0x9C8A, 0x9C6A, 0x9C4A, 0x9C2A, 0x9C0A, 0x9BEA, 0x9BCA, 0x9BAA, 0x9B8A,
   0x9B6A, 0x9B4A, 0x9B2A, 0x9B0A, 0x9AEA, 0x9ACA, 0x9AAA, 0x9A8A, 0x9A6A, 0x9A4A, 0x9A2A, 0x9A0A, 0x99EA, 0x99CA, 0x99AA, 0x998A,
   0x996A, 0x994A, 0x992A, 0x990A, 0x98EA, 0x98CA, 0x98AA, 0x988A, 0x986A, 0x984A, 0x982A, 0x980A, 0x97EA, 0x97CA, 0x97AA, 0x978A,
   0x976A, 0x974A, 0x972A, 0x970A, 0x96EA, 0x96CA, 0x96AA, 0x968A, 0x966A, 0x964A, 0x962A, 0x960A, 0x95EA, 0x95CA, 0x95AA, 0x958A,
   0x956A, 0x954A, 0x952A, 0x950A, 0x94EA, 0x94CA, 0x94AA, 0x948A, 0x946A, 0x944A, 0x942A, 0x940A, 0x93EA, 0x93CA, 0x93AA, 0x938A,
   0x936A, 0x934A, 0x932A, 0x930A, 0x92EA, 0x92CA, 0x92AA, 0x928A, 0x926A, 0x924A, 0x922A, 0x920A, 0x91EA, 0x91CA, 0x91AA, 0x918A,
   0x916A, 0x914A, 0x912A, 0x910A, 0x90EA, 0x90CA, 0x90AA, 0x908A, 0x906A, 0x904A, 0x902A, 0x900A, 0x8FEA, 0x8FCA, 0x8FAA, 0x8F8A,
   0x8F6A, 0x8F4A, 0x8F2A, 0x8F0A, 0x8EEA, 0x8ECA, 0x8EAA, 0x8E8A, 0x8E6A, 0x8E4A, 0x8E2A, 0x8E0A, 0x8DEA, 0x8DCA, 0x8DAA, 0x8D8A,
   0x8D6A, 0x8D4A, 0x8D2A, 0x8D0A, 0x8CEA, 0x8CCA, 0x8CAA, 0x8C8A, 0x8C6A, 0x8C4A, 0x8C2A, 0x8C0A, 0x8BEA, 0x8BCA, 0x8BAA, 0x8B8A,
   0x8B6A, 0x8B4A, 0x8B2A, 0x8B0A, 0x8AEA, 0x8ACA, 0x8AAA, 0x8A8A, 0x8A6A, 0x8A4A, 0x8A2A, 0x8A0A, 0x89EA, 0x89CA, 0x89AA, 0x898A,
   0x896A, 0x894A, 0x892A, 0x890A, 0x88EA, 0x88CA, 0x88AA, 0x888A, 0x886A, 0x884A, 0x882A, 0x880A, 0x87EA, 0x87CA, 0x87AA, 0x878A,
   0x876A, 0x874A, 0x872A, 0x870A, 0x86EA, 0x86CA, 0x86AA, 0x868A, 0x866A, 0x864A, 0x862A, 0x860A, 0x85EA, 0x85CA, 0x85AA, 0x858A,
   0x856A, 0x854A, 0x852A, 0x850A, 0x84EA, 0x84CA, 0x84AA, 0x848A, 0x846A, 0x844A, 0x842A, 0x840A, 0x83EA, 0x83CA, 0x83AA, 0x838A,
   0x836A, 0x834A, 0x832A, 0x830A, 0x82EA, 0x82CA, 0x82AA, 0x828A, 0x826A, 0x824A, 0x822A, 0x820A, 0x81EA, 0x81CA, 0x81AA, 0x818A,
   0x816A, 0x814A, 0x812A, 0x810A, 0x80EA, 0x80CA, 0x80AA, 0x808A, 0x806A, 0x804A, 0x802A, 0x800A, 0x7FEA, 0x7FCA, 0x7FAA, 0x7F8A,
   0x7F6A, 0x7F4A, 0x7F2A, 0x7F0A, 0x7EEA, 0x7ECA, 0x7EAA, 0x7E8A, 0x7E6A, 0x7E4A, 0x7E2A, 0x7E0A, 0x7DEA, 0x7DCA, 0x7DAA, 0x7D8A,
   0x7D6A, 0x7D4A, 0x7D2A, 0x7D0A, 0x7CEA, 0x7CCA, 0x7CAA, 0x7C8A, 0x7C6A, 0x7C4A, 0x7C2A, 0x7C0A, 0x7BEA, 0x7BCA, 0x7BAA, 0x7B8A,
   0x7B6A, 0x7B4A, 0x7B2A, 0x7B0A, 0x7AEA, 0x7ACA, 0x7AAA, 0x7A8A, 0x7A6A, 0x7A4A, 0x7A2A, 0x7A0A, 0x79EA, 0x79CA, 0x79AA, 0x798A,
   0x796A, 0x794A, 0x792A, 0x790A, 0x78EA, 0x78CA, 0x78AA, 0x788A, 0x786A, 0x784A, 0x782A, 0x780A, 0x77EA, 0x77CA, 0x77AA, 0x778A,
   0x776A, 0x774A, 0x772A, 0x770A, 0x76EA, 0x76CA, 0x76AA, 0x768A, 0x766A, 0x764A, 0x762A, 0x760A, 0x75EA, 0x75CA, 0x75AA, 0x758A,
   0x756A, 0x754A, 0x752A, 0x750A, 0x74EA, 0x74CA, 0x74AA, 0x748A, 0x746A, 0x744A, 0x742A, 0x740A, 0x73EA, 0x73CA, 0x73AA, 0x738A,
   0x736A, 0x734A, 0x732A, 0x730A, 0x72EA, 0x72CA, 0x72AA, 0x728A, 0x726A, 0x724A, 0x722A, 0x720A, 0x71EA, 0x71CA, 0x71AA, 0x718A,
   0x716A, 0x714A, 0x712A, 0x710A, 0x70EA, 0x70CA, 0x70AA, 0x708A, 0x706A, 0x704A, 0x702A, 0x700A, 0x6FEA, 0x6FCA, 0x6FAA, 0x6F8A,
   0x6F6A, 0x6F4A, 0x6F2A, 0x6F0A, 0x6EEA, 0x6ECA, 0x6EAA, 0x6E8A, 0x6E6A, 0x6E4A, 0x6E2A, 0x6E0A, 0x6DEA, 0x6DCA, 0x6DAA, 0x6D8A,
   0x6D6A, 0x6D4A, 0x6D2A, 0x6D0A, 0x6CEA, 0x6CCA, 0x6CAA, 0x6C8A, 0x6C6A, 0x6C4A, 0x6C2A, 0x6C0A, 0x6BEA, 0x6BCA, 0x6BAA, 0x6B8A,
   0x6B6A, 0x6B4A, 0x6B2A, 0x6B0A, 0x6AEA, 0x6ACA, 0x6AAA, 0x6A8A, 0x6A6A, 0x6A4A, 0x6A2A, 0x6A0A, 0x69EA, 0x60F0, 0x6368, 0x6348,
   0x696A, 0x694A, 0x692A, 0x690A, 0x68EA, 0x68CA, 0x68AA, 0x688A, 0x686A, 0x684A, 0x682A, 0x680A, 0x67EA, 0x67CA, 0x67AA, 0x678A,
   0x676A, 0x674A, 0x672A, 0x670A, 0x66EA, 0x66CA, 0x66AA, 0x668A, 0x666A, 0x664A, 0x662A, 0x660A, 0x65EA, 0x65CA, 0x65AA, 0x658A,
   0x656A, 0x654A, 0x652A, 0x650A, 0x6B26, 0x6DE1, 0x6E9C, 0x5E48, 0x5E28, 0x5E08, 0x5DE8, 0x5DC8, 0x5DA8, 0x5D88, 0x5D68, 0x5D48,
   0x5D28, 0x5D08, 0x5CE8, 0x5CC8, 0x5CA8, 0x5C88, 0x5C68, 0x5C48, 0x5C28, 0x5C08, 0x5BE8, 0x5BC8, 0x5BA8, 0x5B88, 0x5B68, 0x5B48,
   0x5B28, 0x5B08, 0x5AE8, 0x5AC8, 0x5AA8, 0x5A88, 0x5A68, 0x5A48, 0x5A28, 0x5A08, 0x59E8, 0x59C8, 0x59A8, 0x5988, 0x5968, 0x5948,
   0x5928, 0x5908, 0x58E8, 0x58C8, 0x58A8, 0x5888, 0x5868, 0x5848, 0x5828, 0x5808, 0x57E8, 0x57C8, 0x57A8, 0x5788, 0x5768, 0x5748,
   0x5D6A, 0x5D4A, 0x5D2A, 0x5D0A, 0x5CEA, 0x5CCA, 0x5CAA, 0x5C8A, 0x5C6A, 0x5C4A, 0x5C2A, 0x5C0A, 0x5BEA, 0x5BCA, 0x5BAA, 0x5B8A,
   0x5B6A, 0x5B4A, 0x5B2A, 0x5B0A, 0x5AEA, 0x5ACA, 0x5AAA, 0x5A8A, 0x5A6A, 0x5A4A, 0x5A2A, 0x5A0A, 0x59EA, 0x59CA, 0x59AA, 0x598A,
   0x596A, 0x594A, 0x592A, 0x590A, 0x58EA, 0x58CA, 0x58AA, 0x588A, 0x586A, 0x584A, 0x582A, 0x580A, 0x57EA, 0x57CA, 0x57AA, 0x578A,
   0x576A, 0x574A, 0x572A, 0x570A, 0x56EA, 0x56CA, 0x56AA, 0x568A, 0x566A, 0x564A, 0x562A, 0x560A, 0x55EA, 0x55CA, 0x55AA, 0x558A,
   0x556A, 0x554A, 0x552A, 0x550A, 0x54EA, 0x54CA, 0x54AA, 0x548A, 0x546A, 0x544A, 0x542A, 0x540A, 0x53EA, 0x53CA, 0x53AA, 0x538A,
   0x536A, 0x534A, 0x532A, 0x530A, 0x52EA, 0x52CA, 0x52AA, 0x528A, 0x526A, 0x524A, 0x522A, 0x520A, 0x51EA, 0x51CA, 0x51AA, 0x518A,
   0x516A, 0x514A, 0x512A, 0x510A, 0x50EA, 0x50CA, 0x50AA, 0x508A, 0x506A, 0x504A, 0x502A, 0x500A, 0x4FEA, 0x4FCA, 0x4FAA, 0x4F8A,
   0x4F6A, 0x4F4A, 0x4F2A, 0x4F0A, 0x4EEA, 0x4ECA, 0x4EAA, 0x4E8A, 0x4E6A, 0x4E4A, 0x4E2A, 0x4E0A, 0x4DEA, 0x4DCA, 0x4DAA, 0x4D8A,
   0x4D6A, 0x4D4A, 0x4D2A, 0x4D0A, 0x4CEA, 0x4CCA, 0x4CAA, 0x4C8A, 0x4C6A, 0x4C4A, 0x4C2A, 0x4C0A, 0x4BEA, 0x4BCA, 0x4BAA, 0x4B8A,
   0x4B6A, 0x4B4A, 0x4B2A, 0x4B0A, 0x4AEA, 0x4ACA, 0x4AAA, 0x4A8A, 0x4A6A, 0x4A4A, 0x4A2A, 0x4A0A, 0x49EA, 0x49CA, 0x49AA, 0x498A,
   0x496A, 0x494A, 0x492A, 0x490A, 0x48EA, 0x48CA, 0x48AA, 0x488A, 0x486A, 0x484A, 0x482A, 0x480A, 0x47EA, 0x47CA, 0x47AA, 0x478A,
   0x476A, 0x474A, 0x472A, 0x470A, 0x46EA, 0x46CA, 0x46AA, 0x468A, 0x466A, 0x464A, 0x462A, 0x460A, 0x45EA, 0x45CA, 0x45AA, 0x458A,
   0x456A, 0x454A, 0x452A, 0x450A, 0x44EA, 0x44CA, 0x44AA, 0x448A, 0x446A, 0x444A, 0x442A, 0x440A, 0x43EA, 0x43CA, 0x43AA, 0x438A,
   0x436A, 0x434A, 0x432A, 0x430A, 0x42EA, 0x42CA, 0x42AA, 0x428A, 0x426A, 0x424A, 0x422A, 0x420A, 0x41EA, 0x41CA, 0x41AA, 0x418A,
   0x416A, 0x414A, 0x412A, 0x410A, 0x40EA, 0x40CA, 0x40AA, 0x408A, 0x406A, 0x404A, 0x402A, 0x400A, 0x3FEA, 0x3FCA, 0x3FAA, 0x3F8A,
   0x3F6A, 0x3F4A, 0x3F2A, 0x3F0A, 0x3EEA, 0x3ECA, 0x3EAA, 0x3E8A, 0x3E6A, 0x3E4A, 0x3E2A, 0x3E0A, 0x3DEA, 0x3DCA, 0x3DAA, 0x3D8A,
   0x3D6A, 0x3D4A, 0x3D2A, 0x3D0A, 0x3CEA, 0x3CCA, 0x3CAA, 0x3C8A, 0x3C6A, 0x3C4A, 0x3C2A, 0x3C0A, 0x3BEA, 0x3BCA, 0x3BAA, 0x3B8A,
   0x3B6A, 0x3B4A, 0x3B2A, 0x3B0A, 0x3AEA, 0x3ACA, 0x3AAA, 0x3A8A, 0x3A6A, 0x3A4A, 0x3A2A, 0x3A0A, 0x39EA, 0x39CA, 0x39AA, 0x398A,
   0x396A, 0x394A, 0x392A, 0x390A, 0x38EA, 0x38CA, 0x38AA, 0x388A, 0x386A, 0x384A, 0x382A, 0x380A, 0x37EA, 0x37CA, 0x37AA, 0x378A,
   0x376A, 0x374A, 0x372A, 0x370A, 0x36EA, 0x36CA, 0x36AA, 0x368A, 0x366A, 0x364A, 0x362A, 0x360A, 0x35EA, 0x35CA, 0x35AA, 0x358A,
   0x356A, 0x354A, 0x352A, 0x350A, 0x34EA, 0x34CA, 0x34AA, 0x348A, 0x346A, 0x344A, 0x342A, 0x340A, 0x33EA, 0x33CA, 0x33AA, 0x338A,
   0x336A, 0x334A, 0x332A, 0x330A, 0x32EA, 0x32CA, 0x32AA, 0x328A, 0x326A, 0x324A, 0x322A, 0x320A, 0x31EA, 0x28F2, 0x2B68, 0x2B48,
   0x3C2B, 0x3C0B, 0x3BEB, 0x3BCB, 0x3BAB, 0x3B8B, 0x3B6B, 0x3B4B, 0x3B2B, 0x3B0B, 0x3AEB, 0x3ACB, 0x3AAB, 0x3A8B, 0x3A6B, 0x3A4B,
   0x3A2B, 0x3A0B, 0x39EB, 0x39CB, 0x39AB, 0x398B, 0x396B, 0x394B, 0x392B, 0x390B, 0x38EB, 0x38CB, 0x38AB, 0x388B, 0x386B, 0x384B,
   0x382B, 0x380B, 0x37EB, 0x37CB, 0x37AB, 0x378B, 0x376B, 0x374B, 0x372B, 0x370B, 0x36EB, 0x36CB, 0x36AB, 0x368B, 0x366B, 0x364B,
   0x362B, 0x360B, 0x35EB, 0x35CB, 0x35AB, 0x358B, 0x356B, 0x354B, 0x352B, 0x350B, 0x34EB, 0x34CB, 0x34AB, 0x348B, 0x346B, 0x344B,
   0x344B, 0x342B, 0x340B, 0x33EB, 0x33CB, 0x33AB, 0x338B, 0x336B, 0x334B, 0x332B, 0x330B, 0x32EB, 0x32CB, 0x32AB, 0x328B, 0x326B,
   0x324B, 0x322B, 0x320B, 0x31EB, 0x31CB, 0x31AB, 0x318B, 0x316B, 0x314B, 0x312B, 0x310B, 0x30EB, 0x30CB, 0x30AB, 0x308B, 0x306B,
   0x304B, 0x302B, 0x300B, 0x2FEB, 0x2FCB, 0x2FAB, 0x2F8B, 0x2F6B, 0x2F4B, 0x2F2B, 0x2F0B, 0x2EEB, 0x2ECB, 0x2EAB, 0x2E8B, 0x2E6B,
   0x2E4B, 0x2E2B, 0x2E0B, 0x2DEB, 0x2DCB, 0x2DAB, 0x2D8B, 0x2D6B, 0x2D4B, 0x2D2B, 0x2D0B, 0x2CEB, 0x2CCB, 0x2CAB, 0x2C8B, 0x2C6B,
   0x2C4B, 0x2C2B, 0x2C0B, 0x2BEB, 0x2BCB, 0x2BAB, 0x2B8B, 0x2B6B, 0x2B4B, 0x2B2B, 0x2B0B, 0x2AEB, 0x2ACB, 0x2AAB, 0x2A8B, 0x2A6B,
   0x2A4B, 0x2A2B, 0x2A0B, 0x29EB, 0x29CB, 0x29AB, 0x298B, 0x296B, 0x294B, 0x292B, 0x290B, 0x28EB, 0x28CB, 0x28AB, 0x288B, 0x286B,
   0x284B, 0x282B, 0x280B, 0x27EB, 0x27CB, 0x27AB, 0x278B, 0x276B, 0x274B, 0x272B, 0x270B, 0x26EB, 0x26CB, 0x26AB, 0x268B, 0x266B,
   0x264B, 0x262B, 0x260B, 0x25EB, 0x25CB, 0x25AB, 0x258B, 0x256B, 0x254B, 0x252B, 0x250B, 0x24EB, 0x24CB, 0x24AB, 0x248B, 0x246B,
   0x244B, 0x242B, 0x240B, 0x23EB, 0x23CB, 0x23AB, 0x238B, 0x236B, 0x234B, 0x232B, 0x230B, 0x22EB, 0x22CB, 0x22AB, 0x228B, 0x226B,
   0x224B, 0x222B, 0x220B, 0x21EB, 0x21CB, 0x21AB, 0x218B, 0x216B, 0x214B, 0x212B, 0x210B, 0x20EB, 0x20CB, 0x20AB, 0x208B, 0x206B,
   0x204B, 0x202B, 0x200B, 0x1FEB, 0x1FCB, 0x1FAB, 0x1F8B, 0x1F6B, 0x1F4B, 0x1F2B, 0x1F0B, 0x1EEB, 0x1ECB, 0x1EAB, 0x1E8B, 0x1E6B,
   0x1E4B, 0x1E2B, 0x1E0B, 0x1DEB, 0x1DCB, 0x1DAB, 0x1D8B, 0x1D6B, 0x1D4B, 0x1D2B, 0x1D0B, 0x1CEB, 0x1CCB, 0x1CAB, 0x1C8B, 0x1C6B,
   0x1C4B, 0x1C2B, 0x1C0B, 0x1BEB, 0x1BCB, 0x1BAB, 0x1B8B, 0x1B6B, 0x106A, 0x104A, 0x102A, 0x100A, 0xFEA, 0xFCA, 0xFAA, 0xF8A,
   0xF6A, 0x668, 0x8E8, 0x8C8, 0x8A8, 0x888, 0x868, 0x848, 0x7D7, 0x194B, 0x7B6, 0xD1C, 0xCFC, 0xCB2, 0xCA9, 0xC9C,
   0xC7C, 0xC5C, 0xC3C, 0xC1C, 0xBFC, 0xBDC, 0xBBC, 0xB9C, 0xB7C, 0xB5E, 0xB2C, 0xB1C, 0xAB8, 0xADC, 0xA9C, 0x2C2,
   0x528, 0x166B, 0x1667, 0x3FF, 0x9FC, 0x9DC, 0x9BC, 0x659, 0xBB8, 0x15A7, 0xFC6, 0x1C0, 0x1B1, 0x9CB, 0x82C, 0x1285,
};

static uint16_t Data[] = {
   0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082,
   0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3E80, 0x3E80, 0x3001, 0x3082, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
   0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
   0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x5B88, 0x5B88, 0x3E80, 0x3A85, 0x3A85,
   0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
   0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
   0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x5198, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x4606, 0x3E80, 0x3E80, 0x3A85, 0x3A85,
   0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
   0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
   0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
   0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
   0x3E80, 0x3E80, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x3E80, 0x3E80,
   0x3E80, 0x3E80, 0x5202, 0x5202, 0x5202, 0x5202, 0x5202, 0x5202, 0x5202, 0x5202, 0x5202, 0x5202, 0x5202, 0x5202, 0x5202, 0x5202,
   0x5202, 0x5202, 0x5202, 0x5202, 0x5202, 0x5202, 0x5202, 0x5202, 0x5202, 0x5202, 0x5202, 0x5202, 0x5202, 0x5202, 0x5202, 0x5202,
   0x5202, 0x2E82, 0x3E80, 0x5198, 0x2A14, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606,
   0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4686, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606,
   0x4606, 0x4606, 0x4606, 0x4606, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
   0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x1A1B, 0x1A1B, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x4584, 0x3E80, 0x3E80, 0x3E80, 0x298,
   0x3E80, 0x298, 0x6615, 0x6696, 0x298, 0x1A97, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
   0x4584, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
   0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x4584,
   0x4584, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B, 0x4584,
   0x4584, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B, 0x2E82,
   0x7282, 0x2E82, 0x3E80, 0x2E82, 0x4902, 0x7481, 0x7481, 0x7481, 0x7481, 0x7383, 0x1A1B, 0x1A1B, 0x1A1B, 0x6D82, 0x6D82, 0x4902,
   0x4902, 0x3E80, 0x3E80, 0x2E82, 0x4902, 0x6E01, 0x6E01, 0x7501, 0x7501, 0x3E80, 0x1A1B, 0x1A1B, 0x1A1B, 0x1B02, 0x1B82, 0x1C02,
   0x1C82, 0x1D02, 0x1D82, 0x1E02, 0x1E82, 0x1F02, 0x1F82, 0x2002, 0x2082, 0x2102, 0x2182, 0x2202, 0x2282, 0x2302, 0x2382, 0x2402,
   0x2482, 0x2502, 0x2582, 0x2602, 0x2682, 0x2702, 0x2782, 0x455, 0xC99, 0x4D6, 0xC99, 0xF, 0xF, 0xF, 0xF, 0xF,
   0x10F, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF,
   0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0x8F, 0x10F, 0x8F, 0x18F, 0x10F,
   0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0x10F, 0x10F,
   0x10F, 0x8F, 0x20C, 0x298, 0x298, 0x318, 0x39A, 0x318, 0x298, 0x298, 0x455, 0x4D6, 0x298, 0x519, 0x598, 0x614,
   0x598, 0x698, 0x709, 0x789, 0x809, 0x889, 0x909, 0x989, 0xA09, 0xA89, 0xB09, 0xB89, 0x598, 0x298, 0xC59, 0xC99,
   0xC59, 0x298, 0xD01, 0xD81, 0xE01, 0xE81, 0xF01, 0xF81, 0x1001, 0x1081, 0x1101, 0x1181, 0x1201, 0x1281, 0x1301, 0x1381,
   0x1401, 0x1481, 0x1501, 0x1581, 0x1601, 0x1681, 0x1701, 0x1781, 0x1801, 0x1881, 0x1901, 0x1981, 0x455, 0x298, 0x4D6, 0x1A1B,
   0x1A97, 0x298, 0x298, 0x298, 0xC99, 0x455, 0x4D6, 0x3E80, 0x298, 0x298, 0x298, 0x298, 0x298, 0x298, 0x3E80, 0x3E80,
   0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
   0x282C, 0x298, 0x39A, 0x39A, 0x39A, 0x39A, 0x289C, 0x289C, 0x1A1B, 0x289C, 0x2902, 0x29DD, 0xC99, 0x2A14, 0x289C, 0x1A1B,
   0x2A9C, 0x519, 0x2B0B, 0x2B8B, 0x1A1B, 0x2C02, 0x289C, 0x298, 0x1A1B, 0x2C8B, 0x2902, 0x2D5E, 0x2D8B, 0x2D8B, 0x2D8B, 0x298,
   0x298, 0x519, 0x614, 0xC99, 0xC99, 0xC99, 0x3E80, 0x298, 0x39A, 0x318, 0x298, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x5405,
   0x5405, 0x5405, 0x3E80, 0x5405, 0x3E80, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405,
   0x5405, 0x5405, 0x3E80, 0x3E80, 0x3E80, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606,
   0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606,
   0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x3E80, 0x501C, 0x501C, 0x4F81, 0x4F81, 0x4F81, 0x4F81, 0x4F81, 0x4F81, 0x4F81, 0x4F81,
   0x4F81, 0x4F81, 0x4F81, 0x4F81, 0x4F81, 0x4F81, 0x4F81, 0x4F81, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01,
   0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0xC99,
   0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E82, 0x2E82, 0x2E82, 0x4902, 0x4902, 0x2E82, 0x2E82, 0x3E80, 0x3E80,
   0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x2E82, 0x2E82, 0x2E82, 0x2E82, 0x2E82, 0x3E80,
   0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x5305, 0x4606, 0x5305, 0x5305, 0x3E80, 0x5305, 0x5305, 0x3E80, 0x5305, 0x5305, 0x5305, 0x5305,
   0x5305, 0x5305, 0x5305, 0x5305, 0x5305, 0x5305, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405,
   0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5398, 0x5405, 0x4606, 0x4606, 0x4606, 0x4606,
   0x4606, 0x4606, 0x4606, 0x5087, 0x5087, 0x4606, 0x5087, 0x5087, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
   0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
   0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x2D8B, 0x2D8B, 0x2D8B, 0x2D8B, 0x2D8B, 0x2D8B, 0x2D8B, 0x2D8B,
   0x2D8B, 0x2D8B, 0x2D8B, 0x2D8B, 0x840B, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x2E82, 0x3001,
   0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001,
   0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3E80,
   0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x5C09, 0x5C89, 0x5D09, 0x5D89, 0x5E09, 0x5E89, 0x5F09, 0x5F89, 0x6009, 0x6089, 0x4606,
   0x4606, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x1A1B,
   0x1A1B, 0x4701, 0x298, 0x4781, 0x4781, 0x4781, 0x3E80, 0x4801, 0x3E80, 0x4881, 0x4881, 0x4902, 0x2E01, 0x2E01, 0x2E01, 0x2E01,
   0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2F02, 0x2F02, 0x2F02, 0x2F02,
   0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02,
   0x2F02, 0x2F02, 0x2F02, 0xC99, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F82, 0x2F02, 0x2F02, 0x4A82, 0x2F02,
   0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x4B02, 0x4B82, 0x4B82, 0x3E80, 0x4C02, 0x4C82, 0x4D01, 0x4D01,
   0x4D01, 0x4D82, 0x4E02, 0x2902, 0x3E80, 0x3E80, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082,
   0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x2E82, 0x3B81, 0x3C03, 0x3C82, 0x3001, 0x3082, 0x3D81, 0x3E01, 0x3001, 0x3082,
   0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3101, 0x3182,
   0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x2902, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001,
   0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x4E82, 0x4F02, 0x3D02, 0x2902, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
   0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x5B10, 0x5B10, 0x5B10, 0x5B10, 0x5B10, 0x5B10, 0x7F0B, 0x3E80, 0x3E80,
   0x3E80, 0x7F8B, 0x800B, 0x808B, 0x810B, 0x818B, 0x820B, 0x519, 0x519, 0xC99, 0x455, 0x4D6, 0x2902, 0x3301, 0x3001, 0x3082,
   0x3001, 0x3082, 0x3381, 0x3001, 0x3082, 0x3401, 0x3401, 0x3001, 0x3082, 0x2902, 0x3481, 0x3501, 0x3581, 0x3001, 0x3082, 0x3401,
   0x3601, 0x3682, 0x3701, 0x3781, 0x3001, 0x3082, 0x2902, 0x2902, 0x3701, 0x3801, 0x2902, 0x3881, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
   0x3B81, 0x3C03, 0x3C82, 0x3B81, 0x3C03, 0x3C82, 0x3B81, 0x3C03, 0x3C82, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001,
   0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3D02, 0x3001, 0x3082, 0x501C, 0x4606, 0x4606, 0x4606,
   0x4606, 0x3E80, 0x5087, 0x5087, 0x3E80, 0x3E80, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082,
   0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3201, 0x3001,
   0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3282, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3901, 0x3001, 0x3082, 0x3901,
   0x2902, 0x2902, 0x3001, 0x3082, 0x3901, 0x3001, 0x3082, 0x3981, 0x3981, 0x3001, 0x3082, 0x3001, 0x3082, 0x3A01, 0x3001, 0x3082,
   0x2902, 0x3A85, 0x3001, 0x3082, 0x2902, 0x3B02, 0x4D01, 0x3001, 0x3082, 0x3001, 0x3082, 0x3E80, 0x3E80, 0x3001, 0x3082, 0x3E80,
   0x3E80, 0x3001, 0x3082, 0x3E80, 0x3E80, 0x3E80, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082,
   0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
   0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x598, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
   0x3E80, 0x3E80, 0x3E80, 0x5398, 0x3E80, 0x3E80, 0x3E80, 0x5398, 0x5398, 0x5398, 0x5398, 0x5398, 0x5398, 0x5398, 0x5398, 0x5398,
   0x5398, 0x5398, 0x5398, 0x5398, 0x5398, 0x3E80, 0x5B10, 0x5405, 0x4606, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405,
   0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405,
   0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x3E80, 0x3E80, 0x5B10, 0x4D01, 0x4D01, 0x4D01, 0x4D01, 0x4D01, 0x4D01, 0x4D01,
   0x4D01, 0x4D01, 0x4D01, 0x4D01, 0x4D01, 0x4D01, 0x4D01, 0x4D01, 0x4D01, 0x4D01, 0x4D01, 0x4D01, 0x4D01, 0x4D01, 0x4D01, 0x4D01,
   0x4D01, 0x4D01, 0x4D01, 0x4D01, 0x4D01, 0x4D01, 0x4D01, 0x4D01, 0x4D01, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
   0x3E80, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
   0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80,
   0x3A85, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x5C09, 0x5C89, 0x5D09, 0x5D89, 0x5E09, 0x5E89, 0x5F09, 0x5F89, 0x6009, 0x6089,
   0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
   0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x2902, 0x2902, 0x2902, 0x3F02, 0x3F82, 0x2902, 0x4002, 0x4002, 0x2902, 0x4082,
   0x2902, 0x4102, 0x2902, 0x2902, 0x2902, 0x2902, 0x4002, 0x2902, 0x2902, 0x4182, 0x2902, 0x2902, 0x2902, 0x2902, 0x4202, 0x4282,
   0x2902, 0x2902, 0x2902, 0x2902, 0x2902, 0x4282, 0x2902, 0x2902, 0x4302, 0x2902, 0x2902, 0x4382, 0x2902, 0x2902, 0x2902, 0x2902,
   0x2902, 0x2902, 0x2902, 0x2902, 0x2902, 0x2902, 0x4402, 0x2902, 0x2902, 0x4402, 0x2902, 0x2902, 0x2902, 0x2902, 0x4402, 0x2902,
   0x4482, 0x4482, 0x2902, 0x2902, 0x2902, 0x2902, 0x2902, 0x2902, 0x4502, 0x2902, 0x2902, 0x2902, 0x2902, 0x2902, 0x2902, 0x2902,
   0x2902, 0x2902, 0x2902, 0x2902, 0x2902, 0x2902, 0x2902, 0x3E80, 0x3E80, 0x4584, 0x4584, 0x4584, 0x4584, 0x4584, 0x4584, 0x4584,
   0x4584, 0x4584, 0x1A1B, 0x1A1B, 0x4584, 0x4584, 0x4584, 0x4584, 0x4584, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B, 0x1A1B,
   0x1A1B, 0x1A1B, 0x4584, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
   0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x5101, 0x5101, 0x5101, 0x5101, 0x5101, 0x5101, 0x5101, 0x5101, 0x5101, 0x5101, 0x5101, 0x5101,
   0x5101, 0x5101, 0x5101, 0x5101, 0x5101, 0x5101, 0x5101, 0x5101, 0x5101, 0x5101, 0x5101, 0x3E80, 0x3E80, 0x4584, 0x5198, 0x5198,
   0x5198, 0x5198, 0x5198, 0x5198, 0x2E01, 0x2E01, 0x3E80, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01, 0x2E01,
   0x4982, 0x4A02, 0x4A02, 0x4A02, 0x4902, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02,
   0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x2F02, 0x4F02, 0x4F02, 0x4F02, 0x4F02, 0x4F02, 0x4F02, 0x4F02, 0x4F02, 0x4F02, 0x4F02, 0x4F02,
   0x4F02, 0x4F02, 0x4F02, 0x4F02, 0x4F02, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x5198, 0x4606, 0x4606, 0x3A85, 0x3A85, 0x3A85,
   0x3A85, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x3E80, 0x4606, 0x4606,
   0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606,
   0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x3E80, 0x4606, 0x4606, 0x4606, 0x5298, 0x4606, 0x4606, 0x5298, 0x4606, 0x3E80, 0x3E80,
   0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x5305, 0x5305, 0x5305, 0x5305, 0x5305, 0x5305, 0x5305,
   0x5305, 0x5305, 0x5305, 0x5305, 0x5305, 0x5305, 0x5305, 0x5305, 0x5305, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x5305, 0x5305,
   0x5305, 0x5298, 0x5298, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x5C89, 0x5D09,
   0x5D89, 0x5E09, 0x5E89, 0x5F09, 0x5F89, 0x6009, 0x6089, 0x640B, 0x648B, 0x650B, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
   0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x4606, 0x5B88, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
   0x3E80, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3E80, 0x3A85, 0x3A85,
   0x3E80, 0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
   0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
   0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
   0x3E80, 0x3E80, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606,
   0x5B88, 0x5B88, 0x5B88, 0x5B88, 0x3E80, 0x4606, 0x4606, 0x4606, 0x3E80, 0x4606, 0x4606, 0x4606, 0x4606, 0x3E80, 0x3E80, 0x3E80,
   0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x4606, 0x4606, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x4606,
   0x5B88, 0x5B88, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3E80,
   0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3E80,
   0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
   0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
   0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x5B88, 0x5B88, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
   0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3E80, 0x3A85, 0x3A85,
   0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3A85, 0x3A85,
   0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x5C09, 0x5C89, 0x5D09,
   0x5D89, 0x5E09, 0x5E89, 0x5F09, 0x5F89, 0x6009, 0x6089, 0x501C, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
   0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x5509, 0x5589, 0x5609, 0x5689, 0x5709, 0x5789, 0x5809, 0x5889, 0x5909,
   0x5989, 0x318, 0x5A18, 0x5A18, 0x5398, 0x3E80, 0x3E80, 0x4606, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405,
   0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x3E80, 0x3E80, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405,
   0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405,
   0x5405, 0x5405, 0x5405, 0x5405, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
   0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x5405, 0x5405, 0x5405, 0x5405,
   0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405,
   0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x6615, 0x6696, 0x5484, 0x5405,
   0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x5405, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606,
   0x4606, 0x4606, 0x4606, 0x4606, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
   0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x5B88, 0x5B88, 0x5198, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
   0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x4606, 0x4606, 0x5B88, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
   0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
   0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x5198, 0x5198, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
   0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x5484, 0x5484,
   0x4606, 0x4606, 0x289C, 0x4606, 0x4606, 0x4606, 0x4606, 0x3E80, 0x3E80, 0x709, 0x789, 0x809, 0x889, 0x909, 0x989, 0xA09,
   0xA89, 0xB09, 0xB89, 0x5405, 0x5405, 0x5405, 0x5A9C, 0x5A9C, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3E80, 0x3A85,
   0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x4606, 0x3A85, 0x3A85, 0x4606, 0x4606, 0x4606, 0x4606,
   0x4606, 0x4606, 0x3E80, 0x4606, 0x4606, 0x3A85, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
   0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3A85,
   0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x4606, 0x4606, 0x5B88, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
   0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
   0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x4606, 0x3A85, 0x5B88, 0x5B88,
   0x5B88, 0x5B88, 0x5B88, 0x3E80, 0x4606, 0x5B88, 0x5B88, 0x3E80, 0x5B88, 0x5B88, 0x4606, 0x4606, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
   0x3E80, 0x3E80, 0x3E80, 0x5B88, 0x5B88, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3A85, 0x3E80, 0x5198, 0x5198,
   0x5198, 0x5198, 0x5198, 0x5198, 0x5198, 0x5198, 0x5C89, 0x5D09, 0x5D89, 0x5E09, 0x5E89, 0x5F09, 0x5F89, 0x6009, 0x6089, 0x640B,
   0x670B, 0x678B, 0x680B, 0x688B, 0x690B, 0x698B, 0x6A0B, 0x6A8B, 0x648B, 0x6B0B, 0x3E80, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85,
   0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3A85,
   0x3A85, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x4606, 0x3A85, 0x5B88, 0x4606, 0x4606, 0x4606, 0x4606,
   0x4606, 0x4606, 0x4606, 0x4606, 0x5B88, 0x5B88, 0x5B88, 0x5B88, 0x4606, 0x3E80, 0x3E80, 0x3A85, 0x4606, 0x4606, 0x4606, 0x4606,
   0x3E80, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3A85,
   0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3E80, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x4606,
   0x3E80, 0x5B88, 0x5B88, 0x5B88, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3A85,
   0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
   0x3A85, 0x3E80, 0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
   0x3A85, 0x3E80, 0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
   0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x4606, 0x3A85, 0x3A85, 0x4606, 0x4606,
   0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x39A, 0x39A, 0x39A, 0x39A, 0x39A, 0x39A, 0x39A,
   0x39A, 0x39A, 0x39A, 0x39A, 0x39A, 0x39A, 0x39A, 0x39A, 0x39A, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
   0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x4606, 0x4606, 0x5198, 0x5198, 0x5C09,
   0x5C89, 0x5D09, 0x5D89, 0x5E09, 0x5E89, 0x5F09, 0x5F89, 0x6009, 0x6089, 0x5198, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
   0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x298, 0x298, 0x318, 0x39A, 0x318, 0x298, 0x298,
   0x6615, 0x6696, 0x298, 0x519, 0x598, 0x614, 0x598, 0x698, 0x709, 0x789, 0x809, 0x889, 0x909, 0x989, 0xA09, 0xA89,
   0xB09, 0xB89, 0x598, 0x298, 0xC99, 0xC99, 0xC99, 0x298, 0x298, 0x298, 0x298, 0x298, 0x298, 0x2A14, 0x298, 0x298,
   0x298, 0x298, 0x5B10, 0x5B10, 0x5B10, 0x5B10, 0x3E80, 0x5C09, 0x5C89, 0x5D09, 0x5D89, 0x5E09, 0x5E89, 0x5F09, 0x5F89, 0x6009,
   0x6089, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
   0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
   0x3A85, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x5B88, 0x4606, 0x4606, 0x4606, 0x4606, 0x3E80, 0x3E80, 0x5B88, 0x5B88, 0x3E80, 0x3E80,
   0x5B88, 0x5B88, 0x4606, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x5B88, 0x3E80, 0x3E80, 0x3E80,
   0x3E80, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3E80, 0x3E80, 0x3A85, 0x3E80, 0x3E80,
   0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
   0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3A85,
   0x3E80, 0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x4606, 0x3E80, 0x5B88, 0x5B88, 0x4606, 0x4606, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x4606,
   0x4606, 0x3E80, 0x3E80, 0x4606, 0x4606, 0x4606, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
   0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x4606, 0x4606, 0x3E80, 0x3E80, 0x5C09, 0x5C89,
   0x5D09, 0x5D89, 0x5E09, 0x5E89, 0x5F09, 0x5F89, 0x6009, 0x6089, 0x3A85, 0x3A85, 0x39A, 0x39A, 0x610B, 0x618B, 0x620B, 0x628B,
   0x630B, 0x638B, 0x501C, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
   0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3A85,
   0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x4606, 0x3A85, 0x5B88, 0x5B88, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x3E80, 0x4606, 0x4606,
   0x5B88, 0x3E80, 0x5B88, 0x5B88, 0x4606, 0x3E80, 0x3E80, 0x3A85, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
   0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x5C09, 0x5C89, 0x5D09, 0x5D89, 0x5E09, 0x5E89, 0x5F09, 0x5F89, 0x6009,
   0x6089, 0x630B, 0x630B, 0x630B, 0x630B, 0x630B, 0x630B, 0x630B, 0x630B, 0x630B, 0x630B, 0x501C, 0x4606, 0x501C, 0x4606, 0x501C,
   0x4606, 0x6615, 0x6696, 0x6615, 0x6696, 0x5B88, 0x5B88, 0x4606, 0x4606, 0x4606, 0x3E80, 0x3E80, 0x3E80, 0x5B88, 0x5B88, 0x3E80,
   0x3E80, 0x5B88, 0x5B88, 0x4606, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x4606, 0x5B88, 0x3E80, 0x3E80,
   0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3E80, 0x5B88, 0x4606,
   0x4606, 0x4606, 0x4606, 0x5B88, 0x4606, 0x3E80, 0x3E80, 0x3E80, 0x4606, 0x4606, 0x5B88, 0x4606, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
   0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
   0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x5B88, 0x5B88, 0x5B88, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606,
   0x5B88, 0x5B88, 0x3E80, 0x3E80, 0x3E80, 0x5B88, 0x5B88, 0x5B88, 0x3E80, 0x5B88, 0x5B88, 0x5B88, 0x4606, 0x3E80, 0x3E80, 0x3E80,
   0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x5B88, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3A85,
   0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x4584, 0x3E80, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x3E80, 0x3E80, 0x5C09,
   0x5C89, 0x5D09, 0x5D89, 0x5E09, 0x5E89, 0x5F09, 0x5F89, 0x6009, 0x6089, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3E80,
   0x3E80, 0x5C09, 0x5C89, 0x5D09, 0x5D89, 0x5E09, 0x5E89, 0x5F09, 0x5F89, 0x6009, 0x6089, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
   0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606,
   0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x5087, 0x5087, 0x5087, 0x5B88, 0x4606, 0x4606, 0x4606, 0x3E80,
   0x3E80, 0x5B88, 0x5B88, 0x5B88, 0x3E80, 0x5B88, 0x5B88, 0x5B88, 0x4606, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
   0x3E80, 0x3E80, 0x5B88, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
   0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3E80, 0x4606, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x5B88, 0x5B88, 0x5B88, 0x4606, 0x4606, 0x4606,
   0x3E80, 0x4606, 0x3E80, 0x5B88, 0x5B88, 0x5B88, 0x5B88, 0x5B88, 0x5B88, 0x5B88, 0x5B88, 0x4606, 0x5B88, 0x5B88, 0x4606, 0x4606,
   0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x4606, 0x5198, 0x5198, 0x5198, 0x5198, 0x5198, 0x5198, 0x5198,
   0x39A, 0x5198, 0x3E80, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x4584, 0x4606, 0x4606, 0x4606, 0x4606,
   0x4606, 0x4606, 0x4606, 0x4606, 0x5198, 0x5C09, 0x5C89, 0x5D09, 0x5D89, 0x5E09, 0x5E89, 0x5F09, 0x5F89, 0x6009, 0x6089, 0x5198,
   0x5198, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3A85, 0x501C, 0x501C, 0x501C, 0x5198, 0x5198, 0x5198, 0x5198, 0x5198, 0x5198, 0x5198,
   0x5198, 0x65B8, 0x5198, 0x5198, 0x5198, 0x5198, 0x5198, 0x5198, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x4606, 0x4606, 0x501C,
   0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x4606, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x3E80, 0x3E80, 0x501C, 0x3E80,
   0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x289C,
   0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3A85,
   0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
   0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
   0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
   0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
   0x3A85, 0x3A85, 0x1A97, 0x4584, 0x4584, 0x4584, 0x3E80, 0x5C09, 0x5C89, 0x5D09, 0x5D89, 0x5E09, 0x5E89, 0x5F09, 0x5F89, 0x6009,
   0x6089, 0x5198, 0x5198, 0x5198, 0x5198, 0x5198, 0x5198, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x5B88, 0x5B88, 0x4606,
   0x4606, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x20C, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
   0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
   0x3A85, 0x3A85, 0x6615, 0x6696, 0x3E80, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
   0x3A85, 0x3A85, 0x5198, 0x5198, 0x5198, 0x6B8B, 0x6C0B, 0x6C8B, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
   0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
   0x4606, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
   0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001,
   0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x3001, 0x3082, 0x2E82, 0x2E82, 0x2E82,
   0x2E82, 0x2E82, 0x6D02, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x6D82, 0x6D82, 0x6D82, 0x6D82, 0x6D82, 0x6D82, 0x6D82, 0x6D82, 0x6E01,
   0x6E01, 0x6E01, 0x6E01, 0x6E01, 0x6E01, 0x6E01, 0x6E01, 0x6D82, 0x6D82, 0x6D82, 0x6D82, 0x6D82, 0x6D82, 0x6D82, 0x6D82, 0x6E01,
   0x6E01, 0x6E01, 0x6E01, 0x6E01, 0x6E01, 0x6E01, 0x6E01, 0x6D82, 0x6D82, 0x6D82, 0x6D82, 0x6D82, 0x6D82, 0x3E80, 0x3E80, 0x6E01,
   0x6E01, 0x6E01, 0x6E01, 0x6E01, 0x6E01, 0x3E80, 0x3E80, 0x2E82, 0x6D82, 0x4902, 0x6D82, 0x4902, 0x6D82, 0x4902, 0x6D82, 0x3E80,
   0x6E01, 0x3E80, 0x6E01, 0x3E80, 0x6E01, 0x3E80, 0x6E01, 0x6D82, 0x6D82, 0x6D82, 0x6D82, 0x6D82, 0x6D82, 0x6D82, 0x6D82, 0x6E01,
   0x6E01, 0x6E01, 0x6E01, 0x6E01, 0x6E01, 0x6E01, 0x6E01, 0x6E82, 0x6E82, 0x6F02, 0x6F02, 0x6F02, 0x6F02, 0x6F82, 0x6F82, 0x7002,
   0x7002, 0x7082, 0x7082, 0x7102, 0x7102, 0x3E80, 0x3E80, 0x7182, 0x7182, 0x7182, 0x7182, 0x7182, 0x7182, 0x7182, 0x7182, 0x7203,
   0x7203, 0x7203, 0x7203, 0x7203, 0x7203, 0x7203, 0x7203, 0x7182, 0x7182, 0x7182, 0x7182, 0x7182, 0x7182, 0x7182, 0x7182, 0x7203,
   0x7203, 0x7203, 0x7203, 0x7203, 0x7203, 0x7203, 0x7203, 0x6D82, 0x6D82, 0x2E82, 0x7282, 0x2E82, 0x3E80, 0x2E82, 0x4902, 0x6E01,
   0x6E01, 0x7301, 0x7301, 0x7383, 0x1A1B, 0x7402, 0x1A1B, 0x1B02, 0x1B82, 0x1C02, 0x1C82, 0x1D02, 0x1D82, 0x1E02, 0x1E82, 0x1F02,
   0x1F82, 0x2002, 0x2082, 0x2102, 0x2182, 0x2202, 0x2282, 0x2302, 0x2382, 0x2402, 0x2482, 0x2502, 0x2582, 0x2602, 0x2682, 0x2702,
   0x2782, 0x6615, 0xC99, 0x6696, 0xC99, 0x3E80, 0x6D82, 0x6D82, 0x4902, 0x4902, 0x2E82, 0x7582, 0x2E82, 0x4902, 0x6E01, 0x6E01,
   0x7601, 0x7601, 0x7681, 0x1A1B, 0x1A1B, 0x1A1B, 0x3E80, 0x3E80, 0x2E82, 0x7282, 0x2E82, 0x3E80, 0x2E82, 0x4902, 0x7701, 0x7701,
   0x7781, 0x7781, 0x7383, 0x1A1B, 0x1A1B, 0x3E80, 0x20C, 0x20C, 0x20C, 0x20C, 0x20C, 0x20C, 0x20C, 0x782C, 0x20C, 0x20C,
   0x20C, 0x788C, 0x5B10, 0x5B10, 0x7910, 0x7990, 0x2A14, 0x7A34, 0x2A14, 0x2A14, 0x2A14, 0x2A14, 0x298, 0x298, 0x7A9D, 0x7B1E,
   0x6615, 0x7A9D, 0x7A9D, 0x7B1E, 0x6615, 0x7A9D, 0x298, 0x298, 0x298, 0x298, 0x298, 0x298, 0x298, 0x298, 0x7B8D, 0x7C0E,
   0x7C90, 0x7D10, 0x7D90, 0x7E10, 0x7E90, 0x782C, 0x318, 0x318, 0x318, 0x318, 0x318, 0x298, 0x298, 0x298, 0x298, 0x29DD,
   0x2D5E, 0x298, 0x298, 0x298, 0x298, 0x1A97, 0x7F0B, 0x2C8B, 0x2B0B, 0x2B8B, 0x7F8B, 0x800B, 0x808B, 0x810B, 0x818B, 0x820B,
   0x519, 0x519, 0xC99, 0x455, 0x4D6, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
   0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
   0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3E80, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C,
   0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x289C,
   0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x4D01, 0x289C, 0x289C, 0x289C, 0x289C, 0x4D01, 0x289C, 0x289C, 0x2902, 0x4D01,
   0x4D01, 0x4D01, 0x2902, 0x2902, 0x4D01, 0x4D01, 0x4D01, 0x2902, 0x289C, 0x4D01, 0x289C, 0x289C, 0x289C, 0x4D01, 0x4D01, 0x4D01,
   0x4D01, 0x4D01, 0x289C, 0x289C, 0xA20A, 0xA28A, 0xA30A, 0xA38A, 0xA40A, 0xA48A, 0xA50A, 0xA58A, 0xA60A, 0x4606, 0x4606, 0x4606,
   0x4606, 0x4606, 0x4606, 0x2A14, 0x4584, 0x4584, 0x4584, 0x4584, 0x4584, 0x289C, 0x289C, 0xA68A, 0xA70A, 0xA78A, 0x3E80, 0x3E80,
   0x3E80, 0x289C, 0x289C, 0x289C, 0x289C, 0x3E80, 0x289C, 0x289C, 0x289C, 0x289C, 0x3E80, 0x3E80, 0x289C, 0x289C, 0x289C, 0x289C,
   0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C,
   0x289C, 0x289C, 0x289C, 0xC99, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C,
   0x289C, 0x289C, 0xC99, 0xC99, 0x289C, 0x289C, 0xC99, 0x289C, 0xC99, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C,
   0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0xC99, 0x289C, 0x289C, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
   0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x948A, 0x950A, 0x958A, 0x960A, 0x3E80, 0x3E80, 0x3E80,
   0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0xC99, 0xC99, 0xC99, 0xC99, 0xC99, 0x289C, 0x289C,
   0x289C, 0x289C, 0x289C, 0xC99, 0xC99, 0x289C, 0x289C, 0x289C, 0x289C, 0x4D01, 0x289C, 0x8281, 0x289C, 0x4D01, 0x289C, 0x8301,
   0x8381, 0x4D01, 0x4D01, 0x2A9C, 0x2902, 0x4D01, 0x4D01, 0x289C, 0x4D01, 0x2902, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x2902, 0x289C,
   0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x848A, 0x850A, 0x858A, 0x860A, 0x868A, 0x870A, 0x878A, 0x880A, 0x888A, 0x890A, 0x898A,
   0x8A0A, 0x8A8A, 0x8B0A, 0x8B8A, 0x8C0A, 0x8C8A, 0x8D0A, 0x8D8A, 0x8E0A, 0x8E8A, 0x8F0A, 0x8F8A, 0x900A, 0x908A, 0x910A, 0x918A,
   0x920A, 0x928A, 0x930A, 0x938A, 0x940A, 0xC99, 0xC99, 0xC59, 0xC59, 0xC99, 0xC99, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59,
   0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC99, 0xC99,
   0xC99, 0xC99, 0xC99, 0xC59, 0xC59, 0xC59, 0xC59, 0xC99, 0xC99, 0xC99, 0xC99, 0xC99, 0xC99, 0xC99, 0xC99, 0xC99,
   0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC99, 0xC99, 0xC59, 0xC59, 0xC99, 0xC99, 0xC99, 0xC99, 0xC59, 0xC59, 0xC59,
   0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC99, 0xC99, 0xC59, 0xC59, 0xC59, 0xC59,
   0xC99, 0xC99, 0xC99, 0xC99, 0xC99, 0xC59, 0xC99, 0xC99, 0xC99, 0xC99, 0xC99, 0xC99, 0xC99, 0x289C, 0x289C, 0xC99,
   0x289C, 0x289C, 0xC99, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0xC99, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C,
   0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C,
   0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x3E80, 0x289C, 0x289C, 0x289C, 0x289C,
   0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C,
   0x289C, 0x289C, 0x289C, 0x289C, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
   0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0xC99, 0xC59, 0xC59,
   0xC59, 0xC59, 0xC99, 0xC99, 0xC99, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC99, 0xC99, 0xC99, 0xC59, 0x519,
   0x519, 0xC99, 0xC59, 0xC59, 0xC99, 0xC99, 0xC99, 0xC59, 0xC59, 0xC59, 0xC59, 0xC99, 0xC59, 0xC99, 0xC59, 0xC99,
   0xC99, 0xC99, 0xC99, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC99, 0xC99, 0xC99, 0xC99,
   0xC99, 0xC59, 0xC99, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x455,
   0x4D6, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x501C, 0x501C, 0x501C, 0x501C,
   0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C,
   0x501C, 0x501C, 0x501C, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C,
   0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x9C1C, 0x9C1C, 0x9C1C,
   0x9C1C, 0x9C1C, 0x9C1C, 0x9C1C, 0x9C1C, 0x9C1C, 0x9C1C, 0x9C1C, 0x9C1C, 0x9C1C, 0x9C1C, 0x9C1C, 0x9C1C, 0x9C9C, 0x9C9C, 0x9C9C,
   0x9C9C, 0x9C9C, 0x9C9C, 0x9C9C, 0x9C9C, 0x9C9C, 0x9C9C, 0x9C9C, 0x9C9C, 0x9C9C, 0x9C9C, 0x9C9C, 0x9C9C, 0x7F0B, 0x3E80, 0x3E80,
   0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
   0x3E80, 0x3E80, 0x3E80, 0xC59, 0xC99, 0xC59, 0xC99, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC99,
   0xC99, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59, 0xC59,
   0xC59, 0xC59, 0xC59, 0xC99, 0xC99, 0xC59, 0xC59, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
   0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x39A, 0x39A, 0xC99, 0x1A1B, 0x289C, 0x39A, 0x39A, 0x3E80, 0x289C, 0xC99, 0xC99,
   0xC99, 0xC99, 0x289C, 0x289C, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x5B10, 0x5B10,
   0x5B10, 0x289C, 0x289C, 0x3E80, 0x3E80, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C,
   0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x3E80, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C,
   0x289C, 0x289C, 0x289C, 0x289C, 0x3E80, 0x289C, 0x3E80, 0x289C, 0x289C, 0x289C, 0x289C, 0x3E80, 0x3E80, 0x3E80, 0x289C, 0x3E80,
   0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
   0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x840B, 0x9D0B, 0x9D8B, 0x9E0B, 0x9E8B, 0x9F0B, 0x9F8B, 0xA00B, 0xA08B, 0xA10B, 0x840B,
   0x9D0B, 0x9D8B, 0x9E0B, 0x9E8B, 0x9F0B, 0x9F8B, 0xA00B, 0xA08B, 0xA10B, 0x289C, 0x3E80, 0x3E80, 0x3E80, 0x289C, 0x289C, 0x289C,
   0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0xC59, 0xC59, 0xC59, 0xC59, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C,
   0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x289C, 0x501C, 0x289C,
   0x289C, 0x289C, 0x289C, 0x289C, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x630B, 0x630B, 0x630B, 0x630B, 0x630B, 0x630B, 0x630B,
   0x630B, 0x630B, 0x630B, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C,
   0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C,
   0x501C, 0x501C, 0x501C, 0x3E80, 0x3E80, 0x3E80, 0x501C, 0x610B, 0x618B, 0x620B, 0x628B, 0xA80B, 0xA88B, 0xA90B, 0xA98B, 0xAA0B,
   0x640B, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C,
   0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x289C, 0x3E80, 0x289C, 0x289C,
   0x289C, 0x3E80, 0x289C, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
   0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x2C8B, 0x2B0B, 0x2B8B, 0x7F8B,
   0x800B, 0x808B, 0x810B, 0x818B, 0x820B, 0x968B, 0x970B, 0x978B, 0x980B, 0x988B, 0x990B, 0x998B, 0x9A0B, 0x9A8B, 0x9B0B, 0x9B8B,
   0x2C8B, 0x2B0B, 0x2B8B, 0x7F8B, 0x800B, 0x808B, 0x810B, 0x818B, 0x820B, 0x968B, 0x970B, 0x978B, 0x980B, 0x988B, 0x990B, 0x998B,
   0x9A0B, 0x9A8B, 0x9B0B, 0x9B8B, 0x501C, 0x501C, 0x501C, 0x501C, 0x20C, 0x298, 0x298, 0x298, 0x289C, 0x4584, 0x3A85, 0xA18A,
   0x455, 0x4D6, 0x455, 0x4D6, 0x455, 0x4D6, 0x455, 0x4D6, 0x455, 0x4D6, 0x289C, 0x289C, 0x455, 0x4D6, 0x455, 0x4D6,
   0x455, 0x4D6, 0x455, 0x4D6, 0x2A14, 0x6615, 0x6696, 0x6696, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
   0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x3E80, 0x3E80,
   0x3E80, 0x4606, 0x4606, 0x1A1B, 0x1A1B, 0x4584, 0x4584, 0x3E80, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85,
   0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3A85, 0x3E80, 0x501C, 0x501C, 0x630B, 0x630B, 0x630B, 0x630B, 0x501C, 0x501C,
   0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x501C, 0x3E80,
   0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
   0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0xAA93, 0xAA93, 0xAA93, 0xAA93, 0xAA93,
   0xAA93, 0xAA93, 0xAA93, 0xAA93, 0xAA93, 0xAA93, 0xAA93, 0xAA93, 0xAA93, 0xAA93, 0xAA93, 0xAA93, 0xAA93, 0xAA93, 0xAA93, 0xAA93,
   0xAA93, 0xAA93, 0xAA93, 0xAA93, 0xAA93, 0xAA93, 0xAA93, 0xAA93, 0xAA93, 0xAA93, 0xAA93, 0xAB12, 0xAB12, 0xAB12, 0xAB12, 0xAB12,
   0xAB12, 0xAB12, 0xAB12, 0xAB12, 0xAB12, 0xAB12, 0xAB12, 0xAB12, 0xAB12, 0xAB12, 0xAB12, 0xAB12, 0xAB12, 0xAB12, 0xAB12, 0xAB12,
   0xAB12, 0xAB12, 0xAB12, 0xAB12, 0xAB12, 0xAB12, 0xAB12, 0xAB12, 0xAB12, 0xAB12, 0xAB12, 0x5305, 0x5305, 0x5305, 0x5305, 0x5305,
   0x5305, 0x5305, 0x5305, 0x5305, 0x519, 0x5305, 0x5305, 0x5305, 0x5305, 0x5305, 0x5305, 0x5305, 0x5305, 0x5305, 0x5305, 0x5305,
   0x5305, 0x5305, 0x3E80, 0x5305, 0x5305, 0x5305, 0x5305, 0x5305, 0x3E80, 0x5305, 0x3E80, 0x4606, 0x4606, 0x4606, 0x4606, 0x3E80,
   0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x3E80, 0x298, 0x2A14, 0x2A14, 0x1A97, 0x1A97,
   0x6615, 0x6696, 0x6615, 0x6696, 0x6615, 0x6696, 0x6615, 0x6696, 0x6615, 0x6696, 0x6615, 0x6696, 0x3E80, 0x3E80, 0x3E80, 0x3E80,
   0x298, 0x298, 0x298, 0x298, 0x1A97, 0x1A97, 0x1A97, 0x598, 0x298, 0x598, 0x3E80, 0x298, 0x598, 0x298, 0x298, 0x2A14,
   0x6615, 0x6696, 0x6615, 0x6696, 0x6615, 0x6696, 0x318, 0x298, 0xD01, 0xD81, 0xE01, 0xE81, 0xF01, 0xF81, 0x1001, 0x1081,
   0x1101, 0x1181, 0x1201, 0x1281, 0x1301, 0x1381, 0x1401, 0x1481, 0x1501, 0x1581, 0x1601, 0x1681, 0x1701, 0x1781, 0x1801, 0x1881,
   0x1901, 0x1981, 0x6615, 0x298, 0x6696, 0x1A1B, 0x1A97,
};

static int16_t Upper[] = {
   0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
   0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
   0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
   0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xFFE0, 0xFFE0, 0xFFE0, 0xFFE0, 0xFFE0, 0xFFE0, 0xFFE0, 0xFFE0, 0xFFE0, 0xFFE0,
   0xFFE0, 0xFFE0, 0xFFE0, 0xFFE0, 0xFFE0, 0xFFE0, 0xFFE0, 0xFFE0, 0xFFE0, 0xFFE0, 0xFFE0, 0xFFE0, 0xFFE0, 0xFFE0, 0xFFE0, 0xFFE0,
   0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2E7, 0x0, 0x0, 0x0, 0x0, 0x0, 0xFFE0, 0x79,
   0x0, 0xFFFF, 0x0, 0xFF18, 0x0, 0xFED4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x61, 0x0, 0x0,
   0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x38, 0x0, 0xFFFF, 0xFFFE, 0xFFB1, 0x0, 0x0, 0x0, 0xFF2E, 0xFF32,
   0xFF33, 0xFF36, 0xFF35, 0xFF31, 0xFF2F, 0xFF2D, 0xFF2B, 0xFF2A, 0xFF26, 0xFF27, 0xFF25, 0x0, 0x0, 0x54, 0x0, 0x0,
   0x0, 0x0, 0x0, 0xFFDA, 0xFFDB, 0xFFE1, 0xFFC0, 0xFFC1, 0xFFC2, 0xFFC7, 0x0, 0xFFD1, 0xFFCA, 0xFFAA, 0xFFB0, 0x0,
   0x0, 0x0, 0x0, 0x0, 0xFFD0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
   0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
   0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
   0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xFFC5, 0x8, 0x0, 0x4A, 0x56, 0x64,
   0x80, 0x70, 0x7E, 0x8, 0x0, 0x9, 0x0, 0x0, 0xE3DB, 0x0, 0x0, 0x7, 0x0, 0x0, 0x0, 0x0,
   0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
   0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
   0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0,
   0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0xFFF0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
   0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xFFE6, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
   0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
   0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
};

static int16_t Lower[] = {
   0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
   0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
   0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
   0x20, 0x20, 0x20, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
   0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
   0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20, 0x0, 0x0, 0x0,
   0x1, 0x0, 0xFF39, 0x0, 0xFF87, 0x0, 0xD2, 0xCE, 0xCD, 0x4F, 0xCA, 0xCB, 0xCF, 0x0, 0xD3, 0xD1,
   0xD5, 0xD6, 0xDA, 0xD9, 0xDB, 0x0, 0x0, 0x2, 0x1, 0x0, 0x0, 0xFF9F, 0xFFC8, 0x0, 0x0, 0x0,
   0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x26, 0x25,
   0x40, 0x3F, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x50,
   0x0, 0x0, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
   0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
   0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
   0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xFFF8, 0x0, 0x0, 0x0,
   0x0, 0x0, 0x0, 0x0, 0xFFF8, 0x0, 0xFFB6, 0xFFF7, 0x0, 0xFFAA, 0xFF9C, 0x0, 0xFF90, 0xFFF9, 0xFF80, 0xFF82,
   0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
   0x0, 0x0, 0x0, 0x0, 0x0, 0xE2A3, 0xDF41, 0xDFBA, 0x0, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
   0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
   0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
   0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1A, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
   0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
   0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
};

static inline int32_t charType(int32_t c) {return Data[Blocks[c>>5]+c & 0xFFFF] & 0x1F;}

int isLowc(int32_t c) {
   if (c > 0xFFFF)
      return 0;
   return charType(c) == CHAR_LOWERCASE;
}

int isUppc(int32_t c) {
   if (c > 0xFFFF)
      return 0;
   return charType(c) == CHAR_UPPERCASE;
}

int isLetterOrDigit(int32_t c) {
   if (c > 0xFFFF)
      return 0;
   return (1 << charType(c) & (CHAR_DIGIT | CHAR_LETTER)) != 0;
}

int32_t toUpperCase(int32_t c) {
   if (c > 0xFFFF)
      return c;
   return c + Upper[Data[Blocks[c>>5]+c & 0xFFFF] >> 7];
}

int32_t toLowerCase(int32_t c) {
   if (c > 0xFFFF)
      return c;
   return c + Lower[Data[Blocks[c>>5]+c & 0xFFFF] >> 7];
}
pil21/src/base.ll0000644000000000000000001515650614771742740010765 0ustar  source_filename = "base.l"

declare {i64, i1} @llvm.uadd.with.overflow.i64(i64, i64)
declare {i64, i1} @llvm.usub.with.overflow.i64(i64, i64)
declare i64 @llvm.fshl.i64(i64, i64, i64)
declare i64 @llvm.fshr.i64(i64, i64, i64)
declare void @llvm.memcpy.p0i8.p0i8.i64(i8*, i8*, i64, i1)
declare void @llvm.memset.p0i8.i64(i8*, i8, i64, i1)
declare i8* @llvm.stacksave()
declare void @llvm.stackrestore(i8*)

@$AV0 = global i8* null
@$AV = global i8** null
@$PilHome = global i8* null
@$PilLen = global i64 0
@$UsrHome = global i8* null
@$UsrLen = global i64 0
@$Heaps = global i64 0
@$Avail = global i64 0
@$Extern = global i64 0
@$ExtCnt = global i64 1
@$ExtSkip = global i64 0
@$Coroutines = global i8* null
@$Current = global i8* null
@$CrtLast = global i8* null
@$CrtFree = global i8* null
@$StkLimit = global i8* null
@$StkSizeT = global i64 262144
@$StkSize = global i64 65536
@$Stdin = global i8* null
@$Stdout = global i8* null
@$LinePtr = global i8* null
@$LineBuf = global i8* null
@$LinePrmt = global i8* null
@$ReplPrmt = global i8* null
@$ContPrmt = global i8* null
@$Ret = global i64 0
@$TtyPid = global i32 0
@$InFDs = global i32 0
@$InFiles = global i8** null
@$OutFiles = global i8** null
@$IoCnt = global i32 0
@$IoIx = global i64 0
@$IoChar = global i64 0
@$PutBin = global void(i8)* null
@$GetBin = global i32()* null
@$OutFDs = global i32 0
@$Nfds = global i32 0
@$Poll = global i64* null
@$SeedL = global i64 0
@$SeedH = global i64 0
@$USec = global i64 0
@$Rt = global i64 0
@$Child = global i8* null
@$Children = global i32 0
@$Slot = global i32 0
@$Spkr = global i32 0
@$Mic = global i32 0
@$SpMiPipe = global [2 x i32] [
  i32 0,
  i32 0
]
@$Talking = global i32 0
@$Hear = global i32 0
@$Tell = global i32 0
@$TellBuf = global i8* null
@$Ptr = global i8* null
@$End = global i8* null
@$BufX = global i8* null
@$PtrX = global i8* null
@$EndX = global i8* null
@$ExtN = global i32 0
@$Extn = global i32 0
@$StrP = global i64* null
@$GcCount = global i64 65536
@$DbFiles = global i8* null
@$DbFile = global i8* null
@$DBs = global i32 0
@$MaxBlkSize = global i32 0
@$DbBlock = global i8* null
@$BlkIndex = global i64 0
@$BlkLink = global i64 0
@$BlkPtr = global i8* null
@$BlkEnd = global i8* null
@$DbJnl = global i8* null
@$DbLog = global i8* null
@$Signal = global [16 x i32] [
  i32 0,
  i32 0,
  i32 0,
  i32 0,
  i32 0,
  i32 0,
  i32 0,
  i32 0,
  i32 0,
  i32 0,
  i32 0,
  i32 0,
  i32 0,
  i32 0,
  i32 0,
  i32 0
]
@SymTab = global [888 x i64] [
  ; # [0] NIL
  i64 79992034,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 0,
  ; # [32] ~
  i64 2018,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 40) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 40) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 48) to i64),
  ; # [80] pico
  i64 29900576514,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 64) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 88) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 40) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 112) to i64),
  ; # [144] priv
  i64 31785953026,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 128) to i64),
  ; # [160] *OS
  i64 87356066,
  i64 0,
  ; # [176] *CPU
  i64 22901174946,
  i64 0,
  ; # [192] *Pid
  i64 26953974434,
  i64 0,
  ; # [208] *PPid
  i64 6900217610914,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  ; # [224] *DB
  i64 69485218,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  ; # [240] meth
  i64 28039337682,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64,i64)* @__Meth to i8*), i32 2) to i64),
  ; # [256] quote
  i64 6971922536210,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Quote to i8*), i32 2) to i64),
  ; # [272] T
  i64 1346,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64),
  ; # [288] N
  i64 1250,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  ; # [304] C
  i64 1074,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  ; # [320] S
  i64 1330,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  ; # [336] B
  i64 1058,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  ; # [352] I
  i64 1170,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  ; # [368] P
  i64 1282,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  ; # [384] W
  i64 1394,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 0,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  ; # [416] *Solo
  i64 7656969679522,
  i64 2,
  ; # [432] @
  i64 1026,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  ; # [448] @@
  i64 263170,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  ; # [464] @@@
  i64 67372034,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  ; # [480] This
  i64 30980605250,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  ; # [496] *Prompt
  i64 524395401951117986,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  ; # [512] *Zap
  i64 30166852258,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  ; # [528] *Ext
  i64 31264625314,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  ; # [544] *Scl
  i64 29095178914,
  i64 2,
  ; # [560] *Rule
  i64 6969781199522,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  ; # [576] *Class
  i64 2031030286693026,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  ; # [592] *Run
  i64 29650920098,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  ; # [608] *Hup
  i64 30187750050,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  ; # [624] *Sig1
  i64 3395013653154,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  ; # [640] *Sig2
  i64 3463733129890,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  ; # [656] *Winch
  i64 1836420215173794,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  ; # [672] *TStp1
  i64 869744923460258,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  ; # [688] *TStp2
  i64 887337109504674,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  ; # [704] *Term
  i64 7521130857122,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  ; # [720] ^
  i64 1506,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  ; # [736] *Err
  i64 30721462946,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  ; # [752] *Msg
  i64 27769754274,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  ; # [768] *Uni
  i64 28301415074,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  ; # [784] *Fork
  i64 7383702332066,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  ; # [800] *Bye
  i64 27239129762,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  ; # [816] *Dbg
  i64 27751891618,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  ; # [832] complete
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 852) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 7310579611546251107,
  i64 2,
  ; # [864] remark
  i64 1890224080049954,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  ; # [880] gc
  i64 407154,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Gc to i8*), i32 2) to i64),
  ; # [896] format
  i64 2047388749854306,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Format to i8*), i32 2) to i64),
  ; # [912] +
  i64 690,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Add to i8*), i32 2) to i64),
  ; # [928] -
  i64 722,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Sub to i8*), i32 2) to i64),
  ; # [944] inc
  i64 104261266,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Inc to i8*), i32 2) to i64),
  ; # [960] dec
  i64 104224322,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Dec to i8*), i32 2) to i64),
  ; # [976] *
  i64 674,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Mul to i8*), i32 2) to i64),
  ; # [992] */
  i64 193186,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_MulDiv to i8*), i32 2) to i64),
  ; # [1008] /
  i64 754,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Div to i8*), i32 2) to i64),
  ; # [1024] %
  i64 594,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Rem to i8*), i32 2) to i64),
  ; # [1040] >>
  i64 254946,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Shr to i8*), i32 2) to i64),
  ; # [1056] rev
  i64 124147490,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Rev to i8*), i32 2) to i64),
  ; # [1072] lt0
  i64 50808514,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Lt0 to i8*), i32 2) to i64),
  ; # [1088] le0
  i64 50747074,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Le0 to i8*), i32 2) to i64),
  ; # [1104] ge0
  i64 50746994,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Ge0 to i8*), i32 2) to i64),
  ; # [1120] gt0
  i64 50808434,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Gt0 to i8*), i32 2) to i64),
  ; # [1136] abs
  i64 120989202,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Abs to i8*), i32 2) to i64),
  ; # [1152] bit?
  i64 17033500194,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_BitQ to i8*), i32 2) to i64),
  ; # [1168] &
  i64 610,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_BitAnd to i8*), i32 2) to i64),
  ; # [1184] |
  i64 1986,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_BitOr to i8*), i32 2) to i64),
  ; # [1200] x|
  i64 509826,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_BitXor to i8*), i32 2) to i64),
  ; # [1216] sqrt
  i64 31258515250,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Sqrt to i8*), i32 2) to i64),
  ; # [1232] seed
  i64 26949867314,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Seed to i8*), i32 2) to i64),
  ; # [1248] hash
  i64 28038272642,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Hash to i8*), i32 2) to i64),
  ; # [1264] rand
  i64 26959288098,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Rand to i8*), i32 2) to i64),
  ; # [1280] name
  i64 27226674914,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Name to i8*), i32 2) to i64),
  ; # [1296] nsp
  i64 117913314,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Nsp to i8*), i32 2) to i64),
  ; # [1312] sp?
  i64 66520882,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_SpQ to i8*), i32 2) to i64),
  ; # [1328] pat?
  i64 17033467650,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_PatQ to i8*), i32 2) to i64),
  ; # [1344] fun?
  i64 17027257954,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_FunQ to i8*), i32 2) to i64),
  ; # [1360] getd
  i64 26965595762,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Getd to i8*), i32 2) to i64),
  ; # [1376] all
  i64 113690130,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_All to i8*), i32 2) to i64),
  ; # [1392] symbols
  i64 519821567523788594,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Symbols to i8*), i32 2) to i64),
  ; # [1408] intern
  i64 1943001719301778,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Intern to i8*), i32 2) to i64),
  ; # [1424] ====
  i64 16438776786,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Hide to i8*), i32 2) to i64),
  ; # [1440] box?
  i64 17037719074,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_BoxQ to i8*), i32 2) to i64),
  ; # [1456] str?
  i64 17031448370,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_StrQ to i8*), i32 2) to i64),
  ; # [1472] zap
  i64 117839778,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Zap to i8*), i32 2) to i64),
  ; # [1488] chop
  i64 30181590578,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Chop to i8*), i32 2) to i64),
  ; # [1504] pack
  i64 28826801922,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Pack to i8*), i32 2) to i64),
  ; # [1520] glue
  i64 27235108466,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Glue to i8*), i32 2) to i64),
  ; # [1536] text
  i64 31264757570,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Text to i8*), i32 2) to i64),
  ; # [1552] pre?
  i64 17017808642,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_PreQ to i8*), i32 2) to i64),
  ; # [1568] sub?
  i64 17014675250,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_SubQ to i8*), i32 2) to i64),
  ; # [1584] val
  i64 113645410,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Val to i8*), i32 2) to i64),
  ; # [1600] set
  i64 122050354,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Set to i8*), i32 2) to i64),
  ; # [1616] setq
  i64 30455256882,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Setq to i8*), i32 2) to i64),
  ; # [1632] swap
  i64 30166972210,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Swap to i8*), i32 2) to i64),
  ; # [1648] xchg
  i64 27758311298,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Xchg to i8*), i32 2) to i64),
  ; # [1664] on
  i64 452338,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_On to i8*), i32 2) to i64),
  ; # [1680] off
  i64 107374322,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Off to i8*), i32 2) to i64),
  ; # [1696] onOff
  i64 7036850333426,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_OnOff to i8*), i32 2) to i64),
  ; # [1712] zero
  i64 29916288930,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Zero to i8*), i32 2) to i64),
  ; # [1728] one
  i64 106358514,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_One to i8*), i32 2) to i64),
  ; # [1744] default
  i64 524325579192161858,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Default to i8*), i32 2) to i64),
  ; # [1760] push
  i64 28038354690,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Push to i8*), i32 2) to i64),
  ; # [1776] push1
  i64 3395292714754,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Push1 to i8*), i32 2) to i64),
  ; # [1792] push1q
  i64 1991312315733762,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Push1q to i8*), i32 2) to i64),
  ; # [1808] pop
  i64 117896962,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Pop to i8*), i32 2) to i64),
  ; # [1824] ++
  i64 176818,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Popq to i8*), i32 2) to i64),
  ; # [1840] shift
  i64 7998950246194,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Shift to i8*), i32 2) to i64),
  ; # [1856] cut
  i64 122115634,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Cut to i8*), i32 2) to i64),
  ; # [1872] del
  i64 113661506,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Del to i8*), i32 2) to i64),
  ; # [1888] queue
  i64 6972180485906,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Queue to i8*), i32 2) to i64),
  ; # [1904] fifo
  i64 29903722082,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Fifo to i8*), i32 2) to i64),
  ; # [1920] rid
  i64 105289506,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Rid to i8*), i32 2) to i64),
  ; # [1936] enum
  i64 29382600274,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Enum to i8*), i32 2) to i64),
  ; # [1952] enum?
  i64 4358709634642,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_EnumQ to i8*), i32 2) to i64),
  ; # [1968] idx
  i64 126240402,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Idx to i8*), i32 2) to i64),
  ; # [1984] lup
  i64 117921474,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Lup to i8*), i32 2) to i64),
  ; # [2000] put
  i64 122115842,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Put to i8*), i32 2) to i64),
  ; # [2016] get
  i64 122050162,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Get to i8*), i32 2) to i64),
  ; # [2032] prop
  i64 30181631746,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Prop to i8*), i32 2) to i64),
  ; # [2048] ;
  i64 946,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Semicol to i8*), i32 2) to i64),
  ; # [2064] =:
  i64 238546,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_SetCol to i8*), i32 2) to i64),
  ; # [2080] :
  i64 930,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Col to i8*), i32 2) to i64),
  ; # [2096] ::
  i64 238498,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_PropCol to i8*), i32 2) to i64),
  ; # [2112] putl
  i64 29113145090,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Putl to i8*), i32 2) to i64),
  ; # [2128] getl
  i64 29113079410,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Getl to i8*), i32 2) to i64),
  ; # [2144] wipe
  i64 27229853554,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Wipe to i8*), i32 2) to i64),
  ; # [2160] meta
  i64 26160289490,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Meta to i8*), i32 2) to i64),
  ; # [2176] low?
  i64 17036670658,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_LowQ to i8*), i32 2) to i64),
  ; # [2192] upp?
  i64 17029334866,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_UppQ to i8*), i32 2) to i64),
  ; # [2208] lowc
  i64 26700347074,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Lowc to i8*), i32 2) to i64),
  ; # [2224] uppc
  i64 26693011282,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Uppc to i8*), i32 2) to i64),
  ; # [2240] fold
  i64 26957248098,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Fold to i8*), i32 2) to i64),
  ; # [2256] path
  i64 28039321346,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Path to i8*), i32 2) to i64),
  ; # [2272] wait
  i64 31249012594,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Wait to i8*), i32 2) to i64),
  ; # [2288] sync
  i64 26690950962,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Sync to i8*), i32 2) to i64),
  ; # [2304] hear
  i64 30703769218,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Hear to i8*), i32 2) to i64),
  ; # [2320] tell
  i64 29104691010,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Tell to i8*), i32 2) to i64),
  ; # [2336] poll
  i64 29104731906,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Poll to i8*), i32 2) to i64),
  ; # [2352] read
  i64 26945672994,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Read to i8*), i32 2) to i64),
  ; # [2368] key
  i64 127293106,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Key to i8*), i32 2) to i64),
  ; # [2384] peek
  i64 28828915458,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Peek to i8*), i32 2) to i64),
  ; # [2400] char
  i64 30703781426,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Char to i8*), i32 2) to i64),
  ; # [2416] skip
  i64 30175311666,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Skip to i8*), i32 2) to i64),
  ; # [2432] eol
  i64 113702482,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Eol to i8*), i32 2) to i64),
  ; # [2448] eof
  i64 107411026,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Eof to i8*), i32 2) to i64),
  ; # [2464] from
  i64 29376325218,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_From to i8*), i32 2) to i64),
  ; # [2480] till
  i64 29104707394,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Till to i8*), i32 2) to i64),
  ; # [2496] line
  i64 27227756226,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Line to i8*), i32 2) to i64),
  ; # [2512] in
  i64 452242,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_In to i8*), i32 2) to i64),
  ; # [2528] out
  i64 122115826,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Out to i8*), i32 2) to i64),
  ; # [2544] err
  i64 120006226,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Err to i8*), i32 2) to i64),
  ; # [2560] ctl
  i64 113722930,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Ctl to i8*), i32 2) to i64),
  ; # [2576] input
  i64 8002984142482,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Input to i8*), i32 2) to i64),
  ; # [2592] output
  i64 2048763946817266,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Output to i8*), i32 2) to i64),
  ; # [2608] fd
  i64 411234,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Fd to i8*), i32 2) to i64),
  ; # [2624] pipe
  i64 27229853442,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Pipe to i8*), i32 2) to i64),
  ; # [2640] open
  i64 29634266866,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Open to i8*), i32 2) to i64),
  ; # [2656] close
  i64 6971654063666,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Close to i8*), i32 2) to i64),
  ; # [2672] echo
  i64 29905794642,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Echo to i8*), i32 2) to i64),
  ; # [2688] prin
  i64 29638469378,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Prin to i8*), i32 2) to i64),
  ; # [2704] prinl
  i64 7451341956866,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Prinl to i8*), i32 2) to i64),
  ; # [2720] space
  i64 6967344432946,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Space to i8*), i32 2) to i64),
  ; # [2736] print
  i64 8001097770754,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Print to i8*), i32 2) to i64),
  ; # [2752] printsp
  i64 506434260758374146,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Printsp to i8*), i32 2) to i64),
  ; # [2768] println
  i64 497303916201322242,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Println to i8*), i32 2) to i64),
  ; # [2784] flush
  i64 7177818785378,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Flush to i8*), i32 2) to i64),
  ; # [2800] rewind
  i64 1766806057801506,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Rewind to i8*), i32 2) to i64),
  ; # [2816] ext
  i64 122127954,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Ext to i8*), i32 2) to i64),
  ; # [2832] plio
  i64 29906880258,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Plio to i8*), i32 2) to i64),
  ; # [2848] rd
  i64 411426,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Rd to i8*), i32 2) to i64),
  ; # [2864] pr
  i64 468738,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Pr to i8*), i32 2) to i64),
  ; # [2880] wr
  i64 468850,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Wr to i8*), i32 2) to i64),
  ; # [2896] any
  i64 127329810,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Any to i8*), i32 2) to i64),
  ; # [2912] sym
  i64 114792242,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Sym to i8*), i32 2) to i64),
  ; # [2928] str
  i64 120014642,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Str to i8*), i32 2) to i64),
  ; # [2944] load
  i64 26945713858,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Load to i8*), i32 2) to i64),
  ; # [2960] ext?
  i64 17033561682,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_ExtQ to i8*), i32 2) to i64),
  ; # [2976] rollback
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 2996) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Rollback to i8*), i32 2) to i64),
  i64 7738135660106379122,
  i64 2,
  ; # [3008] extern
  i64 1943001719342674,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Extern to i8*), i32 2) to i64),
  ; # [3024] pool
  i64 29107877634,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Pool to i8*), i32 2) to i64),
  ; # [3040] pool2
  i64 3465081714434,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Pool2 to i8*), i32 2) to i64),
  ; # [3056] journal
  i64 488102791669544610,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Journal to i8*), i32 2) to i64),
  ; # [3072] id
  i64 411282,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Id to i8*), i32 2) to i64),
  ; # [3088] blk
  i64 112641570,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Blk to i8*), i32 2) to i64),
  ; # [3104] seq
  i64 118904626,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Seq to i8*), i32 2) to i64),
  ; # [3120] lieu
  i64 31513286338,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Lieu to i8*), i32 2) to i64),
  ; # [3136] lock
  i64 28826859202,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Lock to i8*), i32 2) to i64),
  ; # [3152] touch
  i64 7173523830594,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Touch to i8*), i32 2) to i64),
  ; # [3168] commit
  i64 2047938500425266,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Commit to i8*), i32 2) to i64),
  ; # [3184] mark
  i64 28842530514,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Mark to i8*), i32 2) to i64),
  ; # [3200] free
  i64 27218355810,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Free to i8*), i32 2) to i64),
  ; # [3216] dbck
  i64 28826805826,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Dbck to i8*), i32 2) to i64),
  ; # [3232] apply
  i64 8344165615122,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Apply to i8*), i32 2) to i64),
  ; # [3248] pass
  i64 30991062786,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Pass to i8*), i32 2) to i64),
  ; # [3264] fun
  i64 115824226,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Fun to i8*), i32 2) to i64),
  ; # [3280] maps
  i64 30987917010,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Maps to i8*), i32 2) to i64),
  ; # [3296] map
  i64 117839570,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Map to i8*), i32 2) to i64),
  ; # [3312] mapc
  i64 26692949714,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Mapc to i8*), i32 2) to i64),
  ; # [3328] maplist
  i64 524447902824011474,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Maplist to i8*), i32 2) to i64),
  ; # [3344] mapcar
  i64 2012201691256530,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Mapcar to i8*), i32 2) to i64),
  ; # [3360] mapcon
  i64 1942795019753170,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Mapcon to i8*), i32 2) to i64),
  ; # [3376] mapcan
  i64 1941832947078866,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Mapcan to i8*), i32 2) to i64),
  ; # [3392] filter
  i64 2012481128404578,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Filter to i8*), i32 2) to i64),
  ; # [3408] extract
  i64 524165879706388050,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Extract to i8*), i32 2) to i64),
  ; # [3424] seek
  i64 28828915506,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Seek to i8*), i32 2) to i64),
  ; # [3440] find
  i64 26959320674,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Find to i8*), i32 2) to i64),
  ; # [3456] pick
  i64 28826834690,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Pick to i8*), i32 2) to i64),
  ; # [3472] fully
  i64 8344161441378,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Fully to i8*), i32 2) to i64),
  ; # [3488] cnt
  i64 122086962,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Cnt to i8*), i32 2) to i64),
  ; # [3504] sum
  i64 114775858,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Sum to i8*), i32 2) to i64),
  ; # [3520] maxi
  i64 28311951058,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Maxi to i8*), i32 2) to i64),
  ; # [3536] mini
  i64 28301498066,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Mini to i8*), i32 2) to i64),
  ; # [3552] fish
  i64 28038305378,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Fish to i8*), i32 2) to i64),
  ; # [3568] by
  i64 497186,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_By to i8*), i32 2) to i64),
  ; # [3584] as
  i64 472594,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_As to i8*), i32 2) to i64),
  ; # [3600] lit
  i64 122066626,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Lit to i8*), i32 2) to i64),
  ; # [3616] eval
  i64 29093226066,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Eval to i8*), i32 2) to i64),
  ; # [3632] run
  i64 115824418,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Run to i8*), i32 2) to i64),
  ; # [3648] def
  i64 107370050,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Def to i8*), i32 2) to i64),
  ; # [3664] de
  i64 415298,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_De to i8*), i32 2) to i64),
  ; # [3680] dm
  i64 448066,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Dm to i8*), i32 2) to i64),
  ; # [3696] box
  i64 126285346,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Box to i8*), i32 2) to i64),
  ; # [3712] new
  i64 125196002,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_New to i8*), i32 2) to i64),
  ; # [3728] type
  i64 27229919042,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Type to i8*), i32 2) to i64),
  ; # [3744] isa
  i64 102184594,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Isa to i8*), i32 2) to i64),
  ; # [3760] method
  i64 1766874505696978,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Method to i8*), i32 2) to i64),
  ; # [3776] send
  i64 26959304498,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Send to i8*), i32 2) to i64),
  ; # [3792] try
  i64 127346498,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Try to i8*), i32 2) to i64),
  ; # [3808] super
  i64 7861250250546,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Super to i8*), i32 2) to i64),
  ; # [3824] extra
  i64 6696513013330,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Extra to i8*), i32 2) to i64),
  ; # [3840] and
  i64 105309714,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_And to i8*), i32 2) to i64),
  ; # [3856] or
  i64 468722,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Or to i8*), i32 2) to i64),
  ; # [3872] nand
  i64 26959288034,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Nand to i8*), i32 2) to i64),
  ; # [3888] nor
  i64 119994082,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Nor to i8*), i32 2) to i64),
  ; # [3904] xor
  i64 119994242,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Xor to i8*), i32 2) to i64),
  ; # [3920] bool
  i64 29107877410,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Bool to i8*), i32 2) to i64),
  ; # [3936] not
  i64 122091234,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Not to i8*), i32 2) to i64),
  ; # [3952] nil
  i64 113678050,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Nil to i8*), i32 2) to i64),
  ; # [3968] t
  i64 1858,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_T to i8*), i32 2) to i64),
  ; # [3984] prog
  i64 27765712642,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Prog to i8*), i32 2) to i64),
  ; # [4000] prog1
  i64 3395020072706,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Prog1 to i8*), i32 2) to i64),
  ; # [4016] prog2
  i64 3463739549442,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Prog2 to i8*), i32 2) to i64),
  ; # [4032] if
  i64 419474,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_If to i8*), i32 2) to i64),
  ; # [4048] ifn
  i64 115762834,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Ifn to i8*), i32 2) to i64),
  ; # [4064] if2
  i64 52848274,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_If2 to i8*), i32 2) to i64),
  ; # [4080] if@@
  i64 17247397522,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_IfAt2 to i8*), i32 2) to i64),
  ; # [4096] when
  i64 29634234226,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_When to i8*), i32 2) to i64),
  ; # [4112] unless
  i64 2031031360612178,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Unless to i8*), i32 2) to i64),
  ; # [4128] cond
  i64 26959345202,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Cond to i8*), i32 2) to i64),
  ; # [4144] nond
  i64 26959345378,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Nond to i8*), i32 2) to i64),
  ; # [4160] case
  i64 27232966194,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Case to i8*), i32 2) to i64),
  ; # [4176] casq
  i64 30454191666,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Casq to i8*), i32 2) to i64),
  ; # [4192] state
  i64 6971907852082,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_State to i8*), i32 2) to i64),
  ; # [4208] while
  i64 6969768707954,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_While to i8*), i32 2) to i64),
  ; # [4224] until
  i64 7450011297618,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Until to i8*), i32 2) to i64),
  ; # [4240] at
  i64 476690,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_At to i8*), i32 2) to i64),
  ; # [4256] do
  i64 456258,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Do to i8*), i32 2) to i64),
  ; # [4272] loop
  i64 30181619394,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Loop to i8*), i32 2) to i64),
  ; # [4288] for
  i64 119993954,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_For to i8*), i32 2) to i64),
  ; # [4304] with
  i64 28039354226,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_With to i8*), i32 2) to i64),
  ; # [4320] bind
  i64 26959320610,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Bind to i8*), i32 2) to i64),
  ; # [4336] job
  i64 103216802,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Job to i8*), i32 2) to i64),
  ; # [4352] let
  i64 122050242,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Let to i8*), i32 2) to i64),
  ; # [4368] let?
  i64 17033483970,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_LetQ to i8*), i32 2) to i64),
  ; # [4384] use
  i64 106379090,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Use to i8*), i32 2) to i64),
  ; # [4400] buf
  i64 107435554,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Buf to i8*), i32 2) to i64),
  ; # [4416] tco
  i64 116799298,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Tco to i8*), i32 2) to i64),
  ; # [4432] tc
  i64 407362,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Tc to i8*), i32 2) to i64),
  ; # [4448] catch
  i64 7173522724402,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Catch to i8*), i32 2) to i64),
  ; # [4464] throw
  i64 8207534032706,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Throw to i8*), i32 2) to i64),
  ; # [4480] finally
  i64 546842958862128738,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Finally to i8*), i32 2) to i64),
  ; # [4496] co
  i64 456242,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Co to i8*), i32 2) to i64),
  ; # [4512] yield
  i64 6901045041042,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Yield to i8*), i32 2) to i64),
  ; # [4528] !
  i64 530,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Break to i8*), i32 2) to i64),
  ; # [4544] e
  i64 1618,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_E to i8*), i32 2) to i64),
  ; # [4560] $
  i64 578,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Trace to i8*), i32 2) to i64),
  ; # [4576] exec
  i64 26681509458,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Exec to i8*), i32 2) to i64),
  ; # [4592] call
  i64 29104674354,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Call to i8*), i32 2) to i64),
  ; # [4608] ipid
  i64 26954106514,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Ipid to i8*), i32 2) to i64),
  ; # [4624] opid
  i64 26954106610,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Opid to i8*), i32 2) to i64),
  ; # [4640] kill
  i64 29104707250,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Kill to i8*), i32 2) to i64),
  ; # [4656] fork
  i64 28842587746,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Fork to i8*), i32 2) to i64),
  ; # [4672] detach
  i64 1836416737105474,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Detach to i8*), i32 2) to i64),
  ; # [4688] bye
  i64 106403362,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Bye to i8*), i32 2) to i64),
  ; # [4704] car
  i64 119936562,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Car to i8*), i32 2) to i64),
  ; # [4720] cdr
  i64 119948850,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Cdr to i8*), i32 2) to i64),
  ; # [4736] caar
  i64 30703752754,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Caar to i8*), i32 2) to i64),
  ; # [4752] cadr
  i64 30706898482,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Cadr to i8*), i32 2) to i64),
  ; # [4768] cdar
  i64 30703765042,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Cdar to i8*), i32 2) to i64),
  ; # [4784] cddr
  i64 30706910770,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Cddr to i8*), i32 2) to i64),
  ; # [4800] caaar
  i64 7860160697906,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Caaar to i8*), i32 2) to i64),
  ; # [4816] caadr
  i64 7860966004274,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Caadr to i8*), i32 2) to i64),
  ; # [4832] cadar
  i64 7860163843634,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Cadar to i8*), i32 2) to i64),
  ; # [4848] caddr
  i64 7860969150002,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Caddr to i8*), i32 2) to i64),
  ; # [4864] cdaar
  i64 7860160710194,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Cdaar to i8*), i32 2) to i64),
  ; # [4880] cdadr
  i64 7860966016562,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Cdadr to i8*), i32 2) to i64),
  ; # [4896] cddar
  i64 7860163855922,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Cddar to i8*), i32 2) to i64),
  ; # [4912] cdddr
  i64 7860969162290,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Cdddr to i8*), i32 2) to i64),
  ; # [4928] caaaar
  i64 2012201138656818,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Caaaar to i8*), i32 2) to i64),
  ; # [4944] caaadr
  i64 2012407297087026,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Caaadr to i8*), i32 2) to i64),
  ; # [4960] caadar
  i64 2012201943963186,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Caadar to i8*), i32 2) to i64),
  ; # [4976] caaddr
  i64 2012408102393394,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Caaddr to i8*), i32 2) to i64),
  ; # [4992] cadaar
  i64 2012201141802546,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Cadaar to i8*), i32 2) to i64),
  ; # [5008] cadadr
  i64 2012407300232754,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Cadadr to i8*), i32 2) to i64),
  ; # [5024] caddar
  i64 2012201947108914,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Caddar to i8*), i32 2) to i64),
  ; # [5040] cadddr
  i64 2012408105539122,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Cadddr to i8*), i32 2) to i64),
  ; # [5056] cdaaar
  i64 2012201138669106,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Cdaaar to i8*), i32 2) to i64),
  ; # [5072] cdaadr
  i64 2012407297099314,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Cdaadr to i8*), i32 2) to i64),
  ; # [5088] cdadar
  i64 2012201943975474,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Cdadar to i8*), i32 2) to i64),
  ; # [5104] cdaddr
  i64 2012408102405682,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Cdaddr to i8*), i32 2) to i64),
  ; # [5120] cddaar
  i64 2012201141814834,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Cddaar to i8*), i32 2) to i64),
  ; # [5136] cddadr
  i64 2012407300245042,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Cddadr to i8*), i32 2) to i64),
  ; # [5152] cdddar
  i64 2012201947121202,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Cdddar to i8*), i32 2) to i64),
  ; # [5168] cddddr
  i64 2012408105551410,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Cddddr to i8*), i32 2) to i64),
  ; # [5184] nth
  i64 109528802,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Nth to i8*), i32 2) to i64),
  ; # [5200] con
  i64 115799602,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Con to i8*), i32 2) to i64),
  ; # [5216] cons
  i64 30985877042,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Cons to i8*), i32 2) to i64),
  ; # [5232] conc
  i64 26690909746,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Conc to i8*), i32 2) to i64),
  ; # [5248] circ
  i64 26695079474,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Circ to i8*), i32 2) to i64),
  ; # [5264] rot
  i64 122091298,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Rot to i8*), i32 2) to i64),
  ; # [5280] list
  i64 31259530946,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_List to i8*), i32 2) to i64),
  ; # [5296] need
  i64 26949867234,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Need to i8*), i32 2) to i64),
  ; # [5312] range
  i64 6968431744802,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Range to i8*), i32 2) to i64),
  ; # [5328] full
  i64 29104756322,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Full to i8*), i32 2) to i64),
  ; # [5344] make
  i64 27224577746,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Make to i8*), i32 2) to i64),
  ; # [5360] made
  i64 27217237714,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Made to i8*), i32 2) to i64),
  ; # [5376] chain
  i64 7587430303282,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Chain to i8*), i32 2) to i64),
  ; # [5392] link
  i64 28838368962,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Link to i8*), i32 2) to i64),
  ; # [5408] yoke
  i64 27224635282,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Yoke to i8*), i32 2) to i64),
  ; # [5424] copy
  i64 32598586930,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Copy to i8*), i32 2) to i64),
  ; # [5440] mix
  i64 126260946,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Mix to i8*), i32 2) to i64),
  ; # [5456] append
  i64 1766804976764434,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Append to i8*), i32 2) to i64),
  ; # [5472] delete
  i64 1784809475429954,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Delete to i8*), i32 2) to i64),
  ; # [5488] delq
  i64 30446868034,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Delq to i8*), i32 2) to i64),
  ; # [5504] replace
  i64 456611883680945954,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Replace to i8*), i32 2) to i64),
  ; # [5520] insert
  i64 2048554834519698,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Insert to i8*), i32 2) to i64),
  ; # [5536] remove
  i64 1784949599786786,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Remove to i8*), i32 2) to i64),
  ; # [5552] place
  i64 6967344416514,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Place to i8*), i32 2) to i64),
  ; # [5568] strip
  i64 7724887131954,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Strip to i8*), i32 2) to i64),
  ; # [5584] split
  i64 7999758731058,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Split to i8*), i32 2) to i64),
  ; # [5600] reverse
  i64 456894525016004386,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Reverse to i8*), i32 2) to i64),
  ; # [5616] flip
  i64 30175315554,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Flip to i8*), i32 2) to i64),
  ; # [5632] trim
  i64 29370033986,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Trim to i8*), i32 2) to i64),
  ; # [5648] clip
  i64 30175315506,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Clip to i8*), i32 2) to i64),
  ; # [5664] head
  i64 26945672834,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Head to i8*), i32 2) to i64),
  ; # [5680] tail
  i64 29101528898,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Tail to i8*), i32 2) to i64),
  ; # [5696] stem
  i64 29365847858,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Stem to i8*), i32 2) to i64),
  ; # [5712] fin
  i64 115775074,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Fin to i8*), i32 2) to i64),
  ; # [5728] last
  i64 31259498178,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Last to i8*), i32 2) to i64),
  ; # [5744] ==
  i64 250834,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Eq to i8*), i32 2) to i64),
  ; # [5760] n==
  i64 64214754,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Neq to i8*), i32 2) to i64),
  ; # [5776] =
  i64 978,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Equal to i8*), i32 2) to i64),
  ; # [5792] <>
  i64 254914,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Nequal to i8*), i32 2) to i64),
  ; # [5808] =0
  i64 197586,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Eq0 to i8*), i32 2) to i64),
  ; # [5824] =1
  i64 201682,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Eq1 to i8*), i32 2) to i64),
  ; # [5840] =T
  i64 345042,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_EqT to i8*), i32 2) to i64),
  ; # [5856] n0
  i64 198370,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Neq0 to i8*), i32 2) to i64),
  ; # [5872] nT
  i64 345826,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_NeqT to i8*), i32 2) to i64),
  ; # [5888] <
  i64 962,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Lt to i8*), i32 2) to i64),
  ; # [5904] <=
  i64 250818,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Le to i8*), i32 2) to i64),
  ; # [5920] >
  i64 994,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Gt to i8*), i32 2) to i64),
  ; # [5936] >=
  i64 250850,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Ge to i8*), i32 2) to i64),
  ; # [5952] max
  i64 126228178,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Max to i8*), i32 2) to i64),
  ; # [5968] min
  i64 115775186,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Min to i8*), i32 2) to i64),
  ; # [5984] atom
  i64 29376333330,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Atom to i8*), i32 2) to i64),
  ; # [6000] pair
  i64 30712141570,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Pair to i8*), i32 2) to i64),
  ; # [6016] circ?
  i64 4356022113842,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_CircQ to i8*), i32 2) to i64),
  ; # [6032] lst?
  i64 17033541314,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_LstQ to i8*), i32 2) to i64),
  ; # [6048] num?
  i64 17026209506,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_NumQ to i8*), i32 2) to i64),
  ; # [6064] sym?
  i64 17026225970,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_SymQ to i8*), i32 2) to i64),
  ; # [6080] flg?
  i64 17019881058,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_FlgQ to i8*), i32 2) to i64),
  ; # [6096] member
  i64 2012476297598674,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Member to i8*), i32 2) to i64),
  ; # [6112] memq
  i64 30447916754,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Memq to i8*), i32 2) to i64),
  ; # [6128] mmeq
  i64 30439560914,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Mmeq to i8*), i32 2) to i64),
  ; # [6144] sect
  i64 31242737458,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Sect to i8*), i32 2) to i64),
  ; # [6160] diff
  i64 27487802946,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Diff to i8*), i32 2) to i64),
  ; # [6176] index
  i64 8273554499218,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Index to i8*), i32 2) to i64),
  ; # [6192] offset
  i64 2047665225754354,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Offset to i8*), i32 2) to i64),
  ; # [6208] prior
  i64 7863927252738,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Prior to i8*), i32 2) to i64),
  ; # [6224] length
  i64 1837586572531394,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Length to i8*), i32 2) to i64),
  ; # [6240] size
  i64 27240339250,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Size to i8*), i32 2) to i64),
  ; # [6256] bytes
  i64 7929973937698,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Bytes to i8*), i32 2) to i64),
  ; # [6272] assoc
  i64 6833145591314,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Assoc to i8*), i32 2) to i64),
  ; # [6288] rassoc
  i64 1749285271377698,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Rassoc to i8*), i32 2) to i64),
  ; # [6304] asoq
  i64 30450071058,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Asoq to i8*), i32 2) to i64),
  ; # [6320] rasoq
  i64 7795218192162,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Rasoq to i8*), i32 2) to i64),
  ; # [6336] rank
  i64 28838336290,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Rank to i8*), i32 2) to i64),
  ; # [6352] match
  i64 7173522724562,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Match to i8*), i32 2) to i64),
  ; # [6368] fill
  i64 29104707170,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Fill to i8*), i32 2) to i64),
  ; # [6384] prove
  i64 6972459394818,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Prove to i8*), i32 2) to i64),
  ; # [6400] ->
  i64 254674,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Arrow to i8*), i32 2) to i64),
  ; # [6416] unify
  i64 8342547654482,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Unify to i8*), i32 2) to i64),
  ; # [6432] group
  i64 7728105203314,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Group to i8*), i32 2) to i64),
  ; # [6448] sort
  i64 31258507058,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Sort to i8*), i32 2) to i64),
  ; # [6464] tty
  i64 127354690,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Tty to i8*), i32 2) to i64),
  ; # [6480] prompt
  i64 2048419538872066,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Prompt to i8*), i32 2) to i64),
  ; # [6496] raw
  i64 125179682,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Raw to i8*), i32 2) to i64),
  ; # [6512] alarm
  i64 7521126762002,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Alarm to i8*), i32 2) to i64),
  ; # [6528] sigio
  i64 7656156075826,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Sigio to i8*), i32 2) to i64),
  ; # [6544] kids
  i64 30975366834,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Kids to i8*), i32 2) to i64),
  ; # [6560] protect
  i64 524166155115898626,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Protect to i8*), i32 2) to i64),
  ; # [6576] heap
  i64 30166898306,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Heap to i8*), i32 2) to i64),
  ; # [6592] stack
  i64 7379661309746,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Stack to i8*), i32 2) to i64),
  ; # [6608] byte
  i64 27234113058,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Byte to i8*), i32 2) to i64),
  ; # [6624] env
  i64 124184146,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Env to i8*), i32 2) to i64),
  ; # [6640] date
  i64 27234014786,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Date to i8*), i32 2) to i64),
  ; # [6656] time
  i64 27226707778,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Time to i8*), i32 2) to i64),
  ; # [6672] usec
  i64 26681489234,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Usec to i8*), i32 2) to i64),
  ; # [6688] rt
  i64 476962,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Rt to i8*), i32 2) to i64),
  ; # [6704] quit
  i64 31249094418,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Quit to i8*), i32 2) to i64),
  ; # [6720] sys
  i64 121083698,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Sys to i8*), i32 2) to i64),
  ; # [6736] pwd
  i64 105346818,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Pwd to i8*), i32 2) to i64),
  ; # [6752] cd
  i64 411186,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Cd to i8*), i32 2) to i64),
  ; # [6768] ctty
  i64 32602801714,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Ctty to i8*), i32 2) to i64),
  ; # [6784] cmd
  i64 105305650,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Cmd to i8*), i32 2) to i64),
  ; # [6800] dir
  i64 119969346,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Dir to i8*), i32 2) to i64),
  ; # [6816] info
  i64 29903742610,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Info to i8*), i32 2) to i64),
  ; # [6832] file
  i64 27225658978,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_File to i8*), i32 2) to i64),
  ; # [6848] argv
  i64 31783855634,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Argv to i8*), i32 2) to i64),
  ; # [6864] opt
  i64 122095346,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Opt to i8*), i32 2) to i64),
  ; # [6880] errno
  i64 7657509824082,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Errno to i8*), i32 2) to i64),
  ; # [6896] %@
  i64 262738,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Nat to i8*), i32 2) to i64),
  ; # [6912] native
  i64 1784947996497634,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Native to i8*), i32 2) to i64),
  ; # [6928] struct
  i64 2047528336312114,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Struct to i8*), i32 2) to i64),
  ; # [6944] lisp
  i64 30185789122,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Lisp to i8*), i32 2) to i64),
  ; # [6960] args
  i64 30978549266,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Args to i8*), i32 2) to i64),
  ; # [6976] next
  i64 31264757474,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Next to i8*), i32 2) to i64),
  ; # [6992] arg
  i64 108471826,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Arg to i8*), i32 2) to i64),
  ; # [7008] rest
  i64 31259514658,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Rest to i8*), i32 2) to i64),
  ; # [7024] adr
  i64 119948818,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Adr to i8*), i32 2) to i64),
  ; # [7040] trail
  i64 7449991391042,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Trail to i8*), i32 2) to i64),
  ; # [7056] up
  i64 460626,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Up to i8*), i32 2) to i64),
  ; # [7072] history
  i64 546948723242342018,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_History to i8*), i32 2) to i64),
  ; # [7088] version
  i64 497355938196772706,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_Version to i8*), i32 2) to i64)
], align 16
@gcData = global [53 x i64] [
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 96) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
], align 8
@cbFuns = global [24 x i64] [
  i64 ptrtoint (i64(i64,i64,i64,i64,i64)* @_Cb1 to i64),
  i64 ptrtoint (i64(i64,i64,i64,i64,i64)* @_Cb2 to i64),
  i64 ptrtoint (i64(i64,i64,i64,i64,i64)* @_Cb3 to i64),
  i64 ptrtoint (i64(i64,i64,i64,i64,i64)* @_Cb4 to i64),
  i64 ptrtoint (i64(i64,i64,i64,i64,i64)* @_Cb5 to i64),
  i64 ptrtoint (i64(i64,i64,i64,i64,i64)* @_Cb6 to i64),
  i64 ptrtoint (i64(i64,i64,i64,i64,i64)* @_Cb7 to i64),
  i64 ptrtoint (i64(i64,i64,i64,i64,i64)* @_Cb8 to i64),
  i64 ptrtoint (i64(i64,i64,i64,i64,i64)* @_Cb9 to i64),
  i64 ptrtoint (i64(i64,i64,i64,i64,i64)* @_Cb10 to i64),
  i64 ptrtoint (i64(i64,i64,i64,i64,i64)* @_Cb11 to i64),
  i64 ptrtoint (i64(i64,i64,i64,i64,i64)* @_Cb12 to i64),
  i64 ptrtoint (i64(i64,i64,i64,i64,i64)* @_Cb13 to i64),
  i64 ptrtoint (i64(i64,i64,i64,i64,i64)* @_Cb14 to i64),
  i64 ptrtoint (i64(i64,i64,i64,i64,i64)* @_Cb15 to i64),
  i64 ptrtoint (i64(i64,i64,i64,i64,i64)* @_Cb16 to i64),
  i64 ptrtoint (i64(i64,i64,i64,i64,i64)* @_Cb17 to i64),
  i64 ptrtoint (i64(i64,i64,i64,i64,i64)* @_Cb18 to i64),
  i64 ptrtoint (i64(i64,i64,i64,i64,i64)* @_Cb19 to i64),
  i64 ptrtoint (i64(i64,i64,i64,i64,i64)* @_Cb20 to i64),
  i64 ptrtoint (i64(i64,i64,i64,i64,i64)* @_Cb21 to i64),
  i64 ptrtoint (i64(i64,i64,i64,i64,i64)* @_Cb22 to i64),
  i64 ptrtoint (i64(i64,i64,i64,i64,i64)* @_Cb23 to i64),
  i64 ptrtoint (i64(i64,i64,i64,i64,i64)* @_Cb24 to i64)
], align 8
@env = global [25 x i64] [
  i64 0,
  i64 0,
  i64 0,
  i64 0,
  i64 ptrtoint (i8* null to i64),
  i64 ptrtoint (i8* null to i64),
  i64 ptrtoint (i8* null to i64),
  i64 ptrtoint (i8* null to i64),
  i64 ptrtoint (i8* null to i64),
  i64 ptrtoint (i8* null to i64),
  i64 ptrtoint (i8* null to i64),
  i64 ptrtoint (void(i8)* null to i64),
  i64 ptrtoint (i32()* null to i64),
  i64 ptrtoint (i64* null to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 0,
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 0,
  i64 0,
  i64 0,
  i64 0,
  i64 0,
  i64 0,
  i64 0,
  i64 0
], align 8
@$Cell = global [2 x i64] [
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64),
  i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
]
@$Version = global [3 x i64] [
  i64 402,
  i64 50,
  i64 466
], align 8
@$TBuf = global [2 x i8] [
  i8 5,
  i8 84
]
@$Month = global [13 x i8] [
  i8 31,
  i8 31,
  i8 28,
  i8 31,
  i8 30,
  i8 31,
  i8 30,
  i8 31,
  i8 31,
  i8 30,
  i8 31,
  i8 30,
  i8 31
]
@$Repl = global i1 0
@$PRepl = global i1 0
@$Tc = global i1 0
@$Jam = global i1 0
@$InBye = global i1 0
@$Sync = global i1 0
@$Empty = constant [1 x i8] c"\00"
@$Delim = constant [16 x i8] c" \09\0A\0D\22'(),[]`{}~\00"
declare i8* @malloc(i64)
declare i8* @realloc(i8*, i64)
declare void @free(i8*)
declare i32 @fork()
declare i8* @getenv(i8*)
declare i32 @setenv(i8*, i8*, i32)
declare i8* @getcwd(i8*, i64)
declare i32 @chdir(i8*)
declare i32 @getpid()
declare i32 @getpgrp()
declare i32 @setsid()
declare i32 @alarm(i32)
declare i32 @setpgid(i32, i32)
declare i32 @execvp(i8*, i8**)
declare i32 @isatty(i32)
declare i32 @openpty(i32*, i32*, i8*, i8*, i8*)
declare i32 @login_tty(i32)
declare i32 @tcgetattr(i32, i8*)
declare i32 @tcgetpgrp(i32)
declare i32 @tcsetpgrp(i32, i32)
declare i64 @read(i32, i8*, i64)
declare i64 @write(i32, i8*, i64)
declare i64 @pread(i32, i8*, i64, i64)
declare i64 @pwrite(i32, i8*, i64, i64)
declare i32 @fread(i8*, i64, i64, i8*)
declare i32 @fwrite(i8*, i64, i64, i8*)
declare i32 @putc_unlocked(i32, i8*)
declare i32 @getc_unlocked(i8*)
declare i8* @fopen(i8*, i8*)
declare i32 @fflush(i8*)
declare i32 @feof(i8*)
declare i32 @fclose(i8*)
declare i32 @fileno(i8*)
declare i32 @fsync(i32)
declare i32 @pipe(i32*)
declare i32 @memcmp(i8*, i8*, i64)
declare i64 @strlen(i8*)
declare i8* @strcpy(i8*, i8*)
declare i8* @strdup(i8*)
declare i32 @strcmp(i8*, i8*)
declare i8* @strchr(i8*, i32)
declare i8* @strrchr(i8*, i32)
declare i8* @dlsym(i8*, i8*)
declare i8* @dlerror()
declare i32 @dup(i32)
declare i32 @dup2(i32, i32)
declare i32 @close(i32)
declare i8* @signal(i32, i8*)
declare i32 @waitpid(i32, i32*, i32)
declare i32 @poll(i64*, i32, i64)
declare i32 @setjmp(i8*)
declare void @longjmp(i8*, i32)
declare i32 @kill(i32, i32)
declare void @exit(i32)
declare void @add_history(i8*)
declare i8*** @history_list()
declare void @clear_history()
@TgOS = external global i8
@TgCPU = external global i8
@PipeBufSize = external global i32
@Fsign = external global i1
@Fdigit = external global i64
declare i8* @stderrMsg(i8*, i8*)
declare void @gPrintf(i8*, i32, i8*, i8*)
declare i8* @strErrno()
declare i32 @openRd(i8*)
declare i32 @openWr(i8*)
declare i32 @openRdWr(i8*)
declare i32 @openRdWrExcl(i8*)
declare i32 @openRdWrCreate(i8*)
declare i32 @openRdWrAppend(i8*)
declare i32 @openWrAppend(i8*)
declare i1 @fseekOfs(i8*, i32)
declare i1 @fseek0(i8*)
declare i1 @seek0(i32)
declare i1 @truncate0(i32)
declare i32 @socketPair(i32*)
declare i32 @fcntlCloExec(i32)
declare void @fcntlSetFl(i32, i32)
declare i32 @nonBlocking(i32)
declare void @fcntlSetOwn(i32, i32)
declare i8* @getDir(i8*)
declare void @initReadline()
declare i8* @gReadline(i8*)
declare void @rlHide()
declare void @rlShow()
declare void @rlSigBeg()
declare void @rlSigEnd()
declare i8* @currentLine()
@Sig = external global i32
@SigDfl = external global i8*
@SigIgn = external global i8*
declare i32 @gSignal(i32)
declare void @iSignal(i32, i8*)
declare void @sigUnblock(i32)
declare void @sigChld(i32)
declare i32 @waitWuntraced(i32, i32*)
declare i32 @wifStopped(i32*)
declare i32 @nErrno()
declare i32 @gErrno()
@Tio = external global i1
@OrgTermio = external global i8
@Termio = external global i8*
declare void @stopTerm()
declare void @setRaw()
declare void @setCooked()
declare i1 @reopenTty(i8*)
declare i64 @getUsec(i1)
declare i64 @getMsec()
declare i64 @getDate()
declare i64 @getGmDate()
declare i64 @getTime()
declare i64 @getGmTime()
declare i8* @ulimStk()
declare i64 @fileInfo(i1, i1, i8*, i64*)
declare void @pollIn(i32, i64*)
declare void @pollOut(i32, i64*)
declare void @pollIgn(i64*)
declare i32 @gPoll(i64*, i32, i64)
declare i1 @readyIn(i64*)
declare i1 @readyOut(i64*)
declare i32 @rdLock(i32, i64, i64, i1)
declare i32 @wrLock(i32, i64, i64, i1)
declare i32 @unLock(i32, i64, i64)
declare i32 @getLock(i32, i64, i64)
@JmpBufSize = external global i64
@QuitRst = external global i8
declare i8* @dlOpen(i8*)
declare i8* @ffiPrep(i8*, i8*, i64)
declare i64 @ffiCall(i8*, i64)
declare i64 @boxFloat(i32, i64)
declare i64 @boxFlt()
declare i64 @boxDouble(i64, i64)
declare i64 @boxDbl()
declare void @bufFloat(i64, i64, i8*)
declare void @bufDouble(i64, i64, i8*)
declare i1 @chance(i64)
declare i1 @isLowc(i32)
declare i1 @isUppc(i32)
declare i1 @isLetterOrDigit(i32)
declare i32 @toUpperCase(i32)
declare i32 @toLowerCase(i32)

define i64 @execAt(i64) align 8 {
$1:
; # (let At (save (val $At)) (exec Prg) (set $At At))
; # (val $At)
  %1 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  %2 = load i64, i64* %1
; # (save (val $At))
  %3 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %4 = load i64, i64* %3
  %5 = alloca i64, i64 2, align 16
  %6 = ptrtoint i64* %5 to i64
  %7 = inttoptr i64 %6 to i64*
  store i64 %2, i64* %7
  %8 = add i64 %6, 8
  %9 = inttoptr i64 %8 to i64*
  store i64 %4, i64* %9
  %10 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %6, i64* %10
; # (exec Prg)
  br label %$2
$2:
  %11 = phi i64 [%0, %$1], [%23, %$5] ; # Prg
  %12 = inttoptr i64 %11 to i64*
  %13 = load i64, i64* %12
  %14 = getelementptr i64, i64* %12, i32 1
  %15 = load i64, i64* %14
  %16 = and i64 %13, 15
  %17 = icmp eq i64 %16, 0
  br i1 %17, label %$3, label %$4
$3:
  %18 = phi i64 [%15, %$2] ; # Prg
  %19 = call i64 @evList(i64 %13)
  br label %$4
$4:
  %20 = phi i64 [%15, %$2], [%18, %$3] ; # Prg
  %21 = and i64 %20, 15
  %22 = icmp ne i64 %21, 0
  br i1 %22, label %$6, label %$5
$5:
  %23 = phi i64 [%20, %$4] ; # Prg
  br label %$2
$6:
  %24 = phi i64 [%20, %$4] ; # Prg
  %25 = phi i64 [0, %$4] ; # ->
; # (set $At At)
  %26 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  store i64 %2, i64* %26
; # (drop *Safe)
  %27 = inttoptr i64 %6 to i64*
  %28 = getelementptr i64, i64* %27, i32 1
  %29 = load i64, i64* %28
  %30 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %29, i64* %30
  ret i64 %2
}

define i64 @runAt(i64) align 8 {
$1:
; # (let At (save (val $At)) (prog1 (run Prg) (set $At At)))
; # (val $At)
  %1 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  %2 = load i64, i64* %1
; # (save (val $At))
  %3 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %4 = load i64, i64* %3
  %5 = alloca i64, i64 2, align 16
  %6 = ptrtoint i64* %5 to i64
  %7 = inttoptr i64 %6 to i64*
  store i64 %2, i64* %7
  %8 = add i64 %6, 8
  %9 = inttoptr i64 %8 to i64*
  store i64 %4, i64* %9
  %10 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %6, i64* %10
; # (prog1 (run Prg) (set $At At))
; # (run Prg)
  br label %$2
$2:
  %11 = phi i64 [%0, %$1], [%33, %$11] ; # Prg
  %12 = inttoptr i64 %11 to i64*
  %13 = load i64, i64* %12
  %14 = getelementptr i64, i64* %12, i32 1
  %15 = load i64, i64* %14
  %16 = and i64 %15, 15
  %17 = icmp ne i64 %16, 0
  br i1 %17, label %$5, label %$3
$5:
  %18 = phi i64 [%15, %$2] ; # Prg
  %19 = and i64 %13, 6
  %20 = icmp ne i64 %19, 0
  br i1 %20, label %$8, label %$7
$8:
  br label %$6
$7:
  %21 = and i64 %13, 8
  %22 = icmp ne i64 %21, 0
  br i1 %22, label %$10, label %$9
$10:
  %23 = inttoptr i64 %13 to i64*
  %24 = load i64, i64* %23
  br label %$6
$9:
  %25 = call i64 @evList(i64 %13)
  br label %$6
$6:
  %26 = phi i64 [%13, %$8], [%24, %$10], [%25, %$9] ; # ->
  br label %$4
$3:
  %27 = phi i64 [%15, %$2] ; # Prg
  %28 = and i64 %13, 15
  %29 = icmp eq i64 %28, 0
  br i1 %29, label %$12, label %$11
$12:
  %30 = phi i64 [%27, %$3] ; # Prg
  %31 = call i64 @evList(i64 %13)
  %32 = icmp ne i64 %31, 0
  br label %$11
$11:
  %33 = phi i64 [%27, %$3], [%30, %$12] ; # Prg
  %34 = phi i1 [0, %$3], [%32, %$12] ; # ->
  br label %$2
$4:
  %35 = phi i64 [%18, %$6] ; # Prg
  %36 = phi i64 [%26, %$6] ; # ->
; # (set $At At)
  %37 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  store i64 %2, i64* %37
; # (drop *Safe)
  %38 = inttoptr i64 %6 to i64*
  %39 = getelementptr i64, i64* %38, i32 1
  %40 = load i64, i64* %39
  %41 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %40, i64* %41
  ret i64 %36
}

define i64 @wrnl() align 8 {
$1:
; # (write 1 ($ "^J") 1)
  %0 = call i64 @write(i32 1, i8* bitcast ([2 x i8]* @$1 to i8*), i64 1)
  ret i64 %0
}

define i64 @dbg(i64, i64) align 8 {
$1:
; # (let (Out (val $OutFile) Put (val (i8** $Put))) (set $OutFile (va...
; # (val $OutFile)
  %2 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 80) to i8**)
; # (i8** $Put)
  %3 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**) to i8**
; # (val (i8** $Put))
  %4 = load i8*, i8** %3
; # (set $OutFile (val 3 (val $OutFiles)) $Put (fun (void i8) _putStd...
; # (val $OutFiles)
  %5 = load i8**, i8*** @$OutFiles
; # (val 3 (val $OutFiles))
  %6 = getelementptr i8*, i8** %5, i32 2
  %7 = load i8*, i8** %6
  store i8* %7, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 80) to i8**)
; # (fun (void i8) _putStdout)
  store void(i8)* @_putStdout, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
; # (outWord N)
  call void @outWord(i64 %0)
; # (when X (space) (print X))
  %8 = icmp ne i64 %1, 0
  br i1 %8, label %$2, label %$3
$2:
; # (space)
  call void @space()
; # (print X)
  call void @print(i64 %1)
  br label %$3
$3:
; # (newline)
  call void @newline()
; # (set (i8** $Put) Put $OutFile Out)
; # (i8** $Put)
  %9 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**) to i8**
  store i8* %4, i8** %9
  store i8* %2, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 80) to i8**)
  ret i64 %1
}

define void @stop(i8*) align 8 {
$1:
; # (let Crt: (coroutine Crt) (when (symb? (Crt: tag)) (put @ ZERO $N...
; # (when (symb? (Crt: tag)) (put @ ZERO $Nil))
; # (Crt: tag)
  %1 = ptrtoint i8* %0 to i64
  %2 = inttoptr i64 %1 to i64*
  %3 = load i64, i64* %2
; # (symb? (Crt: tag))
  %4 = xor i64 %3, 8
  %5 = and i64 %4, 14
  %6 = icmp eq i64 %5, 0
  br i1 %6, label %$2, label %$3
$2:
; # (put @ ZERO $Nil)
  call void @put(i64 %3, i64 2, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  br label %$3
$3:
; # (Crt: tag 0)
  %7 = ptrtoint i8* %0 to i64
  %8 = inttoptr i64 %7 to i64*
  store i64 0, i64* %8
; # (Crt: lim (val $CrtFree))
  %9 = getelementptr i8, i8* %0, i32 40
  %10 = bitcast i8* %9 to i8**
  %11 = load i8*, i8** @$CrtFree
  store i8* %11, i8** %10
; # (set $CrtFree Crt)
  store i8* %0, i8** @$CrtFree
  ret void
}

define void @unwind(i8*) align 8 {
$1:
; # (let (Ca (val $Catch) Bnd (val $Bind)) (while Ca (let Ca: (caFram...
; # (val $Catch)
  %1 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 32) to i8**)
; # (val $Bind)
  %2 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  %3 = load i64, i64* %2
; # (while Ca (let Ca: (caFrame Ca) (while (and Bnd (<> Bnd (Ca: (env...
  br label %$2
$2:
  %4 = phi i8* [%1, %$1], [%192, %$40] ; # Ca
  %5 = phi i64 [%3, %$1], [%190, %$40] ; # Bnd
  %6 = icmp ne i8* %4, null
  br i1 %6, label %$3, label %$4
$3:
  %7 = phi i8* [%4, %$2] ; # Ca
  %8 = phi i64 [%5, %$2] ; # Bnd
; # (let Ca: (caFrame Ca) (while (and Bnd (<> Bnd (Ca: (env $Bind any...
; # (while (and Bnd (<> Bnd (Ca: (env $Bind any)))) (set (val 2 Bnd) ...
  br label %$5
$5:
  %9 = phi i8* [%7, %$3], [%23, %$8] ; # Ca
  %10 = phi i64 [%8, %$3], [%33, %$8] ; # Bnd
; # (and Bnd (<> Bnd (Ca: (env $Bind any))))
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$7, label %$6
$7:
  %12 = phi i8* [%9, %$5] ; # Ca
  %13 = phi i64 [%10, %$5] ; # Bnd
; # (Ca: (env $Bind any))
  %14 = getelementptr i8, i8* %7, i32 72
  %15 = getelementptr i8, i8* %14, i32 8
  %16 = ptrtoint i8* %15 to i64
  %17 = inttoptr i64 %16 to i64*
  %18 = load i64, i64* %17
; # (<> Bnd (Ca: (env $Bind any)))
  %19 = icmp ne i64 %13, %18
  br label %$6
$6:
  %20 = phi i8* [%9, %$5], [%12, %$7] ; # Ca
  %21 = phi i64 [%10, %$5], [%13, %$7] ; # Bnd
  %22 = phi i1 [0, %$5], [%19, %$7] ; # ->
  br i1 %22, label %$8, label %$9
$8:
  %23 = phi i8* [%20, %$6] ; # Ca
  %24 = phi i64 [%21, %$6] ; # Bnd
; # (set (val 2 Bnd) (val Bnd))
; # (val 2 Bnd)
  %25 = inttoptr i64 %24 to i64*
  %26 = getelementptr i64, i64* %25, i32 1
  %27 = load i64, i64* %26
; # (val Bnd)
  %28 = inttoptr i64 %24 to i64*
  %29 = load i64, i64* %28
  %30 = inttoptr i64 %27 to i64*
  store i64 %29, i64* %30
; # (val 3 Bnd)
  %31 = inttoptr i64 %24 to i64*
  %32 = getelementptr i64, i64* %31, i32 2
  %33 = load i64, i64* %32
  br label %$5
$9:
  %34 = phi i8* [%20, %$6] ; # Ca
  %35 = phi i64 [%21, %$6] ; # Bnd
; # (while (and (val $CtlFrames) (<> @ (Ca: (env $CtlFrames i8*)))) (...
  br label %$10
$10:
  %36 = phi i8* [%34, %$9], [%50, %$13] ; # Ca
  %37 = phi i64 [%35, %$9], [%51, %$13] ; # Bnd
; # (and (val $CtlFrames) (<> @ (Ca: (env $CtlFrames i8*))))
; # (val $CtlFrames)
  %38 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 64) to i8**)
  %39 = icmp ne i8* %38, null
  br i1 %39, label %$12, label %$11
$12:
  %40 = phi i8* [%36, %$10] ; # Ca
  %41 = phi i64 [%37, %$10] ; # Bnd
; # (Ca: (env $CtlFrames i8*))
  %42 = getelementptr i8, i8* %7, i32 72
  %43 = getelementptr i8, i8* %42, i32 64
  %44 = bitcast i8* %43 to i8**
  %45 = load i8*, i8** %44
; # (<> @ (Ca: (env $CtlFrames i8*)))
  %46 = icmp ne i8* %38, %45
  br label %$11
$11:
  %47 = phi i8* [%36, %$10], [%40, %$12] ; # Ca
  %48 = phi i64 [%37, %$10], [%41, %$12] ; # Bnd
  %49 = phi i1 [0, %$10], [%46, %$12] ; # ->
  br i1 %49, label %$13, label %$14
$13:
  %50 = phi i8* [%47, %$11] ; # Ca
  %51 = phi i64 [%48, %$11] ; # Bnd
; # (popCtlFiles)
  call void @popCtlFiles()
  br label %$10
$14:
  %52 = phi i8* [%47, %$11] ; # Ca
  %53 = phi i64 [%48, %$11] ; # Bnd
; # (while (and (val $ErrFrames) (<> @ (Ca: (env $ErrFrames i8*)))) (...
  br label %$15
$15:
  %54 = phi i8* [%52, %$14], [%68, %$18] ; # Ca
  %55 = phi i64 [%53, %$14], [%69, %$18] ; # Bnd
; # (and (val $ErrFrames) (<> @ (Ca: (env $ErrFrames i8*))))
; # (val $ErrFrames)
  %56 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 56) to i8**)
  %57 = icmp ne i8* %56, null
  br i1 %57, label %$17, label %$16
$17:
  %58 = phi i8* [%54, %$15] ; # Ca
  %59 = phi i64 [%55, %$15] ; # Bnd
; # (Ca: (env $ErrFrames i8*))
  %60 = getelementptr i8, i8* %7, i32 72
  %61 = getelementptr i8, i8* %60, i32 56
  %62 = bitcast i8* %61 to i8**
  %63 = load i8*, i8** %62
; # (<> @ (Ca: (env $ErrFrames i8*)))
  %64 = icmp ne i8* %56, %63
  br label %$16
$16:
  %65 = phi i8* [%54, %$15], [%58, %$17] ; # Ca
  %66 = phi i64 [%55, %$15], [%59, %$17] ; # Bnd
  %67 = phi i1 [0, %$15], [%64, %$17] ; # ->
  br i1 %67, label %$18, label %$19
$18:
  %68 = phi i8* [%65, %$16] ; # Ca
  %69 = phi i64 [%66, %$16] ; # Bnd
; # (popErrFiles)
  call void @popErrFiles()
  br label %$15
$19:
  %70 = phi i8* [%65, %$16] ; # Ca
  %71 = phi i64 [%66, %$16] ; # Bnd
; # (until (or (== (val $OutFrames) (val $Stdout)) (== (val $OutFrame...
  br label %$20
$20:
  %72 = phi i8* [%70, %$19], [%88, %$23] ; # Ca
  %73 = phi i64 [%71, %$19], [%89, %$23] ; # Bnd
; # (or (== (val $OutFrames) (val $Stdout)) (== (val $OutFrames) (Ca:...
; # (val $OutFrames)
  %74 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 48) to i8**)
; # (val $Stdout)
  %75 = load i8*, i8** @$Stdout
; # (== (val $OutFrames) (val $Stdout))
  %76 = icmp eq i8* %74, %75
  br i1 %76, label %$21, label %$22
$22:
  %77 = phi i8* [%72, %$20] ; # Ca
  %78 = phi i64 [%73, %$20] ; # Bnd
; # (val $OutFrames)
  %79 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 48) to i8**)
; # (Ca: (env $OutFrames i8*))
  %80 = getelementptr i8, i8* %7, i32 72
  %81 = getelementptr i8, i8* %80, i32 48
  %82 = bitcast i8* %81 to i8**
  %83 = load i8*, i8** %82
; # (== (val $OutFrames) (Ca: (env $OutFrames i8*)))
  %84 = icmp eq i8* %79, %83
  br label %$21
$21:
  %85 = phi i8* [%72, %$20], [%77, %$22] ; # Ca
  %86 = phi i64 [%73, %$20], [%78, %$22] ; # Bnd
  %87 = phi i1 [1, %$20], [%84, %$22] ; # ->
  br i1 %87, label %$24, label %$23
$23:
  %88 = phi i8* [%85, %$21] ; # Ca
  %89 = phi i64 [%86, %$21] ; # Bnd
; # (popOutFiles)
  call void @popOutFiles()
  br label %$20
$24:
  %90 = phi i8* [%85, %$21] ; # Ca
  %91 = phi i64 [%86, %$21] ; # Bnd
; # (until (or (== (val $InFrames) (val $Stdin)) (== (val $InFrames) ...
  br label %$25
$25:
  %92 = phi i8* [%90, %$24], [%108, %$28] ; # Ca
  %93 = phi i64 [%91, %$24], [%109, %$28] ; # Bnd
; # (or (== (val $InFrames) (val $Stdin)) (== (val $InFrames) (Ca: (e...
; # (val $InFrames)
  %94 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 40) to i8**)
; # (val $Stdin)
  %95 = load i8*, i8** @$Stdin
; # (== (val $InFrames) (val $Stdin))
  %96 = icmp eq i8* %94, %95
  br i1 %96, label %$26, label %$27
$27:
  %97 = phi i8* [%92, %$25] ; # Ca
  %98 = phi i64 [%93, %$25] ; # Bnd
; # (val $InFrames)
  %99 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 40) to i8**)
; # (Ca: (env $InFrames i8*))
  %100 = getelementptr i8, i8* %7, i32 72
  %101 = getelementptr i8, i8* %100, i32 40
  %102 = bitcast i8* %101 to i8**
  %103 = load i8*, i8** %102
; # (== (val $InFrames) (Ca: (env $InFrames i8*)))
  %104 = icmp eq i8* %99, %103
  br label %$26
$26:
  %105 = phi i8* [%92, %$25], [%97, %$27] ; # Ca
  %106 = phi i64 [%93, %$25], [%98, %$27] ; # Bnd
  %107 = phi i1 [1, %$25], [%104, %$27] ; # ->
  br i1 %107, label %$29, label %$28
$28:
  %108 = phi i8* [%105, %$26] ; # Ca
  %109 = phi i64 [%106, %$26] ; # Bnd
; # (popInFiles)
  call void @popInFiles()
  br label %$25
$29:
  %110 = phi i8* [%105, %$26] ; # Ca
  %111 = phi i64 [%106, %$26] ; # Bnd
; # (let (Src (val $Current) Dst (Ca: co)) (unless Dst (setq Dst (val...
; # (val $Current)
  %112 = load i8*, i8** @$Current
; # (Ca: co)
  %113 = getelementptr i8, i8* %7, i32 24
  %114 = bitcast i8* %113 to i8**
  %115 = load i8*, i8** %114
; # (unless Dst (setq Dst (val $Coroutines)))
  %116 = icmp ne i8* %115, null
  br i1 %116, label %$31, label %$30
$30:
  %117 = phi i8* [%110, %$29] ; # Ca
  %118 = phi i64 [%111, %$29] ; # Bnd
  %119 = phi i8* [%115, %$29] ; # Dst
; # (val $Coroutines)
  %120 = load i8*, i8** @$Coroutines
  br label %$31
$31:
  %121 = phi i8* [%110, %$29], [%117, %$30] ; # Ca
  %122 = phi i64 [%111, %$29], [%118, %$30] ; # Bnd
  %123 = phi i8* [%115, %$29], [%120, %$30] ; # Dst
; # (unless (== Src Dst) (stop Src) (let Crt: (coroutine (set $Curren...
; # (== Src Dst)
  %124 = icmp eq i8* %112, %123
  br i1 %124, label %$33, label %$32
$32:
  %125 = phi i8* [%121, %$31] ; # Ca
  %126 = phi i64 [%122, %$31] ; # Bnd
  %127 = phi i8* [%123, %$31] ; # Dst
; # (stop Src)
  call void @stop(i8* %112)
; # (let Crt: (coroutine (set $Current Dst)) (set $StkLimit (+ (Crt: ...
; # (set $Current Dst)
  store i8* %127, i8** @$Current
; # (set $StkLimit (+ (Crt: lim) 1024))
; # (Crt: lim)
  %128 = getelementptr i8, i8* %127, i32 40
  %129 = bitcast i8* %128 to i8**
  %130 = load i8*, i8** %129
; # (+ (Crt: lim) 1024)
  %131 = getelementptr i8, i8* %130, i32 1024
  store i8* %131, i8** @$StkLimit
; # (set $At (Crt: at))
; # (Crt: at)
  %132 = getelementptr i8, i8* %127, i32 48
  %133 = ptrtoint i8* %132 to i64
  %134 = inttoptr i64 %133 to i64*
  %135 = load i64, i64* %134
  %136 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  store i64 %135, i64* %136
; # (Crt: at 0)
  %137 = getelementptr i8, i8* %127, i32 48
  %138 = ptrtoint i8* %137 to i64
  %139 = inttoptr i64 %138 to i64*
  store i64 0, i64* %139
  br label %$33
$33:
  %140 = phi i8* [%121, %$31], [%125, %$32] ; # Ca
  %141 = phi i64 [%122, %$31], [%126, %$32] ; # Bnd
  %142 = phi i8* [%123, %$31], [%127, %$32] ; # Dst
; # (Ca:)
; # (getCaEnv (Ca:))
  %143 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i8*
  %144 = getelementptr i8, i8* %7, i32 72
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %143, i8* %144, i64 200, i1 0)
  %145 = getelementptr i8, i8* %7, i32 32
  %146 = ptrtoint i8* %145 to i64
  %147 = inttoptr i64 %146 to i64*
  %148 = load i64, i64* %147
  %149 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 0) to i64) to i64*
  store i64 %148, i64* %149
  %150 = getelementptr i8, i8* %7, i32 40
  %151 = ptrtoint i8* %150 to i64
  %152 = inttoptr i64 %151 to i64*
  %153 = load i64, i64* %152
  %154 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 8) to i64) to i64*
  store i64 %153, i64* %154
  %155 = getelementptr i8, i8* %7, i32 48
  %156 = ptrtoint i8* %155 to i64
  %157 = inttoptr i64 %156 to i64*
  %158 = load i64, i64* %157
  %159 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 8) to i64) to i64*
  %160 = getelementptr i64, i64* %159, i32 1
  store i64 %158, i64* %160
  %161 = getelementptr i8, i8* %7, i32 56
  %162 = ptrtoint i8* %161 to i64
  %163 = inttoptr i64 %162 to i64*
  %164 = load i64, i64* %163
  %165 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 112) to i64) to i64*
  store i64 %164, i64* %165
  %166 = getelementptr i8, i8* %7, i32 64
  %167 = ptrtoint i8* %166 to i64
  %168 = inttoptr i64 %167 to i64*
  %169 = load i64, i64* %168
  %170 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 112) to i64) to i64*
  %171 = getelementptr i64, i64* %170, i32 1
  store i64 %169, i64* %171
; # (Ca: fin)
  %172 = getelementptr i8, i8* %7, i32 16
  %173 = ptrtoint i8* %172 to i64
  %174 = inttoptr i64 %173 to i64*
  %175 = load i64, i64* %174
; # (eval (Ca: fin))
  %176 = and i64 %175, 6
  %177 = icmp ne i64 %176, 0
  br i1 %177, label %$36, label %$35
$36:
  br label %$34
$35:
  %178 = and i64 %175, 8
  %179 = icmp ne i64 %178, 0
  br i1 %179, label %$38, label %$37
$38:
  %180 = inttoptr i64 %175 to i64*
  %181 = load i64, i64* %180
  br label %$34
$37:
  %182 = call i64 @evList(i64 %175)
  br label %$34
$34:
  %183 = phi i64 [%175, %$36], [%181, %$38], [%182, %$37] ; # ->
; # (set $Catch (Ca: link))
; # (Ca: link)
  %184 = bitcast i8* %7 to i8**
  %185 = load i8*, i8** %184
  store i8* %185, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 32) to i8**)
; # (when (== Ca Catch) (ret))
; # (== Ca Catch)
  %186 = icmp eq i8* %140, %0
  br i1 %186, label %$39, label %$40
$39:
  %187 = phi i8* [%140, %$34] ; # Ca
  %188 = phi i64 [%141, %$34] ; # Bnd
; # (ret)
  ret void
$40:
  %189 = phi i8* [%140, %$34] ; # Ca
  %190 = phi i64 [%141, %$34] ; # Bnd
; # (Ca: link)
  %191 = bitcast i8* %7 to i8**
  %192 = load i8*, i8** %191
  br label %$2
$4:
  %193 = phi i8* [%4, %$2] ; # Ca
  %194 = phi i64 [%5, %$2] ; # Bnd
; # (while Bnd (set (val 2 Bnd) (val Bnd)) (setq Bnd (val 3 Bnd)))
  br label %$41
$41:
  %195 = phi i8* [%193, %$4], [%198, %$42] ; # Ca
  %196 = phi i64 [%194, %$4], [%208, %$42] ; # Bnd
  %197 = icmp ne i64 %196, 0
  br i1 %197, label %$42, label %$43
$42:
  %198 = phi i8* [%195, %$41] ; # Ca
  %199 = phi i64 [%196, %$41] ; # Bnd
; # (set (val 2 Bnd) (val Bnd))
; # (val 2 Bnd)
  %200 = inttoptr i64 %199 to i64*
  %201 = getelementptr i64, i64* %200, i32 1
  %202 = load i64, i64* %201
; # (val Bnd)
  %203 = inttoptr i64 %199 to i64*
  %204 = load i64, i64* %203
  %205 = inttoptr i64 %202 to i64*
  store i64 %204, i64* %205
; # (val 3 Bnd)
  %206 = inttoptr i64 %199 to i64*
  %207 = getelementptr i64, i64* %206, i32 2
  %208 = load i64, i64* %207
  br label %$41
$43:
  %209 = phi i8* [%195, %$41] ; # Ca
  %210 = phi i64 [%196, %$41] ; # Bnd
; # (set $Bind 0)
  %211 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 0, i64* %211
; # (while (val $CtlFrames) (popCtlFiles))
  br label %$44
$44:
  %212 = phi i8* [%209, %$43], [%216, %$45] ; # Ca
  %213 = phi i64 [%210, %$43], [%217, %$45] ; # Bnd
; # (val $CtlFrames)
  %214 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 64) to i8**)
  %215 = icmp ne i8* %214, null
  br i1 %215, label %$45, label %$46
$45:
  %216 = phi i8* [%212, %$44] ; # Ca
  %217 = phi i64 [%213, %$44] ; # Bnd
; # (popCtlFiles)
  call void @popCtlFiles()
  br label %$44
$46:
  %218 = phi i8* [%212, %$44] ; # Ca
  %219 = phi i64 [%213, %$44] ; # Bnd
; # (while (val $ErrFrames) (popErrFiles))
  br label %$47
$47:
  %220 = phi i8* [%218, %$46], [%224, %$48] ; # Ca
  %221 = phi i64 [%219, %$46], [%225, %$48] ; # Bnd
; # (val $ErrFrames)
  %222 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 56) to i8**)
  %223 = icmp ne i8* %222, null
  br i1 %223, label %$48, label %$49
$48:
  %224 = phi i8* [%220, %$47] ; # Ca
  %225 = phi i64 [%221, %$47] ; # Bnd
; # (popErrFiles)
  call void @popErrFiles()
  br label %$47
$49:
  %226 = phi i8* [%220, %$47] ; # Ca
  %227 = phi i64 [%221, %$47] ; # Bnd
; # (until (== (val $OutFrames) (val $Stdout)) (popOutFiles))
  br label %$50
$50:
  %228 = phi i8* [%226, %$49], [%233, %$51] ; # Ca
  %229 = phi i64 [%227, %$49], [%234, %$51] ; # Bnd
; # (val $OutFrames)
  %230 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 48) to i8**)
; # (val $Stdout)
  %231 = load i8*, i8** @$Stdout
; # (== (val $OutFrames) (val $Stdout))
  %232 = icmp eq i8* %230, %231
  br i1 %232, label %$52, label %$51
$51:
  %233 = phi i8* [%228, %$50] ; # Ca
  %234 = phi i64 [%229, %$50] ; # Bnd
; # (popOutFiles)
  call void @popOutFiles()
  br label %$50
$52:
  %235 = phi i8* [%228, %$50] ; # Ca
  %236 = phi i64 [%229, %$50] ; # Bnd
; # (until (== (val $InFrames) (val $Stdin)) (popInFiles))
  br label %$53
$53:
  %237 = phi i8* [%235, %$52], [%242, %$54] ; # Ca
  %238 = phi i64 [%236, %$52], [%243, %$54] ; # Bnd
; # (val $InFrames)
  %239 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 40) to i8**)
; # (val $Stdin)
  %240 = load i8*, i8** @$Stdin
; # (== (val $InFrames) (val $Stdin))
  %241 = icmp eq i8* %239, %240
  br i1 %241, label %$55, label %$54
$54:
  %242 = phi i8* [%237, %$53] ; # Ca
  %243 = phi i64 [%238, %$53] ; # Bnd
; # (popInFiles)
  call void @popInFiles()
  br label %$53
$55:
  %244 = phi i8* [%237, %$53] ; # Ca
  %245 = phi i64 [%238, %$53] ; # Bnd
; # (let (Src (val $Current) Dst (val $Coroutines)) (unless (== Src D...
; # (val $Current)
  %246 = load i8*, i8** @$Current
; # (val $Coroutines)
  %247 = load i8*, i8** @$Coroutines
; # (unless (== Src Dst) (stop Src) (let Crt: (coroutine (set $Curren...
; # (== Src Dst)
  %248 = icmp eq i8* %246, %247
  br i1 %248, label %$57, label %$56
$56:
  %249 = phi i8* [%244, %$55] ; # Ca
  %250 = phi i64 [%245, %$55] ; # Bnd
; # (stop Src)
  call void @stop(i8* %246)
; # (let Crt: (coroutine (set $Current Dst)) (set $StkLimit (+ (Crt: ...
; # (set $Current Dst)
  store i8* %247, i8** @$Current
; # (set $StkLimit (+ (Crt: lim) 1024))
; # (Crt: lim)
  %251 = getelementptr i8, i8* %247, i32 40
  %252 = bitcast i8* %251 to i8**
  %253 = load i8*, i8** %252
; # (+ (Crt: lim) 1024)
  %254 = getelementptr i8, i8* %253, i32 1024
  store i8* %254, i8** @$StkLimit
; # (Crt:)
; # (getCrtEnv (Crt:))
  %255 = getelementptr i8, i8* %247, i32 112
  %256 = ptrtoint i8* %255 to i64
  %257 = inttoptr i64 %256 to i64*
  %258 = load i64, i64* %257
  %259 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 0) to i64) to i64*
  store i64 %258, i64* %259
  %260 = getelementptr i8, i8* %247, i32 120
  %261 = ptrtoint i8* %260 to i64
  %262 = inttoptr i64 %261 to i64*
  %263 = load i64, i64* %262
  %264 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 8) to i64) to i64*
  store i64 %263, i64* %264
  %265 = getelementptr i8, i8* %247, i32 128
  %266 = ptrtoint i8* %265 to i64
  %267 = inttoptr i64 %266 to i64*
  %268 = load i64, i64* %267
  %269 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 8) to i64) to i64*
  %270 = getelementptr i64, i64* %269, i32 1
  store i64 %268, i64* %270
  %271 = getelementptr i8, i8* %247, i32 136
  %272 = ptrtoint i8* %271 to i64
  %273 = inttoptr i64 %272 to i64*
  %274 = load i64, i64* %273
  %275 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 112) to i64) to i64*
  store i64 %274, i64* %275
  %276 = getelementptr i8, i8* %247, i32 144
  %277 = ptrtoint i8* %276 to i64
  %278 = inttoptr i64 %277 to i64*
  %279 = load i64, i64* %278
  %280 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 112) to i64) to i64*
  %281 = getelementptr i64, i64* %280, i32 1
  store i64 %279, i64* %281
; # (set $At (Crt: at))
; # (Crt: at)
  %282 = getelementptr i8, i8* %247, i32 48
  %283 = ptrtoint i8* %282 to i64
  %284 = inttoptr i64 %283 to i64*
  %285 = load i64, i64* %284
  %286 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  store i64 %285, i64* %286
; # (Crt: at 0)
  %287 = getelementptr i8, i8* %247, i32 48
  %288 = ptrtoint i8* %287 to i64
  %289 = inttoptr i64 %288 to i64*
  store i64 0, i64* %289
  br label %$57
$57:
  %290 = phi i8* [%244, %$55], [%249, %$56] ; # Ca
  %291 = phi i64 [%245, %$55], [%250, %$56] ; # Bnd
  ret void
}

define void @giveup(i8*) align 8 {
$1:
; # (stderrMsg ($ "Give up: %s^J") Msg)
  %1 = call i8* @stderrMsg(i8* bitcast ([13 x i8]* @$2 to i8*), i8* %0)
; # (setCooked)
  call void @setCooked()
; # (exit 1)
  call void @exit(i32 1)
  unreachable
}

define void @bye(i32) align 8 {
$1:
; # (unless (val $InBye) (set $InBye YES) (unwind null) (exec (val $B...
; # (val $InBye)
  %1 = load i1, i1* @$InBye
  br i1 %1, label %$3, label %$2
$2:
; # (set $InBye YES)
  store i1 1, i1* @$InBye
; # (unwind null)
  call void @unwind(i8* null)
; # (val $Bye)
  %2 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 808) to i64) to i64*
  %3 = load i64, i64* %2
; # (exec (val $Bye))
  br label %$4
$4:
  %4 = phi i64 [%3, %$2], [%16, %$7] ; # Prg
  %5 = inttoptr i64 %4 to i64*
  %6 = load i64, i64* %5
  %7 = getelementptr i64, i64* %5, i32 1
  %8 = load i64, i64* %7
  %9 = and i64 %6, 15
  %10 = icmp eq i64 %9, 0
  br i1 %10, label %$5, label %$6
$5:
  %11 = phi i64 [%8, %$4] ; # Prg
  %12 = call i64 @evList(i64 %6)
  br label %$6
$6:
  %13 = phi i64 [%8, %$4], [%11, %$5] ; # Prg
  %14 = and i64 %13, 15
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$8, label %$7
$7:
  %16 = phi i64 [%13, %$6] ; # Prg
  br label %$4
$8:
  %17 = phi i64 [%13, %$6] ; # Prg
  %18 = phi i64 [0, %$6] ; # ->
  br label %$3
$3:
; # (when (nil? (val $PPid)) (flushAll))
; # (val $PPid)
  %19 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 216) to i64) to i64*
  %20 = load i64, i64* %19
; # (nil? (val $PPid))
  %21 = icmp eq i64 %20, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %21, label %$9, label %$10
$9:
; # (flushAll)
  call void @flushAll()
  br label %$10
$10:
; # (setCooked)
  call void @setCooked()
; # (exit N)
  call void @exit(i32 %0)
  unreachable
}

define void @execErr(i8*) align 8 {
$1:
; # (stderrMsg ($ "%s: Can't exec^J") Cmd)
  %1 = call i8* @stderrMsg(i8* bitcast ([16 x i8]* @$3 to i8*), i8* %0)
; # (exit 127)
  call void @exit(i32 127)
  unreachable
}

define i8* @alloc(i8*, i64) align 8 {
$1:
; # (unless (realloc Ptr Siz) (giveup ($ "No memory")))
; # (realloc Ptr Siz)
  %2 = call i8* @realloc(i8* %0, i64 %1)
  %3 = icmp ne i8* %2, null
  br i1 %3, label %$3, label %$2
$2:
; # (giveup ($ "No memory"))
  call void @giveup(i8* bitcast ([10 x i8]* @$4 to i8*))
  unreachable
$3:
  ret i8* %2
}

define void @heapAlloc() align 8 {
$1:
; # (let (H (any (alloc null (* 8 (inc HEAP)))) P (ofs H HEAP) A (val...
; # (inc HEAP)
; # (* 8 (inc HEAP))
; # (alloc null (* 8 (inc HEAP)))
  %0 = call i8* @alloc(i8* null, i64 1048584)
; # (any (alloc null (* 8 (inc HEAP))))
  %1 = ptrtoint i8* %0 to i64
; # (ofs H HEAP)
  %2 = add i64 %1, 1048576
; # (val $Avail)
  %3 = load i64, i64* @$Avail
; # (set P (val $Heaps) $Heaps H)
; # (val $Heaps)
  %4 = load i64, i64* @$Heaps
  %5 = inttoptr i64 %2 to i64*
  store i64 %4, i64* %5
  store i64 %1, i64* @$Heaps
; # (loop (set (setq P (ofs P -2)) A) (? (== (setq A P) H)))
  br label %$2
$2:
  %6 = phi i64 [%2, %$1], [%11, %$3] ; # P
  %7 = phi i64 [%3, %$1], [%12, %$3] ; # A
; # (set (setq P (ofs P -2)) A)
; # (ofs P -2)
  %8 = add i64 %6, -16
  %9 = inttoptr i64 %8 to i64*
  store i64 %7, i64* %9
; # (? (== (setq A P) H))
; # (== (setq A P) H)
  %10 = icmp eq i64 %8, %1
  br i1 %10, label %$4, label %$3
$3:
  %11 = phi i64 [%8, %$2] ; # P
  %12 = phi i64 [%8, %$2] ; # A
  br label %$2
$4:
  %13 = phi i64 [%8, %$2] ; # P
  %14 = phi i64 [%8, %$2] ; # A
  %15 = phi i64 [0, %$2] ; # ->
; # (set $Avail A)
  store i64 %14, i64* @$Avail
  ret void
}

define void @sig(i32) align 8 {
$1:
; # (if (val $TtyPid) (kill @ N) (set $Signal (+ (val $Signal) 1)) (l...
; # (val $TtyPid)
  %1 = load i32, i32* @$TtyPid
  %2 = icmp ne i32 %1, 0
  br i1 %2, label %$2, label %$3
$2:
; # (kill @ N)
  %3 = call i32 @kill(i32 %1, i32 %0)
  br label %$4
$3:
; # (set $Signal (+ (val $Signal) 1))
; # (val $Signal)
  %4 = load i32, i32* bitcast ([16 x i32]* @$Signal to i32*)
; # (+ (val $Signal) 1)
  %5 = add i32 %4, 1
  store i32 %5, i32* bitcast ([16 x i32]* @$Signal to i32*)
; # (let P (ofs $Signal (gSignal N)) (set P (+ (val P) 1)))
; # (gSignal N)
  %6 = call i32 @gSignal(i32 %0)
; # (ofs $Signal (gSignal N))
  %7 = getelementptr i32, i32* bitcast ([16 x i32]* @$Signal to i32*), i32 %6
; # (set P (+ (val P) 1))
; # (val P)
  %8 = load i32, i32* %7
; # (+ (val P) 1)
  %9 = add i32 %8, 1
  store i32 %9, i32* %7
  br label %$4
$4:
  %10 = phi i32 [%3, %$2], [%9, %$3] ; # ->
  ret void
}

define void @sigTerm(i32) align 8 {
$1:
; # (if (val $TtyPid) (kill @ N) (set $Signal (+ (val $Signal) 1)) (l...
; # (val $TtyPid)
  %1 = load i32, i32* @$TtyPid
  %2 = icmp ne i32 %1, 0
  br i1 %2, label %$2, label %$3
$2:
; # (kill @ N)
  %3 = call i32 @kill(i32 %1, i32 %0)
  br label %$4
$3:
; # (set $Signal (+ (val $Signal) 1))
; # (val $Signal)
  %4 = load i32, i32* bitcast ([16 x i32]* @$Signal to i32*)
; # (+ (val $Signal) 1)
  %5 = add i32 %4, 1
  store i32 %5, i32* bitcast ([16 x i32]* @$Signal to i32*)
; # (let P (ofs $Signal (gSignal (val SIGTERM Sig))) (set P (+ (val P...
; # (val SIGTERM Sig)
  %6 = getelementptr i32, i32* @Sig, i32 6
  %7 = load i32, i32* %6
; # (gSignal (val SIGTERM Sig))
  %8 = call i32 @gSignal(i32 %7)
; # (ofs $Signal (gSignal (val SIGTERM Sig)))
  %9 = getelementptr i32, i32* bitcast ([16 x i32]* @$Signal to i32*), i32 %8
; # (set P (+ (val P) 1))
; # (val P)
  %10 = load i32, i32* %9
; # (+ (val P) 1)
  %11 = add i32 %10, 1
  store i32 %11, i32* %9
  br label %$4
$4:
  %12 = phi i32 [%3, %$2], [%11, %$3] ; # ->
  ret void
}

define void @sighandler(i64) align 8 {
$1:
; # (unless (val $Protect) (set $Protect 1) (let P T (loop (cond ((va...
; # (val $Protect)
  %1 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 176) to i32*)
  %2 = icmp ne i32 %1, 0
  br i1 %2, label %$3, label %$2
$2:
; # (set $Protect 1)
  store i32 1, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 176) to i32*)
; # (let P T (loop (cond ((val (setq P (ofs $Signal SIGIO))) (set P (...
; # (loop (cond ((val (setq P (ofs $Signal SIGIO))) (set P (dec @)) (...
  br label %$4
$4:
; # (cond ((val (setq P (ofs $Signal SIGIO))) (set P (dec @)) (set $S...
; # (ofs $Signal SIGIO)
  %3 = getelementptr i32, i32* bitcast ([16 x i32]* @$Signal to i32*), i32 15
; # (val (setq P (ofs $Signal SIGIO)))
  %4 = load i32, i32* %3
  %5 = icmp ne i32 %4, 0
  br i1 %5, label %$7, label %$6
$7:
  %6 = phi i32* [%3, %$4] ; # P
; # (set P (dec @))
; # (dec @)
  %7 = sub i32 %4, 1
  store i32 %7, i32* %6
; # (set $Signal (dec (val $Signal)))
; # (val $Signal)
  %8 = load i32, i32* bitcast ([16 x i32]* @$Signal to i32*)
; # (dec (val $Signal))
  %9 = sub i32 %8, 1
  store i32 %9, i32* bitcast ([16 x i32]* @$Signal to i32*)
; # (val $Sigio)
  %10 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 32) to i64) to i64*
  %11 = load i64, i64* %10
; # (execAt (val $Sigio))
  %12 = call i64 @execAt(i64 %11)
  br label %$5
$6:
  %13 = phi i32* [%3, %$4] ; # P
; # (ofs $Signal SIGUSR1)
  %14 = getelementptr i32, i32* bitcast ([16 x i32]* @$Signal to i32*), i32 3
; # (val (setq P (ofs $Signal SIGUSR1)))
  %15 = load i32, i32* %14
  %16 = icmp ne i32 %15, 0
  br i1 %16, label %$9, label %$8
$9:
  %17 = phi i32* [%14, %$6] ; # P
; # (set P (dec @))
; # (dec @)
  %18 = sub i32 %15, 1
  store i32 %18, i32* %17
; # (set $Signal (dec (val $Signal)))
; # (val $Signal)
  %19 = load i32, i32* bitcast ([16 x i32]* @$Signal to i32*)
; # (dec (val $Signal))
  %20 = sub i32 %19, 1
  store i32 %20, i32* bitcast ([16 x i32]* @$Signal to i32*)
; # (val $Sig1)
  %21 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 632) to i64) to i64*
  %22 = load i64, i64* %21
; # (execAt (val $Sig1))
  %23 = call i64 @execAt(i64 %22)
  br label %$5
$8:
  %24 = phi i32* [%14, %$6] ; # P
; # (ofs $Signal SIGUSR2)
  %25 = getelementptr i32, i32* bitcast ([16 x i32]* @$Signal to i32*), i32 4
; # (val (setq P (ofs $Signal SIGUSR2)))
  %26 = load i32, i32* %25
  %27 = icmp ne i32 %26, 0
  br i1 %27, label %$11, label %$10
$11:
  %28 = phi i32* [%25, %$8] ; # P
; # (set P (dec @))
; # (dec @)
  %29 = sub i32 %26, 1
  store i32 %29, i32* %28
; # (set $Signal (dec (val $Signal)))
; # (val $Signal)
  %30 = load i32, i32* bitcast ([16 x i32]* @$Signal to i32*)
; # (dec (val $Signal))
  %31 = sub i32 %30, 1
  store i32 %31, i32* bitcast ([16 x i32]* @$Signal to i32*)
; # (val $Sig2)
  %32 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 648) to i64) to i64*
  %33 = load i64, i64* %32
; # (execAt (val $Sig2))
  %34 = call i64 @execAt(i64 %33)
  br label %$5
$10:
  %35 = phi i32* [%25, %$8] ; # P
; # (ofs $Signal SIGALRM)
  %36 = getelementptr i32, i32* bitcast ([16 x i32]* @$Signal to i32*), i32 6
; # (val (setq P (ofs $Signal SIGALRM)))
  %37 = load i32, i32* %36
  %38 = icmp ne i32 %37, 0
  br i1 %38, label %$13, label %$12
$13:
  %39 = phi i32* [%36, %$10] ; # P
; # (set P (dec @))
; # (dec @)
  %40 = sub i32 %37, 1
  store i32 %40, i32* %39
; # (set $Signal (dec (val $Signal)))
; # (val $Signal)
  %41 = load i32, i32* bitcast ([16 x i32]* @$Signal to i32*)
; # (dec (val $Signal))
  %42 = sub i32 %41, 1
  store i32 %42, i32* bitcast ([16 x i32]* @$Signal to i32*)
; # (val $Alarm)
  %43 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 24) to i64) to i64*
  %44 = load i64, i64* %43
; # (execAt (val $Alarm))
  %45 = call i64 @execAt(i64 %44)
  br label %$5
$12:
  %46 = phi i32* [%36, %$10] ; # P
; # (ofs $Signal SIGHUP)
  %47 = getelementptr i32, i32* bitcast ([16 x i32]* @$Signal to i32*), i32 1
; # (val (setq P (ofs $Signal SIGHUP)))
  %48 = load i32, i32* %47
  %49 = icmp ne i32 %48, 0
  br i1 %49, label %$15, label %$14
$15:
  %50 = phi i32* [%47, %$12] ; # P
; # (set P (dec @))
; # (dec @)
  %51 = sub i32 %48, 1
  store i32 %51, i32* %50
; # (set $Signal (dec (val $Signal)))
; # (val $Signal)
  %52 = load i32, i32* bitcast ([16 x i32]* @$Signal to i32*)
; # (dec (val $Signal))
  %53 = sub i32 %52, 1
  store i32 %53, i32* bitcast ([16 x i32]* @$Signal to i32*)
; # (val $Hup)
  %54 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 616) to i64) to i64*
  %55 = load i64, i64* %54
; # (execAt (val $Hup))
  %56 = call i64 @execAt(i64 %55)
  br label %$5
$14:
  %57 = phi i32* [%47, %$12] ; # P
; # (ofs $Signal SIGINT)
  %58 = getelementptr i32, i32* bitcast ([16 x i32]* @$Signal to i32*), i32 2
; # (val (setq P (ofs $Signal SIGINT)))
  %59 = load i32, i32* %58
  %60 = icmp ne i32 %59, 0
  br i1 %60, label %$17, label %$16
$17:
  %61 = phi i32* [%58, %$14] ; # P
; # (set P (dec @))
; # (dec @)
  %62 = sub i32 %59, 1
  store i32 %62, i32* %61
; # (set $Signal (dec (val $Signal)))
; # (val $Signal)
  %63 = load i32, i32* bitcast ([16 x i32]* @$Signal to i32*)
; # (dec (val $Signal))
  %64 = sub i32 %63, 1
  store i32 %64, i32* bitcast ([16 x i32]* @$Signal to i32*)
; # (unless (val $PRepl) (wrnl) (rlSigBeg) (brkLoad (if Exe @ $Nil)) ...
; # (val $PRepl)
  %65 = load i1, i1* @$PRepl
  br i1 %65, label %$19, label %$18
$18:
  %66 = phi i32* [%61, %$17] ; # P
; # (wrnl)
  %67 = call i64 @wrnl()
; # (rlSigBeg)
  call void @rlSigBeg()
; # (if Exe @ $Nil)
  %68 = icmp ne i64 %0, 0
  br i1 %68, label %$20, label %$21
$20:
  %69 = phi i32* [%66, %$18] ; # P
  br label %$22
$21:
  %70 = phi i32* [%66, %$18] ; # P
  br label %$22
$22:
  %71 = phi i32* [%69, %$20], [%70, %$21] ; # P
  %72 = phi i64 [%0, %$20], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$21] ; # ->
; # (brkLoad (if Exe @ $Nil))
  %73 = call i64 @brkLoad(i64 %72)
; # (rlSigEnd)
  call void @rlSigEnd()
  br label %$19
$19:
  %74 = phi i32* [%61, %$17], [%71, %$22] ; # P
  br label %$5
$16:
  %75 = phi i32* [%58, %$14] ; # P
; # (ofs $Signal SIGWINCH)
  %76 = getelementptr i32, i32* bitcast ([16 x i32]* @$Signal to i32*), i32 14
; # (val (setq P (ofs $Signal SIGWINCH)))
  %77 = load i32, i32* %76
  %78 = icmp ne i32 %77, 0
  br i1 %78, label %$24, label %$23
$24:
  %79 = phi i32* [%76, %$16] ; # P
; # (set P (dec @))
; # (dec @)
  %80 = sub i32 %77, 1
  store i32 %80, i32* %79
; # (set $Signal (dec (val $Signal)))
; # (val $Signal)
  %81 = load i32, i32* bitcast ([16 x i32]* @$Signal to i32*)
; # (dec (val $Signal))
  %82 = sub i32 %81, 1
  store i32 %82, i32* bitcast ([16 x i32]* @$Signal to i32*)
; # (val $Winch)
  %83 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 664) to i64) to i64*
  %84 = load i64, i64* %83
; # (execAt (val $Winch))
  %85 = call i64 @execAt(i64 %84)
  br label %$5
$23:
  %86 = phi i32* [%76, %$16] ; # P
; # (ofs $Signal SIGTSTP)
  %87 = getelementptr i32, i32* bitcast ([16 x i32]* @$Signal to i32*), i32 11
; # (val (setq P (ofs $Signal SIGTSTP)))
  %88 = load i32, i32* %87
  %89 = icmp ne i32 %88, 0
  br i1 %89, label %$26, label %$25
$26:
  %90 = phi i32* [%87, %$23] ; # P
; # (set P (dec @))
; # (dec @)
  %91 = sub i32 %88, 1
  store i32 %91, i32* %90
; # (set $Signal (dec (val $Signal)))
; # (val $Signal)
  %92 = load i32, i32* bitcast ([16 x i32]* @$Signal to i32*)
; # (dec (val $Signal))
  %93 = sub i32 %92, 1
  store i32 %93, i32* bitcast ([16 x i32]* @$Signal to i32*)
; # (rlSigBeg)
  call void @rlSigBeg()
; # (val $TStp1)
  %94 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 680) to i64) to i64*
  %95 = load i64, i64* %94
; # (execAt (val $TStp1))
  %96 = call i64 @execAt(i64 %95)
; # (stopTerm)
  call void @stopTerm()
; # (val SIGTSTP Sig)
  %97 = getelementptr i32, i32* @Sig, i32 10
  %98 = load i32, i32* %97
; # (fun sig)
; # (i8* (def (pico~pack "@" (pico~car cross~Args)) (func (; cross~Ar...
  %99 = bitcast void(i32)* @sig to i8*
; # (iSignal (val SIGTSTP Sig) (fun sig))
  call void @iSignal(i32 %98, i8* %99)
; # (val $TStp2)
  %100 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 696) to i64) to i64*
  %101 = load i64, i64* %100
; # (execAt (val $TStp2))
  %102 = call i64 @execAt(i64 %101)
; # (rlSigEnd)
  call void @rlSigEnd()
  br label %$5
$25:
  %103 = phi i32* [%87, %$23] ; # P
; # (ofs $Signal SIGTERM)
  %104 = getelementptr i32, i32* bitcast ([16 x i32]* @$Signal to i32*), i32 7
; # (val (setq P (ofs $Signal SIGTERM)))
  %105 = load i32, i32* %104
  %106 = icmp ne i32 %105, 0
  br i1 %106, label %$28, label %$27
$28:
  %107 = phi i32* [%104, %$25] ; # P
; # (if (nil? (run (val $Term))) (let (Cld (val $Child) 
  br label %$31
$30:
  %126 = phi i64 [%114, %$29] ; # Prg
  %127 = and i64 %112, 15
  %128 = icmp eq i64 %127, 0
  br i1 %128, label %$39, label %$38
$39:
  %129 = phi i64 [%126, %$30] ; # Prg
  %130 = call i64 @evList(i64 %112)
  %131 = icmp ne i64 %130, 0
  br label %$38
$38:
  %132 = phi i64 [%126, %$30], [%129, %$39] ; # Prg
  %133 = phi i1 [0, %$30], [%131, %$39] ; # ->
  br label %$29
$31:
  %134 = phi i64 [%117, %$33] ; # Prg
  %135 = phi i64 [%125, %$33] ; # ->
; # (nil? (run (val $Term)))
  %136 = icmp eq i64 %135, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %136, label %$40, label %$41
$40:
  %137 = phi i32* [%107, %$31] ; # P
; # (let (Cld (val $Child) 
  br i1 %163, label %$48, label %$49
$48:
  %164 = phi i32* [%160, %$46] ; # P
  %165 = phi i8* [%161, %$46] ; # Cld
  %166 = phi i1 [%162, %$46] ; # Flg
  br label %$49
$49:
  %167 = phi i32* [%160, %$46], [%164, %$48] ; # P
  %168 = phi i8* [%161, %$46], [%165, %$48] ; # Cld
  %169 = phi i1 [%162, %$46], [1, %$48] ; # Flg
; # (ofs Cld (child T))
  %170 = getelementptr i8, i8* %168, i32 32
  br label %$43
$45:
  %171 = phi i32* [%142, %$43] ; # P
  %172 = phi i8* [%143, %$43] ; # Cld
  %173 = phi i1 [%144, %$43] ; # Flg
; # (? Flg)
  br i1 %173, label %$51, label %$50
$50:
  %174 = phi i32* [%171, %$45] ; # P
  %175 = phi i8* [%172, %$45] ; # Cld
  %176 = phi i1 [%173, %$45] ; # Flg
; # (set $Signal 0)
  store i32 0, i32* bitcast ([16 x i32]* @$Signal to i32*)
; # (rlSigBeg)
  call void @rlSigBeg()
; # (bye 0)
  call void @bye(i32 0)
  unreachable
$41:
  %177 = phi i32* [%107, %$31] ; # P
; # (set P (dec (val P)))
; # (val P)
  %178 = load i32, i32* %177
; # (dec (val P))
  %179 = sub i32 %178, 1
  store i32 %179, i32* %177
; # (set $Signal (dec (val $Signal)))
; # (val $Signal)
  %180 = load i32, i32* bitcast ([16 x i32]* @$Signal to i32*)
; # (dec (val $Signal))
  %181 = sub i32 %180, 1
  store i32 %181, i32* bitcast ([16 x i32]* @$Signal to i32*)
  br label %$42
$42:
  %182 = phi i32* [%177, %$41] ; # P
  %183 = phi i32 [%181, %$41] ; # ->
  br label %$5
$27:
  %184 = phi i32* [%104, %$25] ; # P
  br label %$5
$5:
  %185 = phi i32* [%6, %$7], [%17, %$9], [%28, %$11], [%39, %$13], [%50, %$15], [%74, %$19], [%79, %$24], [%90, %$26], [%182, %$42], [%184, %$27] ; # P
; # (? (=0 (val $Signal)))
; # (val $Signal)
  %186 = load i32, i32* bitcast ([16 x i32]* @$Signal to i32*)
; # (=0 (val $Signal))
  %187 = icmp eq i32 %186, 0
  br i1 %187, label %$51, label %$52
$52:
  %188 = phi i32* [%185, %$5] ; # P
  br label %$4
$51:
  %189 = phi i32* [%171, %$45], [%185, %$5] ; # P
  %190 = phi i64 [0, %$45], [0, %$5] ; # ->
; # (set $Protect 0)
  store i32 0, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 176) to i32*)
  br label %$3
$3:
  ret void
}

define void @err(i64, i64, i8*, i8*) align 8 {
$1:
; # (set $Up (if Exe @ $Nil))
; # (if Exe @ $Nil)
  %4 = icmp ne i64 %0, 0
  br i1 %4, label %$2, label %$3
$2:
  br label %$4
$3:
  br label %$4
$4:
  %5 = phi i64 [%0, %$2], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$3] ; # ->
  %6 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 728) to i64) to i64*
  store i64 %5, i64* %6
; # (when X (link (push X NIL)))
  %7 = icmp ne i64 %1, 0
  br i1 %7, label %$5, label %$6
$5:
; # (push X NIL)
  %8 = alloca i64, i64 2, align 16
  %9 = ptrtoint i64* %8 to i64
  %10 = inttoptr i64 %9 to i64*
  store i64 %1, i64* %10
; # (link (push X NIL))
  %11 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %12 = load i64, i64* %11
  %13 = inttoptr i64 %9 to i64*
  %14 = getelementptr i64, i64* %13, i32 1
  store i64 %12, i64* %14
  %15 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %9, i64* %15
  br label %$6
$6:
; # (let Msg (b8 240) (gPrintf Msg 240 Fmt Arg) (when (val Msg) (set ...
; # (b8 240)
  %16 = alloca i8, i64 240
; # (gPrintf Msg 240 Fmt Arg)
  call void @gPrintf(i8* %16, i32 240, i8* %2, i8* %3)
; # (when (val Msg) (set $Msg (mkStr Msg)) (let Ca (val $Catch) (whil...
; # (val Msg)
  %17 = load i8, i8* %16
  %18 = icmp ne i8 %17, 0
  br i1 %18, label %$7, label %$8
$7:
; # (set $Msg (mkStr Msg))
; # (mkStr Msg)
  %19 = call i64 @mkStr(i8* %16)
  %20 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 760) to i64) to i64*
  store i64 %19, i64* %20
; # (let Ca (val $Catch) (while Ca (let Ca: (caFrame Ca) (let Tag (Ca...
; # (val $Catch)
  %21 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 32) to i8**)
; # (while Ca (let Ca: (caFrame Ca) (let Tag (Ca: tag) (when Tag (whi...
  br label %$9
$9:
  %22 = phi i8* [%21, %$7], [%68, %$13] ; # Ca
  %23 = icmp ne i8* %22, null
  br i1 %23, label %$10, label %$11
$10:
  %24 = phi i8* [%22, %$9] ; # Ca
; # (let Ca: (caFrame Ca) (let Tag (Ca: tag) (when Tag (while (pair T...
; # (let Tag (Ca: tag) (when Tag (while (pair Tag) (when (subStr (car...
; # (Ca: tag)
  %25 = getelementptr i8, i8* %24, i32 8
  %26 = ptrtoint i8* %25 to i64
  %27 = inttoptr i64 %26 to i64*
  %28 = load i64, i64* %27
; # (when Tag (while (pair Tag) (when (subStr (car Tag) (val $Msg)) (...
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %$12, label %$13
$12:
  %30 = phi i8* [%24, %$10] ; # Ca
  %31 = phi i64 [%28, %$10] ; # Tag
; # (while (pair Tag) (when (subStr (car Tag) (val $Msg)) (unwind (Ca...
  br label %$14
$14:
  %32 = phi i8* [%30, %$12], [%58, %$18] ; # Ca
  %33 = phi i64 [%31, %$12], [%62, %$18] ; # Tag
; # (pair Tag)
  %34 = and i64 %33, 15
  %35 = icmp eq i64 %34, 0
  br i1 %35, label %$15, label %$16
$15:
  %36 = phi i8* [%32, %$14] ; # Ca
  %37 = phi i64 [%33, %$14] ; # Tag
; # (when (subStr (car Tag) (val $Msg)) (unwind (Ca:)) (set $Ret (if ...
; # (car Tag)
  %38 = inttoptr i64 %37 to i64*
  %39 = load i64, i64* %38
; # (val $Msg)
  %40 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 760) to i64) to i64*
  %41 = load i64, i64* %40
; # (subStr (car Tag) (val $Msg))
  %42 = call i1 @subStr(i64 %39, i64 %41)
  br i1 %42, label %$17, label %$18
$17:
  %43 = phi i8* [%36, %$15] ; # Ca
  %44 = phi i64 [%37, %$15] ; # Tag
; # (Ca:)
; # (unwind (Ca:))
  call void @unwind(i8* %24)
; # (set $Ret (if (nil? (car Tag)) (val $Msg) @))
; # (if (nil? (car Tag)) (val $Msg) @)
; # (car Tag)
  %45 = inttoptr i64 %44 to i64*
  %46 = load i64, i64* %45
; # (nil? (car Tag))
  %47 = icmp eq i64 %46, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %47, label %$19, label %$20
$19:
  %48 = phi i8* [%43, %$17] ; # Ca
  %49 = phi i64 [%44, %$17] ; # Tag
; # (val $Msg)
  %50 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 760) to i64) to i64*
  %51 = load i64, i64* %50
  br label %$21
$20:
  %52 = phi i8* [%43, %$17] ; # Ca
  %53 = phi i64 [%44, %$17] ; # Tag
  br label %$21
$21:
  %54 = phi i8* [%48, %$19], [%52, %$20] ; # Ca
  %55 = phi i64 [%49, %$19], [%53, %$20] ; # Tag
  %56 = phi i64 [%51, %$19], [%46, %$20] ; # ->
  store i64 %56, i64* @$Ret
; # (Ca: (rst))
  %57 = getelementptr i8, i8* %24, i32 272
; # (longjmp (Ca: (rst)) 1)
  call void @longjmp(i8* %57, i32 1)
  unreachable
$18:
  %58 = phi i8* [%36, %$15] ; # Ca
  %59 = phi i64 [%37, %$15] ; # Tag
; # (shift Tag)
  %60 = inttoptr i64 %59 to i64*
  %61 = getelementptr i64, i64* %60, i32 1
  %62 = load i64, i64* %61
  br label %$14
$16:
  %63 = phi i8* [%32, %$14] ; # Ca
  %64 = phi i64 [%33, %$14] ; # Tag
  br label %$13
$13:
  %65 = phi i8* [%24, %$10], [%63, %$16] ; # Ca
  %66 = phi i64 [%28, %$10], [%64, %$16] ; # Tag
; # (Ca: link)
  %67 = bitcast i8* %24 to i8**
  %68 = load i8*, i8** %67
  br label %$9
$11:
  %69 = phi i8* [%22, %$9] ; # Ca
  br label %$8
$8:
; # (flushAll)
  call void @flushAll()
; # (set $Chr (set $ExtN 0))
; # (set $ExtN 0)
  store i32 0, i32* @$ExtN
  store i32 0, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
; # (set $Break 0)
  %70 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 16) to i64) to i64*
  store i64 0, i64* %70
; # (set $LinePtr null)
  store i8* null, i8** @$LinePtr
; # (set $Alarm (set $Sigio $Nil))
; # (set $Sigio $Nil)
  %71 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 32) to i64) to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %71
  %72 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 24) to i64) to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %72
; # (b8+ (ioFrame T))
  %73 = alloca i8, i64 28, align 8
; # (val $OutFiles)
  %74 = load i8**, i8*** @$OutFiles
; # (val 3 (val $OutFiles))
  %75 = getelementptr i8*, i8** %74, i32 2
  %76 = load i8*, i8** %75
; # (pushOutFile (b8+ (ioFrame T)) (val 3 (val $OutFiles)) 0)
  call void @pushOutFile(i8* %73, i8* %76, i32 0)
; # (let In: (inFile (val $InFile)) (when (and (In:) (In: name)) (cal...
; # (val $InFile)
  %77 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 72) to i8**)
; # (when (and (In:) (In: name)) (call $Put (char "[")) (outString (I...
; # (and (In:) (In: name))
; # (In:)
  %78 = icmp ne i8* %77, null
  br i1 %78, label %$23, label %$22
$23:
; # (In: name)
  %79 = bitcast i8* %77 to i8**
  %80 = load i8*, i8** %79
  %81 = icmp ne i8* %80, null
  br label %$22
$22:
  %82 = phi i1 [0, %$8], [%81, %$23] ; # ->
  br i1 %82, label %$24, label %$25
$24:
; # (call $Put (char "["))
  %83 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %83(i8 91)
; # (In: name)
  %84 = bitcast i8* %77 to i8**
  %85 = load i8*, i8** %84
; # (outString (In: name))
  call void @outString(i8* %85)
; # (call $Put (char ":"))
  %86 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %86(i8 58)
; # (In: src)
  %87 = getelementptr i8, i8* %77, i32 20
  %88 = bitcast i8* %87 to i32*
  %89 = load i32, i32* %88
; # (i64 (In: src))
  %90 = sext i32 %89 to i64
; # (outWord (i64 (In: src)))
  call void @outWord(i64 %90)
; # (call $Put (char "]"))
  %91 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %91(i8 93)
; # (space)
  call void @space()
  br label %$25
$25:
; # (when Exe (outString ($ "!? ")) (print Exe) (newline))
  %92 = icmp ne i64 %0, 0
  br i1 %92, label %$26, label %$27
$26:
; # (outString ($ "!? "))
  call void @outString(i8* bitcast ([4 x i8]* @$5 to i8*))
; # (print Exe)
  call void @print(i64 %0)
; # (newline)
  call void @newline()
  br label %$27
$27:
; # (when X (print X) (outString ($ " -- ")))
  %93 = icmp ne i64 %1, 0
  br i1 %93, label %$28, label %$29
$28:
; # (print X)
  call void @print(i64 %1)
; # (outString ($ " -- "))
  call void @outString(i8* bitcast ([5 x i8]* @$6 to i8*))
  br label %$29
$29:
; # (when (val Msg) (outString Msg) (newline) (unless (or (nil? (val ...
; # (val Msg)
  %94 = load i8, i8* %16
  %95 = icmp ne i8 %94, 0
  br i1 %95, label %$30, label %$31
$30:
; # (outString Msg)
  call void @outString(i8* %16)
; # (newline)
  call void @newline()
; # (unless (or (nil? (val $Err)) (val $Jam)) (set $Jam YES) (execAt ...
; # (or (nil? (val $Err)) (val $Jam))
; # (val $Err)
  %96 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 744) to i64) to i64*
  %97 = load i64, i64* %96
; # (nil? (val $Err))
  %98 = icmp eq i64 %97, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %98, label %$32, label %$33
$33:
; # (val $Jam)
  %99 = load i1, i1* @$Jam
  br label %$32
$32:
  %100 = phi i1 [1, %$30], [%99, %$33] ; # ->
  br i1 %100, label %$35, label %$34
$34:
; # (set $Jam YES)
  store i1 1, i1* @$Jam
; # (val $Err)
  %101 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 744) to i64) to i64*
  %102 = load i64, i64* %101
; # (execAt (val $Err))
  %103 = call i64 @execAt(i64 %102)
; # (set $Jam NO)
  store i1 0, i1* @$Jam
  br label %$35
$35:
; # (unless (and ((inFile (val (val $InFiles))) tty) ((outFile (val 2...
; # (and ((inFile (val (val $InFiles))) tty) ((outFile (val 2 (val $O...
; # (val $InFiles)
  %104 = load i8**, i8*** @$InFiles
; # (val (val $InFiles))
  %105 = load i8*, i8** %104
; # ((inFile (val (val $InFiles))) tty)
  %106 = getelementptr i8, i8* %105, i32 4128
  %107 = bitcast i8* %106 to i1*
  %108 = load i1, i1* %107
  br i1 %108, label %$37, label %$36
$37:
; # (val $OutFiles)
  %109 = load i8**, i8*** @$OutFiles
; # (val 2 (val $OutFiles))
  %110 = getelementptr i8*, i8** %109, i32 1
  %111 = load i8*, i8** %110
; # ((outFile (val 2 (val $OutFiles))) tty)
  %112 = getelementptr i8, i8* %111, i32 4104
  %113 = bitcast i8* %112 to i1*
  %114 = load i1, i1* %113
  br label %$36
$36:
  %115 = phi i1 [0, %$35], [%114, %$37] ; # ->
  br i1 %115, label %$39, label %$38
$38:
; # (bye 1)
  call void @bye(i32 1)
  unreachable
$39:
; # (repl 0 ($ "? ") $Nil)
  %116 = call i64 @repl(i64 0, i8* bitcast ([3 x i8]* @$7 to i8*), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  br label %$31
$31:
; # (unless (val $StkLimit) (giveup ($ "No stack")))
; # (val $StkLimit)
  %117 = load i8*, i8** @$StkLimit
  %118 = icmp ne i8* %117, null
  br i1 %118, label %$41, label %$40
$40:
; # (giveup ($ "No stack"))
  call void @giveup(i8* bitcast ([9 x i8]* @$8 to i8*))
  unreachable
$41:
; # (unwind null)
  call void @unwind(i8* null)
; # (set $Link 0 $Protect 0 $Next $Nil $Make 0 $Yoke 0 $Trace 0 $Put ...
  %119 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 0, i64* %119
  store i32 0, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 176) to i32*)
  %120 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 128) to i64) to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %120
  %121 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 152) to i64) to i64*
  store i64 0, i64* %121
  %122 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 160) to i64) to i64*
  store i64 0, i64* %122
  store i32 0, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 184) to i32*)
; # (fun (void i8) _putStdout)
  store void(i8)* @_putStdout, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
; # (fun (i32) _getStdin)
  store i32()* @_getStdin, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
; # (longjmp QuitRst 1)
  call void @longjmp(i8* @QuitRst, i32 1)
  unreachable
}

define void @stkErr(i64) align 8 {
$1:
; # (set $StkLimit null)
  store i8* null, i8** @$StkLimit
; # (if (val $Current) ((coroutine @) tag) 0)
; # (val $Current)
  %1 = load i8*, i8** @$Current
  %2 = icmp ne i8* %1, null
  br i1 %2, label %$2, label %$3
$2:
; # ((coroutine @) tag)
  %3 = ptrtoint i8* %1 to i64
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  br label %$4
$3:
  br label %$4
$4:
  %6 = phi i64 [%5, %$2], [0, %$3] ; # ->
; # (err Exe (if (val $Current) ((coroutine @) tag) 0) ($ "Stack over...
  call void @err(i64 %0, i64 %6, i8* bitcast ([15 x i8]* @$9 to i8*), i8* null)
  unreachable
}

define void @argErr(i64, i64) align 8 {
$1:
; # (err Exe X ($ "Bad argument") null)
  call void @err(i64 %0, i64 %1, i8* bitcast ([13 x i8]* @$10 to i8*), i8* null)
  unreachable
}

define void @cntErr(i64, i64) align 8 {
$1:
; # (err Exe X ($ "Small number expected") null)
  call void @err(i64 %0, i64 %1, i8* bitcast ([22 x i8]* @$11 to i8*), i8* null)
  unreachable
}

define void @numErr(i64, i64) align 8 {
$1:
; # (err Exe X ($ "Number expected") null)
  call void @err(i64 %0, i64 %1, i8* bitcast ([16 x i8]* @$12 to i8*), i8* null)
  unreachable
}

define void @symErr(i64, i64) align 8 {
$1:
; # (err Exe X ($ "Symbol expected") null)
  call void @err(i64 %0, i64 %1, i8* bitcast ([16 x i8]* @$13 to i8*), i8* null)
  unreachable
}

define void @charErr(i64, i64) align 8 {
$1:
; # (err Exe X ($ "Char expected") null)
  call void @err(i64 %0, i64 %1, i8* bitcast ([14 x i8]* @$14 to i8*), i8* null)
  unreachable
}

define void @extErr(i64, i64) align 8 {
$1:
; # (err Exe X ($ "External symbol expected") null)
  call void @err(i64 %0, i64 %1, i8* bitcast ([25 x i8]* @$15 to i8*), i8* null)
  unreachable
}

define void @atomErr(i64, i64) align 8 {
$1:
; # (err Exe X ($ "Atom expected") null)
  call void @err(i64 %0, i64 %1, i8* bitcast ([14 x i8]* @$16 to i8*), i8* null)
  unreachable
}

define void @pairErr(i64, i64) align 8 {
$1:
; # (err Exe X ($ "Cons pair expected") null)
  call void @err(i64 %0, i64 %1, i8* bitcast ([19 x i8]* @$17 to i8*), i8* null)
  unreachable
}

define void @lstErr(i64, i64) align 8 {
$1:
; # (err Exe X ($ "List expected") null)
  call void @err(i64 %0, i64 %1, i8* bitcast ([14 x i8]* @$18 to i8*), i8* null)
  unreachable
}

define void @varErr(i64, i64) align 8 {
$1:
; # (err Exe X ($ "Variable expected") null)
  call void @err(i64 %0, i64 %1, i8* bitcast ([18 x i8]* @$19 to i8*), i8* null)
  unreachable
}

define void @itemErr(i64, i64) align 8 {
$1:
; # (err Exe X ($ "Item not found") null)
  call void @err(i64 %0, i64 %1, i8* bitcast ([15 x i8]* @$20 to i8*), i8* null)
  unreachable
}

define void @protErr(i64, i64) align 8 {
$1:
; # (err Exe X ($ "Protected") null)
  call void @err(i64 %0, i64 %1, i8* bitcast ([10 x i8]* @$21 to i8*), i8* null)
  unreachable
}

define void @lockErr() align 8 {
$1:
; # (strErrno)
  %0 = call i8* @strErrno()
; # (err 0 0 ($ "File lock: %s") (strErrno))
  call void @err(i64 0, i64 0, i8* bitcast ([14 x i8]* @$22 to i8*), i8* %0)
  unreachable
}

define void @forkErr(i64) align 8 {
$1:
; # (err Exe 0 ($ "Can't fork") null)
  call void @err(i64 %0, i64 0, i8* bitcast ([11 x i8]* @$23 to i8*), i8* null)
  unreachable
}

define void @symNspErr(i64, i64) align 8 {
$1:
; # (err Exe X ($ "Bad symbol namespace") null)
  call void @err(i64 %0, i64 %1, i8* bitcast ([21 x i8]* @$24 to i8*), i8* null)
  unreachable
}

define i64 @xCnt(i64, i64) align 8 {
$1:
; # (let N (int (needCnt Exe X)) (if (sign? X) (- N) N))
; # (needCnt Exe X)
  %2 = and i64 %1, 2
  %3 = icmp ne i64 %2, 0
  br i1 %3, label %$3, label %$2
$2:
  call void @cntErr(i64 %0, i64 %1)
  unreachable
$3:
; # (int (needCnt Exe X))
  %4 = lshr i64 %1, 4
; # (if (sign? X) (- N) N)
; # (sign? X)
  %5 = and i64 %1, 8
  %6 = icmp ne i64 %5, 0
  br i1 %6, label %$4, label %$5
$4:
; # (- N)
  %7 = sub i64 0, %4
  br label %$6
$5:
  br label %$6
$6:
  %8 = phi i64 [%7, %$4], [%4, %$5] ; # ->
  ret i64 %8
}

define i64 @evCnt(i64, i64) align 8 {
$1:
; # (car X)
  %2 = inttoptr i64 %1 to i64*
  %3 = load i64, i64* %2
; # (eval (car X))
  %4 = and i64 %3, 6
  %5 = icmp ne i64 %4, 0
  br i1 %5, label %$4, label %$3
$4:
  br label %$2
$3:
  %6 = and i64 %3, 8
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$6, label %$5
$6:
  %8 = inttoptr i64 %3 to i64*
  %9 = load i64, i64* %8
  br label %$2
$5:
  %10 = call i64 @evList(i64 %3)
  br label %$2
$2:
  %11 = phi i64 [%3, %$4], [%9, %$6], [%10, %$5] ; # ->
; # (xCnt Exe (eval (car X)))
  %12 = call i64 @xCnt(i64 %0, i64 %11)
  ret i64 %12
}

define i64 @evLst(i64) align 8 {
$1:
; # (let X (eval (car Exe)) (unless (or (pair X) (nil? X)) (lstErr Ex...
; # (car Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = load i64, i64* %1
; # (eval (car Exe))
  %3 = and i64 %2, 6
  %4 = icmp ne i64 %3, 0
  br i1 %4, label %$4, label %$3
$4:
  br label %$2
$3:
  %5 = and i64 %2, 8
  %6 = icmp ne i64 %5, 0
  br i1 %6, label %$6, label %$5
$6:
  %7 = inttoptr i64 %2 to i64*
  %8 = load i64, i64* %7
  br label %$2
$5:
  %9 = call i64 @evList(i64 %2)
  br label %$2
$2:
  %10 = phi i64 [%2, %$4], [%8, %$6], [%9, %$5] ; # ->
; # (unless (or (pair X) (nil? X)) (lstErr Exe X))
; # (or (pair X) (nil? X))
; # (pair X)
  %11 = and i64 %10, 15
  %12 = icmp eq i64 %11, 0
  br i1 %12, label %$7, label %$8
$8:
; # (nil? X)
  %13 = icmp eq i64 %10, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$7
$7:
  %14 = phi i1 [1, %$2], [%13, %$8] ; # ->
  br i1 %14, label %$10, label %$9
$9:
; # (lstErr Exe X)
  call void @lstErr(i64 %0, i64 %10)
  unreachable
$10:
  ret i64 %10
}

define i64 @xSym(i64) align 8 {
$1:
; # (if (symb? X) X (let P (push 4 NIL ZERO NIL) (link (ofs P 2) T) (...
; # (symb? X)
  %1 = xor i64 %0, 8
  %2 = and i64 %1, 14
  %3 = icmp eq i64 %2, 0
  br i1 %3, label %$2, label %$3
$2:
  br label %$4
$3:
; # (let P (push 4 NIL ZERO NIL) (link (ofs P 2) T) (pack X P) (consS...
; # (push 4 NIL ZERO NIL)
  %4 = alloca i64, i64 4, align 16
  store i64 4, i64* %4
  %5 = getelementptr i64, i64* %4, i32 2
  store i64 2, i64* %5
; # (ofs P 2)
  %6 = getelementptr i64, i64* %4, i32 2
; # (link (ofs P 2) T)
  %7 = ptrtoint i64* %6 to i64
  %8 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %9 = load i64, i64* %8
  %10 = inttoptr i64 %7 to i64*
  %11 = getelementptr i64, i64* %10, i32 1
  store i64 %9, i64* %11
  %12 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %7, i64* %12
; # (pack X P)
  call void @pack(i64 %0, i64* %4)
; # (val 3 P)
  %13 = getelementptr i64, i64* %4, i32 2
  %14 = load i64, i64* %13
; # (consStr (val 3 P))
  %15 = call i64 @consStr(i64 %14)
; # (drop *Safe)
  %16 = inttoptr i64 %7 to i64*
  %17 = getelementptr i64, i64* %16, i32 1
  %18 = load i64, i64* %17
  %19 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %18, i64* %19
  br label %$4
$4:
  %20 = phi i64 [%0, %$2], [%15, %$3] ; # ->
  ret i64 %20
}

define i64 @evSym(i64) align 8 {
$1:
; # (car Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = load i64, i64* %1
; # (eval (car Exe))
  %3 = and i64 %2, 6
  %4 = icmp ne i64 %3, 0
  br i1 %4, label %$4, label %$3
$4:
  br label %$2
$3:
  %5 = and i64 %2, 8
  %6 = icmp ne i64 %5, 0
  br i1 %6, label %$6, label %$5
$6:
  %7 = inttoptr i64 %2 to i64*
  %8 = load i64, i64* %7
  br label %$2
$5:
  %9 = call i64 @evList(i64 %2)
  br label %$2
$2:
  %10 = phi i64 [%2, %$4], [%8, %$6], [%9, %$5] ; # ->
; # (xSym (eval (car Exe)))
  %11 = call i64 @xSym(i64 %10)
  ret i64 %11
}

define i64 @xName(i64) align 8 {
$1:
; # (cond ((nil? Sym) ZERO) ((sym? (val (tail Sym))) (let P (push 4 N...
; # (nil? Sym)
  %1 = icmp eq i64 %0, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %1, label %$4, label %$3
$4:
  br label %$2
$3:
; # (tail Sym)
  %2 = add i64 %0, -8
; # (val (tail Sym))
  %3 = inttoptr i64 %2 to i64*
  %4 = load i64, i64* %3
; # (sym? (val (tail Sym)))
  %5 = and i64 %4, 8
  %6 = icmp ne i64 %5, 0
  br i1 %6, label %$6, label %$5
$6:
; # (let P (push 4 NIL ZERO NIL) (link (ofs P 2) T) (packExtNm (name ...
; # (push 4 NIL ZERO NIL)
  %7 = alloca i64, i64 4, align 16
  store i64 4, i64* %7
  %8 = getelementptr i64, i64* %7, i32 2
  store i64 2, i64* %8
; # (ofs P 2)
  %9 = getelementptr i64, i64* %7, i32 2
; # (link (ofs P 2) T)
  %10 = ptrtoint i64* %9 to i64
  %11 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %12 = load i64, i64* %11
  %13 = inttoptr i64 %10 to i64*
  %14 = getelementptr i64, i64* %13, i32 1
  store i64 %12, i64* %14
  %15 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %10, i64* %15
; # (& @ -9)
  %16 = and i64 %4, -9
; # (name (& @ -9))
  br label %$7
$7:
  %17 = phi i64 [%16, %$6], [%23, %$8] ; # Tail
  %18 = and i64 %17, 6
  %19 = icmp ne i64 %18, 0
  br i1 %19, label %$9, label %$8
$8:
  %20 = phi i64 [%17, %$7] ; # Tail
  %21 = inttoptr i64 %20 to i64*
  %22 = getelementptr i64, i64* %21, i32 1
  %23 = load i64, i64* %22
  br label %$7
$9:
  %24 = phi i64 [%17, %$7] ; # Tail
; # (packExtNm (name (& @ -9)) P)
  call void @packExtNm(i64 %24, i64* %7)
; # (val 3 P)
  %25 = getelementptr i64, i64* %7, i32 2
  %26 = load i64, i64* %25
; # (drop *Safe)
  %27 = inttoptr i64 %10 to i64*
  %28 = getelementptr i64, i64* %27, i32 1
  %29 = load i64, i64* %28
  %30 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %29, i64* %30
  br label %$2
$5:
; # (name @)
  br label %$10
$10:
  %31 = phi i64 [%4, %$5], [%37, %$11] ; # Tail
  %32 = and i64 %31, 6
  %33 = icmp ne i64 %32, 0
  br i1 %33, label %$12, label %$11
$11:
  %34 = phi i64 [%31, %$10] ; # Tail
  %35 = inttoptr i64 %34 to i64*
  %36 = getelementptr i64, i64* %35, i32 1
  %37 = load i64, i64* %36
  br label %$10
$12:
  %38 = phi i64 [%31, %$10] ; # Tail
  br label %$2
$2:
  %39 = phi i64 [2, %$4], [%26, %$9], [%38, %$12] ; # ->
  ret i64 %39
}

define i64 @circ(i64) align 8 {
$1:
; # (if (atom X) 0 (let Y X (loop (set Y (| (val Y) 1)) (? (atom (shi...
; # (atom X)
  %1 = and i64 %0, 15
  %2 = icmp ne i64 %1, 0
  br i1 %2, label %$2, label %$3
$2:
  %3 = phi i64 [%0, %$1] ; # X
  br label %$4
$3:
  %4 = phi i64 [%0, %$1] ; # X
; # (let Y X (loop (set Y (| (val Y) 1)) (? (atom (shift Y)) (loop (s...
; # (loop (set Y (| (val Y) 1)) (? (atom (shift Y)) (loop (set X (& (...
  br label %$5
$5:
  %5 = phi i64 [%4, %$3], [%70, %$12] ; # X
  %6 = phi i64 [%4, %$3], [%71, %$12] ; # Y
; # (set Y (| (val Y) 1))
; # (val Y)
  %7 = inttoptr i64 %6 to i64*
  %8 = load i64, i64* %7
; # (| (val Y) 1)
  %9 = or i64 %8, 1
  %10 = inttoptr i64 %6 to i64*
  store i64 %9, i64* %10
; # (? (atom (shift Y)) (loop (set X (& (val X) -2)) (? (== Y (shift ...
; # (shift Y)
  %11 = inttoptr i64 %6 to i64*
  %12 = getelementptr i64, i64* %11, i32 1
  %13 = load i64, i64* %12
; # (atom (shift Y))
  %14 = and i64 %13, 15
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$8, label %$6
$8:
  %16 = phi i64 [%5, %$5] ; # X
  %17 = phi i64 [%13, %$5] ; # Y
; # (loop (set X (& (val X) -2)) (? (== Y (shift X))))
  br label %$9
$9:
  %18 = phi i64 [%16, %$8], [%28, %$10] ; # X
  %19 = phi i64 [%17, %$8], [%29, %$10] ; # Y
; # (set X (& (val X) -2))
; # (val X)
  %20 = inttoptr i64 %18 to i64*
  %21 = load i64, i64* %20
; # (& (val X) -2)
  %22 = and i64 %21, -2
  %23 = inttoptr i64 %18 to i64*
  store i64 %22, i64* %23
; # (? (== Y (shift X)))
; # (shift X)
  %24 = inttoptr i64 %18 to i64*
  %25 = getelementptr i64, i64* %24, i32 1
  %26 = load i64, i64* %25
; # (== Y (shift X))
  %27 = icmp eq i64 %19, %26
  br i1 %27, label %$11, label %$10
$10:
  %28 = phi i64 [%26, %$9] ; # X
  %29 = phi i64 [%19, %$9] ; # Y
  br label %$9
$11:
  %30 = phi i64 [%26, %$9] ; # X
  %31 = phi i64 [%19, %$9] ; # Y
  %32 = phi i64 [0, %$9] ; # ->
  br label %$7
$6:
  %33 = phi i64 [%5, %$5] ; # X
  %34 = phi i64 [%13, %$5] ; # Y
; # (? (& (val Y) 1) (until (== X Y) (set X (& (val X) -2)) (shift X)...
; # (val Y)
  %35 = inttoptr i64 %34 to i64*
  %36 = load i64, i64* %35
; # (& (val Y) 1)
  %37 = and i64 %36, 1
  %38 = icmp ne i64 %37, 0
  br i1 %38, label %$13, label %$12
$13:
  %39 = phi i64 [%33, %$6] ; # X
  %40 = phi i64 [%34, %$6] ; # Y
; # (until (== X Y) (set X (& (val X) -2)) (shift X))
  br label %$14
$14:
  %41 = phi i64 [%39, %$13], [%52, %$15] ; # X
  %42 = phi i64 [%40, %$13], [%45, %$15] ; # Y
; # (== X Y)
  %43 = icmp eq i64 %41, %42
  br i1 %43, label %$16, label %$15
$15:
  %44 = phi i64 [%41, %$14] ; # X
  %45 = phi i64 [%42, %$14] ; # Y
; # (set X (& (val X) -2))
; # (val X)
  %46 = inttoptr i64 %44 to i64*
  %47 = load i64, i64* %46
; # (& (val X) -2)
  %48 = and i64 %47, -2
  %49 = inttoptr i64 %44 to i64*
  store i64 %48, i64* %49
; # (shift X)
  %50 = inttoptr i64 %44 to i64*
  %51 = getelementptr i64, i64* %50, i32 1
  %52 = load i64, i64* %51
  br label %$14
$16:
  %53 = phi i64 [%41, %$14] ; # X
  %54 = phi i64 [%42, %$14] ; # Y
; # (loop (set X (& (val X) -2)) (? (== Y (shift X))))
  br label %$17
$17:
  %55 = phi i64 [%53, %$16], [%65, %$18] ; # X
  %56 = phi i64 [%54, %$16], [%66, %$18] ; # Y
; # (set X (& (val X) -2))
; # (val X)
  %57 = inttoptr i64 %55 to i64*
  %58 = load i64, i64* %57
; # (& (val X) -2)
  %59 = and i64 %58, -2
  %60 = inttoptr i64 %55 to i64*
  store i64 %59, i64* %60
; # (? (== Y (shift X)))
; # (shift X)
  %61 = inttoptr i64 %55 to i64*
  %62 = getelementptr i64, i64* %61, i32 1
  %63 = load i64, i64* %62
; # (== Y (shift X))
  %64 = icmp eq i64 %56, %63
  br i1 %64, label %$19, label %$18
$18:
  %65 = phi i64 [%63, %$17] ; # X
  %66 = phi i64 [%56, %$17] ; # Y
  br label %$17
$19:
  %67 = phi i64 [%63, %$17] ; # X
  %68 = phi i64 [%56, %$17] ; # Y
  %69 = phi i64 [0, %$17] ; # ->
  br label %$7
$12:
  %70 = phi i64 [%33, %$6] ; # X
  %71 = phi i64 [%34, %$6] ; # Y
  br label %$5
$7:
  %72 = phi i64 [%30, %$11], [%67, %$19] ; # X
  %73 = phi i64 [%31, %$11], [%68, %$19] ; # Y
  %74 = phi i64 [0, %$11], [%68, %$19] ; # ->
  br label %$4
$4:
  %75 = phi i64 [%3, %$2], [%72, %$7] ; # X
  %76 = phi i64 [0, %$2], [%74, %$7] ; # ->
  ret i64 %76
}

define i64 @funq(i64) align 8 {
$1:
; # (cond ((cnt? X) X) ((or (big? X) (sym? X)) 0) ((circ X) 0) (T (le...
; # (cnt? X)
  %1 = and i64 %0, 2
  %2 = icmp ne i64 %1, 0
  br i1 %2, label %$4, label %$3
$4:
  %3 = phi i64 [%0, %$1] ; # X
  br label %$2
$3:
  %4 = phi i64 [%0, %$1] ; # X
; # (or (big? X) (sym? X))
; # (big? X)
  %5 = and i64 %4, 4
  %6 = icmp ne i64 %5, 0
  br i1 %6, label %$5, label %$6
$6:
  %7 = phi i64 [%4, %$3] ; # X
; # (sym? X)
  %8 = and i64 %7, 8
  %9 = icmp ne i64 %8, 0
  br label %$5
$5:
  %10 = phi i64 [%4, %$3], [%7, %$6] ; # X
  %11 = phi i1 [1, %$3], [%9, %$6] ; # ->
  br i1 %11, label %$8, label %$7
$8:
  %12 = phi i64 [%10, %$5] ; # X
  br label %$2
$7:
  %13 = phi i64 [%10, %$5] ; # X
; # (circ X)
  %14 = call i64 @circ(i64 %13)
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$10, label %$9
$10:
  %16 = phi i64 [%13, %$7] ; # X
  br label %$2
$9:
  %17 = phi i64 [%13, %$7] ; # X
; # (let Y (cdr X) (loop (? (atom Y) (cond ((not (nil? Y)) 0) ((nil? ...
; # (cdr X)
  %18 = inttoptr i64 %17 to i64*
  %19 = getelementptr i64, i64* %18, i32 1
  %20 = load i64, i64* %19
; # (loop (? (atom Y) (cond ((not (nil? Y)) 0) ((nil? (setq X (car X)...
  br label %$11
$11:
  %21 = phi i64 [%17, %$9], [%204, %$53] ; # X
  %22 = phi i64 [%20, %$9], [%205, %$53] ; # Y
; # (? (atom Y) (cond ((not (nil? Y)) 0) ((nil? (setq X (car X))) $T)...
; # (atom Y)
  %23 = and i64 %22, 15
  %24 = icmp ne i64 %23, 0
  br i1 %24, label %$14, label %$12
$14:
  %25 = phi i64 [%21, %$11] ; # X
  %26 = phi i64 [%22, %$11] ; # Y
; # (cond ((not (nil? Y)) 0) ((nil? (setq X (car X))) $T) ((== X $Til...
; # (nil? Y)
  %27 = icmp eq i64 %26, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
; # (not (nil? Y))
  %28 = icmp eq i1 %27, 0
  br i1 %28, label %$17, label %$16
$17:
  %29 = phi i64 [%25, %$14] ; # X
  %30 = phi i64 [%26, %$14] ; # Y
  br label %$15
$16:
  %31 = phi i64 [%25, %$14] ; # X
  %32 = phi i64 [%26, %$14] ; # Y
; # (car X)
  %33 = inttoptr i64 %31 to i64*
  %34 = load i64, i64* %33
; # (nil? (setq X (car X)))
  %35 = icmp eq i64 %34, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %35, label %$19, label %$18
$19:
  %36 = phi i64 [%34, %$16] ; # X
  %37 = phi i64 [%32, %$16] ; # Y
  br label %$15
$18:
  %38 = phi i64 [%34, %$16] ; # X
  %39 = phi i64 [%32, %$16] ; # Y
; # (== X $Tilde)
  %40 = icmp eq i64 %38, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 40) to i64)
  br i1 %40, label %$21, label %$20
$21:
  %41 = phi i64 [%38, %$18] ; # X
  %42 = phi i64 [%39, %$18] ; # Y
  br label %$15
$20:
  %43 = phi i64 [%38, %$18] ; # X
  %44 = phi i64 [%39, %$18] ; # Y
; # (circ (setq Y X))
  %45 = call i64 @circ(i64 %43)
  %46 = icmp ne i64 %45, 0
  br i1 %46, label %$23, label %$22
$23:
  %47 = phi i64 [%43, %$20] ; # X
  %48 = phi i64 [%43, %$20] ; # Y
  br label %$15
$22:
  %49 = phi i64 [%43, %$20] ; # X
  %50 = phi i64 [%43, %$20] ; # Y
; # (loop (? (atom Y) (if (or (num? Y) (t? Y)) 0 X)) (? (or (num? (++...
  br label %$24
$24:
  %51 = phi i64 [%49, %$22], [%147, %$49] ; # X
  %52 = phi i64 [%50, %$22], [%148, %$49] ; # Y
; # (? (atom Y) (if (or (num? Y) (t? Y)) 0 X))
; # (atom Y)
  %53 = and i64 %52, 15
  %54 = icmp ne i64 %53, 0
  br i1 %54, label %$27, label %$25
$27:
  %55 = phi i64 [%51, %$24] ; # X
  %56 = phi i64 [%52, %$24] ; # Y
; # (if (or (num? Y) (t? Y)) 0 X)
; # (or (num? Y) (t? Y))
; # (num? Y)
  %57 = and i64 %56, 6
  %58 = icmp ne i64 %57, 0
  br i1 %58, label %$28, label %$29
$29:
  %59 = phi i64 [%55, %$27] ; # X
  %60 = phi i64 [%56, %$27] ; # Y
; # (t? Y)
  %61 = icmp eq i64 %60, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br label %$28
$28:
  %62 = phi i64 [%55, %$27], [%59, %$29] ; # X
  %63 = phi i64 [%56, %$27], [%60, %$29] ; # Y
  %64 = phi i1 [1, %$27], [%61, %$29] ; # ->
  br i1 %64, label %$30, label %$31
$30:
  %65 = phi i64 [%62, %$28] ; # X
  %66 = phi i64 [%63, %$28] ; # Y
  br label %$32
$31:
  %67 = phi i64 [%62, %$28] ; # X
  %68 = phi i64 [%63, %$28] ; # Y
  br label %$32
$32:
  %69 = phi i64 [%65, %$30], [%67, %$31] ; # X
  %70 = phi i64 [%66, %$30], [%68, %$31] ; # Y
  %71 = phi i64 [0, %$30], [%67, %$31] ; # ->
  br label %$26
$25:
  %72 = phi i64 [%51, %$24] ; # X
  %73 = phi i64 [%52, %$24] ; # Y
; # (? (or (num? (++ Y)) (nil? @) (t? @) (and (pair @) (let Z @ (loop...
; # (or (num? (++ Y)) (nil? @) (t? @) (and (pair @) (let Z @ (loop (?...
; # (++ Y)
  %74 = inttoptr i64 %73 to i64*
  %75 = load i64, i64* %74
  %76 = getelementptr i64, i64* %74, i32 1
  %77 = load i64, i64* %76
; # (num? (++ Y))
  %78 = and i64 %75, 6
  %79 = icmp ne i64 %78, 0
  br i1 %79, label %$33, label %$34
$34:
  %80 = phi i64 [%72, %$25] ; # X
  %81 = phi i64 [%77, %$25] ; # Y
; # (nil? @)
  %82 = icmp eq i64 %75, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %82, label %$33, label %$35
$35:
  %83 = phi i64 [%80, %$34] ; # X
  %84 = phi i64 [%81, %$34] ; # Y
; # (t? @)
  %85 = icmp eq i64 %75, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %85, label %$33, label %$36
$36:
  %86 = phi i64 [%83, %$35] ; # X
  %87 = phi i64 [%84, %$35] ; # Y
; # (and (pair @) (let Z @ (loop (? (or (not (symb? (++ Z))) (t? @)) ...
; # (pair @)
  %88 = and i64 %75, 15
  %89 = icmp eq i64 %88, 0
  br i1 %89, label %$38, label %$37
$38:
  %90 = phi i64 [%86, %$36] ; # X
  %91 = phi i64 [%87, %$36] ; # Y
; # (let Z @ (loop (? (or (not (symb? (++ Z))) (t? @)) YES) (? (atom ...
; # (loop (? (or (not (symb? (++ Z))) (t? @)) YES) (? (atom Z) (or (n...
  br label %$39
$39:
  %92 = phi i64 [%90, %$38], [%132, %$45] ; # X
  %93 = phi i64 [%91, %$38], [%133, %$45] ; # Y
  %94 = phi i64 [%75, %$38], [%134, %$45] ; # Z
; # (? (or (not (symb? (++ Z))) (t? @)) YES)
; # (or (not (symb? (++ Z))) (t? @))
; # (++ Z)
  %95 = inttoptr i64 %94 to i64*
  %96 = load i64, i64* %95
  %97 = getelementptr i64, i64* %95, i32 1
  %98 = load i64, i64* %97
; # (symb? (++ Z))
  %99 = xor i64 %96, 8
  %100 = and i64 %99, 14
  %101 = icmp eq i64 %100, 0
; # (not (symb? (++ Z)))
  %102 = icmp eq i1 %101, 0
  br i1 %102, label %$40, label %$41
$41:
  %103 = phi i64 [%92, %$39] ; # X
  %104 = phi i64 [%93, %$39] ; # Y
  %105 = phi i64 [%98, %$39] ; # Z
; # (t? @)
  %106 = icmp eq i64 %96, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br label %$40
$40:
  %107 = phi i64 [%92, %$39], [%103, %$41] ; # X
  %108 = phi i64 [%93, %$39], [%104, %$41] ; # Y
  %109 = phi i64 [%98, %$39], [%105, %$41] ; # Z
  %110 = phi i1 [1, %$39], [%106, %$41] ; # ->
  br i1 %110, label %$44, label %$42
$44:
  %111 = phi i64 [%107, %$40] ; # X
  %112 = phi i64 [%108, %$40] ; # Y
  %113 = phi i64 [%109, %$40] ; # Z
  br label %$43
$42:
  %114 = phi i64 [%107, %$40] ; # X
  %115 = phi i64 [%108, %$40] ; # Y
  %116 = phi i64 [%109, %$40] ; # Z
; # (? (atom Z) (or (num? Z) (t? Z)))
; # (atom Z)
  %117 = and i64 %116, 15
  %118 = icmp ne i64 %117, 0
  br i1 %118, label %$46, label %$45
$46:
  %119 = phi i64 [%114, %$42] ; # X
  %120 = phi i64 [%115, %$42] ; # Y
  %121 = phi i64 [%116, %$42] ; # Z
; # (or (num? Z) (t? Z))
; # (num? Z)
  %122 = and i64 %121, 6
  %123 = icmp ne i64 %122, 0
  br i1 %123, label %$47, label %$48
$48:
  %124 = phi i64 [%119, %$46] ; # X
  %125 = phi i64 [%120, %$46] ; # Y
  %126 = phi i64 [%121, %$46] ; # Z
; # (t? Z)
  %127 = icmp eq i64 %126, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br label %$47
$47:
  %128 = phi i64 [%119, %$46], [%124, %$48] ; # X
  %129 = phi i64 [%120, %$46], [%125, %$48] ; # Y
  %130 = phi i64 [%121, %$46], [%126, %$48] ; # Z
  %131 = phi i1 [1, %$46], [%127, %$48] ; # ->
  br label %$43
$45:
  %132 = phi i64 [%114, %$42] ; # X
  %133 = phi i64 [%115, %$42] ; # Y
  %134 = phi i64 [%116, %$42] ; # Z
  br label %$39
$43:
  %135 = phi i64 [%111, %$44], [%128, %$47] ; # X
  %136 = phi i64 [%112, %$44], [%129, %$47] ; # Y
  %137 = phi i64 [%113, %$44], [%130, %$47] ; # Z
  %138 = phi i1 [1, %$44], [%131, %$47] ; # ->
  br label %$37
$37:
  %139 = phi i64 [%86, %$36], [%135, %$43] ; # X
  %140 = phi i64 [%87, %$36], [%136, %$43] ; # Y
  %141 = phi i1 [0, %$36], [%138, %$43] ; # ->
  br label %$33
$33:
  %142 = phi i64 [%72, %$25], [%80, %$34], [%83, %$35], [%139, %$37] ; # X
  %143 = phi i64 [%77, %$25], [%81, %$34], [%84, %$35], [%140, %$37] ; # Y
  %144 = phi i1 [1, %$25], [1, %$34], [1, %$35], [%141, %$37] ; # ->
  br i1 %144, label %$50, label %$49
$50:
  %145 = phi i64 [%142, %$33] ; # X
  %146 = phi i64 [%143, %$33] ; # Y
  br label %$26
$49:
  %147 = phi i64 [%142, %$33] ; # X
  %148 = phi i64 [%143, %$33] ; # Y
  br label %$24
$26:
  %149 = phi i64 [%69, %$32], [%145, %$50] ; # X
  %150 = phi i64 [%70, %$32], [%146, %$50] ; # Y
  %151 = phi i64 [%71, %$32], [0, %$50] ; # ->
  br label %$15
$15:
  %152 = phi i64 [%29, %$17], [%36, %$19], [%41, %$21], [%47, %$23], [%149, %$26] ; # X
  %153 = phi i64 [%30, %$17], [%37, %$19], [%42, %$21], [%48, %$23], [%150, %$26] ; # Y
  %154 = phi i64 [0, %$17], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$19], [0, %$21], [0, %$23], [%151, %$26] ; # ->
  br label %$13
$12:
  %155 = phi i64 [%21, %$11] ; # X
  %156 = phi i64 [%22, %$11] ; # Y
; # (let Z (++ Y) (if (pair Z) (if (num? (car Z)) (? (pair Y) 0) (? (...
; # (++ Y)
  %157 = inttoptr i64 %156 to i64*
  %158 = load i64, i64* %157
  %159 = getelementptr i64, i64* %157, i32 1
  %160 = load i64, i64* %159
; # (if (pair Z) (if (num? (car Z)) (? (pair Y) 0) (? (or (nil? (car ...
; # (pair Z)
  %161 = and i64 %158, 15
  %162 = icmp eq i64 %161, 0
  br i1 %162, label %$51, label %$52
$51:
  %163 = phi i64 [%155, %$12] ; # X
  %164 = phi i64 [%160, %$12] ; # Y
; # (if (num? (car Z)) (? (pair Y) 0) (? (or (nil? (car Z)) (t? (car ...
; # (car Z)
  %165 = inttoptr i64 %158 to i64*
  %166 = load i64, i64* %165
; # (num? (car Z))
  %167 = and i64 %166, 6
  %168 = icmp ne i64 %167, 0
  br i1 %168, label %$54, label %$55
$54:
  %169 = phi i64 [%163, %$51] ; # X
  %170 = phi i64 [%164, %$51] ; # Y
; # (? (pair Y) 0)
; # (pair Y)
  %171 = and i64 %170, 15
  %172 = icmp eq i64 %171, 0
  br i1 %172, label %$58, label %$57
$58:
  %173 = phi i64 [%169, %$54] ; # X
  %174 = phi i64 [%170, %$54] ; # Y
  br label %$13
$57:
  %175 = phi i64 [%169, %$54] ; # X
  %176 = phi i64 [%170, %$54] ; # Y
  br label %$56
$55:
  %177 = phi i64 [%163, %$51] ; # X
  %178 = phi i64 [%164, %$51] ; # Y
; # (? (or (nil? (car Z)) (t? (car Z))) 0)
; # (or (nil? (car Z)) (t? (car Z)))
; # (car Z)
  %179 = inttoptr i64 %158 to i64*
  %180 = load i64, i64* %179
; # (nil? (car Z))
  %181 = icmp eq i64 %180, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %181, label %$59, label %$60
$60:
  %182 = phi i64 [%177, %$55] ; # X
  %183 = phi i64 [%178, %$55] ; # Y
; # (car Z)
  %184 = inttoptr i64 %158 to i64*
  %185 = load i64, i64* %184
; # (t? (car Z))
  %186 = icmp eq i64 %185, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br label %$59
$59:
  %187 = phi i64 [%177, %$55], [%182, %$60] ; # X
  %188 = phi i64 [%178, %$55], [%183, %$60] ; # Y
  %189 = phi i1 [1, %$55], [%186, %$60] ; # ->
  br i1 %189, label %$62, label %$61
$62:
  %190 = phi i64 [%187, %$59] ; # X
  %191 = phi i64 [%188, %$59] ; # Y
  br label %$13
$61:
  %192 = phi i64 [%187, %$59] ; # X
  %193 = phi i64 [%188, %$59] ; # Y
  br label %$56
$56:
  %194 = phi i64 [%175, %$57], [%192, %$61] ; # X
  %195 = phi i64 [%176, %$57], [%193, %$61] ; # Y
  br label %$53
$52:
  %196 = phi i64 [%155, %$12] ; # X
  %197 = phi i64 [%160, %$12] ; # Y
; # (? (not (nil? Y)) 0)
; # (nil? Y)
  %198 = icmp eq i64 %197, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
; # (not (nil? Y))
  %199 = icmp eq i1 %198, 0
  br i1 %199, label %$64, label %$63
$64:
  %200 = phi i64 [%196, %$52] ; # X
  %201 = phi i64 [%197, %$52] ; # Y
  br label %$13
$63:
  %202 = phi i64 [%196, %$52] ; # X
  %203 = phi i64 [%197, %$52] ; # Y
  br label %$53
$53:
  %204 = phi i64 [%194, %$56], [%202, %$63] ; # X
  %205 = phi i64 [%195, %$56], [%203, %$63] ; # Y
  br label %$11
$13:
  %206 = phi i64 [%152, %$15], [%173, %$58], [%190, %$62], [%200, %$64] ; # X
  %207 = phi i64 [%153, %$15], [%174, %$58], [%191, %$62], [%201, %$64] ; # Y
  %208 = phi i64 [%154, %$15], [0, %$58], [0, %$62], [0, %$64] ; # ->
  br label %$2
$2:
  %209 = phi i64 [%3, %$4], [%12, %$8], [%16, %$10], [%206, %$13] ; # X
  %210 = phi i64 [%3, %$4], [0, %$8], [0, %$10], [%208, %$13] ; # ->
  ret i64 %210
}

define i64 @_Tty(i64) align 8 {
$1:
; # (b8+ (ioFrame T))
  %1 = alloca i8, i64 28, align 8
; # (val $OutFiles)
  %2 = load i8**, i8*** @$OutFiles
; # (val 3 (val $OutFiles))
  %3 = getelementptr i8*, i8** %2, i32 2
  %4 = load i8*, i8** %3
; # (pushOutFile (b8+ (ioFrame T)) (val 3 (val $OutFiles)) 0)
  call void @pushOutFile(i8* %1, i8* %4, i32 0)
; # (prog2 (rlHide) (run (cdr Exe)) (rlShow) (popOutFiles))
; # (rlHide)
  call void @rlHide()
; # (cdr Exe)
  %5 = inttoptr i64 %0 to i64*
  %6 = getelementptr i64, i64* %5, i32 1
  %7 = load i64, i64* %6
; # (run (cdr Exe))
  br label %$2
$2:
  %8 = phi i64 [%7, %$1], [%30, %$11] ; # Prg
  %9 = inttoptr i64 %8 to i64*
  %10 = load i64, i64* %9
  %11 = getelementptr i64, i64* %9, i32 1
  %12 = load i64, i64* %11
  %13 = and i64 %12, 15
  %14 = icmp ne i64 %13, 0
  br i1 %14, label %$5, label %$3
$5:
  %15 = phi i64 [%12, %$2] ; # Prg
  %16 = and i64 %10, 6
  %17 = icmp ne i64 %16, 0
  br i1 %17, label %$8, label %$7
$8:
  br label %$6
$7:
  %18 = and i64 %10, 8
  %19 = icmp ne i64 %18, 0
  br i1 %19, label %$10, label %$9
$10:
  %20 = inttoptr i64 %10 to i64*
  %21 = load i64, i64* %20
  br label %$6
$9:
  %22 = call i64 @evList(i64 %10)
  br label %$6
$6:
  %23 = phi i64 [%10, %$8], [%21, %$10], [%22, %$9] ; # ->
  br label %$4
$3:
  %24 = phi i64 [%12, %$2] ; # Prg
  %25 = and i64 %10, 15
  %26 = icmp eq i64 %25, 0
  br i1 %26, label %$12, label %$11
$12:
  %27 = phi i64 [%24, %$3] ; # Prg
  %28 = call i64 @evList(i64 %10)
  %29 = icmp ne i64 %28, 0
  br label %$11
$11:
  %30 = phi i64 [%24, %$3], [%27, %$12] ; # Prg
  %31 = phi i1 [0, %$3], [%29, %$12] ; # ->
  br label %$2
$4:
  %32 = phi i64 [%15, %$6] ; # Prg
  %33 = phi i64 [%23, %$6] ; # ->
; # (rlShow)
  call void @rlShow()
; # (popOutFiles)
  call void @popOutFiles()
  ret i64 %33
}

define i64 @_Prompt(i64) align 8 {
$1:
; # (let (X (cdr Exe) Nm (xName (evSym X))) (prog2 (set $LinePrmt (se...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (evSym X)
  %4 = call i64 @evSym(i64 %3)
; # (xName (evSym X))
  %5 = call i64 @xName(i64 %4)
; # (prog2 (set $LinePrmt (set $ContPrmt (bufString Nm (b8 (bufSize N...
; # (set $LinePrmt (set $ContPrmt (bufString Nm (b8 (bufSize Nm)))))
; # (set $ContPrmt (bufString Nm (b8 (bufSize Nm))))
; # (bufSize Nm)
  %6 = call i64 @bufSize(i64 %5)
; # (b8 (bufSize Nm))
  %7 = alloca i8, i64 %6
; # (bufString Nm (b8 (bufSize Nm)))
  %8 = call i8* @bufString(i64 %5, i8* %7)
  store i8* %8, i8** @$ContPrmt
  store i8* %8, i8** @$LinePrmt
; # (cdr X)
  %9 = inttoptr i64 %3 to i64*
  %10 = getelementptr i64, i64* %9, i32 1
  %11 = load i64, i64* %10
; # (run (cdr X))
  br label %$2
$2:
  %12 = phi i64 [%11, %$1], [%34, %$11] ; # Prg
  %13 = inttoptr i64 %12 to i64*
  %14 = load i64, i64* %13
  %15 = getelementptr i64, i64* %13, i32 1
  %16 = load i64, i64* %15
  %17 = and i64 %16, 15
  %18 = icmp ne i64 %17, 0
  br i1 %18, label %$5, label %$3
$5:
  %19 = phi i64 [%16, %$2] ; # Prg
  %20 = and i64 %14, 6
  %21 = icmp ne i64 %20, 0
  br i1 %21, label %$8, label %$7
$8:
  br label %$6
$7:
  %22 = and i64 %14, 8
  %23 = icmp ne i64 %22, 0
  br i1 %23, label %$10, label %$9
$10:
  %24 = inttoptr i64 %14 to i64*
  %25 = load i64, i64* %24
  br label %$6
$9:
  %26 = call i64 @evList(i64 %14)
  br label %$6
$6:
  %27 = phi i64 [%14, %$8], [%25, %$10], [%26, %$9] ; # ->
  br label %$4
$3:
  %28 = phi i64 [%16, %$2] ; # Prg
  %29 = and i64 %14, 15
  %30 = icmp eq i64 %29, 0
  br i1 %30, label %$12, label %$11
$12:
  %31 = phi i64 [%28, %$3] ; # Prg
  %32 = call i64 @evList(i64 %14)
  %33 = icmp ne i64 %32, 0
  br label %$11
$11:
  %34 = phi i64 [%28, %$3], [%31, %$12] ; # Prg
  %35 = phi i1 [0, %$3], [%33, %$12] ; # ->
  br label %$2
$4:
  %36 = phi i64 [%19, %$6] ; # Prg
  %37 = phi i64 [%27, %$6] ; # ->
; # (set $LinePrmt (set $ContPrmt null))
; # (set $ContPrmt null)
  store i8* null, i8** @$ContPrmt
  store i8* null, i8** @$LinePrmt
  ret i64 %37
}

define i64 @_Raw(i64) align 8 {
$1:
; # (let X (cdr Exe) (cond ((atom X) (if (val Termio) $T $Nil)) ((nil...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (cond ((atom X) (if (val Termio) $T $Nil)) ((nil? (eval (car X)))...
; # (atom X)
  %4 = and i64 %3, 15
  %5 = icmp ne i64 %4, 0
  br i1 %5, label %$4, label %$3
$4:
; # (if (val Termio) $T $Nil)
; # (val Termio)
  %6 = load i8*, i8** @Termio
  %7 = icmp ne i8* %6, null
  br i1 %7, label %$5, label %$6
$5:
  br label %$7
$6:
  br label %$7
$7:
  %8 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$5], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$6] ; # ->
  br label %$2
$3:
; # (car X)
  %9 = inttoptr i64 %3 to i64*
  %10 = load i64, i64* %9
; # (eval (car X))
  %11 = and i64 %10, 6
  %12 = icmp ne i64 %11, 0
  br i1 %12, label %$10, label %$9
$10:
  br label %$8
$9:
  %13 = and i64 %10, 8
  %14 = icmp ne i64 %13, 0
  br i1 %14, label %$12, label %$11
$12:
  %15 = inttoptr i64 %10 to i64*
  %16 = load i64, i64* %15
  br label %$8
$11:
  %17 = call i64 @evList(i64 %10)
  br label %$8
$8:
  %18 = phi i64 [%10, %$10], [%16, %$12], [%17, %$11] ; # ->
; # (nil? (eval (car X)))
  %19 = icmp eq i64 %18, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %19, label %$14, label %$13
$14:
; # (setCooked)
  call void @setCooked()
  br label %$2
$13:
; # (setRaw)
  call void @setRaw()
  br label %$2
$2:
  %20 = phi i64 [%8, %$7], [%18, %$14], [%18, %$13] ; # ->
  ret i64 %20
}

define i64 @_Alarm(i64) align 8 {
$1:
; # (let X (cdr Exe) (prog1 (cnt (i64 (alarm (i32 (evCnt Exe X))))) (...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (prog1 (cnt (i64 (alarm (i32 (evCnt Exe X))))) (set $Alarm (cdr X...
; # (evCnt Exe X)
  %4 = call i64 @evCnt(i64 %0, i64 %3)
; # (i32 (evCnt Exe X))
  %5 = trunc i64 %4 to i32
; # (alarm (i32 (evCnt Exe X)))
  %6 = call i32 @alarm(i32 %5)
; # (i64 (alarm (i32 (evCnt Exe X))))
  %7 = sext i32 %6 to i64
; # (cnt (i64 (alarm (i32 (evCnt Exe X)))))
  %8 = shl i64 %7, 4
  %9 = or i64 %8, 2
; # (set $Alarm (cdr X))
; # (cdr X)
  %10 = inttoptr i64 %3 to i64*
  %11 = getelementptr i64, i64* %10, i32 1
  %12 = load i64, i64* %11
  %13 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 24) to i64) to i64*
  store i64 %12, i64* %13
  ret i64 %9
}

define i64 @_Sigio(i64) align 8 {
$1:
; # (let (X (cdr Exe) Fd (evCnt Exe X)) (set $Sigio (cdr X)) (fcntlSe...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (evCnt Exe X)
  %4 = call i64 @evCnt(i64 %0, i64 %3)
; # (set $Sigio (cdr X))
; # (cdr X)
  %5 = inttoptr i64 %3 to i64*
  %6 = getelementptr i64, i64* %5, i32 1
  %7 = load i64, i64* %6
  %8 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 32) to i64) to i64*
  store i64 %7, i64* %8
; # (i32 Fd)
  %9 = trunc i64 %4 to i32
; # (val $Pid)
  %10 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 200) to i64) to i64*
  %11 = load i64, i64* %10
; # (int (val $Pid))
  %12 = lshr i64 %11, 4
; # (i32 (int (val $Pid)))
  %13 = trunc i64 %12 to i32
; # (fcntlSetOwn (i32 Fd) (i32 (int (val $Pid))))
  call void @fcntlSetOwn(i32 %9, i32 %13)
; # (cnt Fd)
  %14 = shl i64 %4, 4
  %15 = or i64 %14, 2
  ret i64 %15
}

define i64 @_Kids(i64) align 8 {
$1:
; # (let (X $Nil Cld (val $Child) 
  br label %$4
$3:
  %22 = phi i64 [%10, %$2] ; # Prg
  %23 = and i64 %8, 15
  %24 = icmp eq i64 %23, 0
  br i1 %24, label %$12, label %$11
$12:
  %25 = phi i64 [%22, %$3] ; # Prg
  %26 = call i64 @evList(i64 %8)
  %27 = icmp ne i64 %26, 0
  br label %$11
$11:
  %28 = phi i64 [%22, %$3], [%25, %$12] ; # Prg
  %29 = phi i1 [0, %$3], [%27, %$12] ; # ->
  br label %$2
$4:
  %30 = phi i64 [%13, %$6] ; # Prg
  %31 = phi i64 [%21, %$6] ; # ->
; # (set $Protect (- (val $Protect) 1))
; # (val $Protect)
  %32 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 176) to i32*)
; # (- (val $Protect) 1)
  %33 = sub i32 %32, 1
  store i32 %33, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 176) to i32*)
  ret i64 %31
}

define i64 @_Heap(i64) align 8 {
$1:
; # (if (nil? (eval (cadr Exe))) (let (N 1 P (val $Heaps)) (while (se...
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (nil? (eval (cadr Exe)))
  %14 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %14, label %$7, label %$8
$7:
; # (let (N 1 P (val $Heaps)) (while (setq P (val (ofs P HEAP))) (inc...
; # (val $Heaps)
  %15 = load i64, i64* @$Heaps
; # (while (setq P (val (ofs P HEAP))) (inc 'N))
  br label %$10
$10:
  %16 = phi i64 [1, %$7], [%24, %$11] ; # N
  %17 = phi i64 [%15, %$7], [%23, %$11] ; # P
; # (ofs P HEAP)
  %18 = add i64 %17, 1048576
; # (val (ofs P HEAP))
  %19 = inttoptr i64 %18 to i64*
  %20 = load i64, i64* %19
  %21 = icmp ne i64 %20, 0
  br i1 %21, label %$11, label %$12
$11:
  %22 = phi i64 [%16, %$10] ; # N
  %23 = phi i64 [%20, %$10] ; # P
; # (inc 'N)
  %24 = add i64 %22, 1
  br label %$10
$12:
  %25 = phi i64 [%16, %$10] ; # N
  %26 = phi i64 [%20, %$10] ; # P
; # (cnt N)
  %27 = shl i64 %25, 4
  %28 = or i64 %27, 2
  br label %$9
$8:
; # (let (N 0 P (val $Avail)) (while P (inc 'N) (setq P (car P))) (cn...
; # (val $Avail)
  %29 = load i64, i64* @$Avail
; # (while P (inc 'N) (setq P (car P)))
  br label %$13
$13:
  %30 = phi i64 [0, %$8], [%35, %$14] ; # N
  %31 = phi i64 [%29, %$8], [%37, %$14] ; # P
  %32 = icmp ne i64 %31, 0
  br i1 %32, label %$14, label %$15
$14:
  %33 = phi i64 [%30, %$13] ; # N
  %34 = phi i64 [%31, %$13] ; # P
; # (inc 'N)
  %35 = add i64 %33, 1
; # (car P)
  %36 = inttoptr i64 %34 to i64*
  %37 = load i64, i64* %36
  br label %$13
$15:
  %38 = phi i64 [%30, %$13] ; # N
  %39 = phi i64 [%31, %$13] ; # P
; # (- 20 4)
; # (shr N (- 20 4))
  %40 = lshr i64 %38, 16
; # (cnt (shr N (- 20 4)))
  %41 = shl i64 %40, 4
  %42 = or i64 %41, 2
  br label %$9
$9:
  %43 = phi i64 [%28, %$12], [%42, %$15] ; # ->
  ret i64 %43
}

define i64 @_Stack(i64) align 8 {
$1:
; # (let (X (cdr Exe) Crt (val $Coroutines)) (if (or (atom X) (and Cr...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (val $Coroutines)
  %4 = load i8*, i8** @$Coroutines
; # (if (or (atom X) (and Crt ((coroutine Crt) nxt))) (let R (cnt (sh...
; # (or (atom X) (and Crt ((coroutine Crt) nxt)))
; # (atom X)
  %5 = and i64 %3, 15
  %6 = icmp ne i64 %5, 0
  br i1 %6, label %$2, label %$3
$3:
  %7 = phi i64 [%3, %$1] ; # X
  %8 = phi i8* [%4, %$1] ; # Crt
; # (and Crt ((coroutine Crt) nxt))
  %9 = icmp ne i8* %8, null
  br i1 %9, label %$5, label %$4
$5:
  %10 = phi i64 [%7, %$3] ; # X
  %11 = phi i8* [%8, %$3] ; # Crt
; # ((coroutine Crt) nxt)
  %12 = getelementptr i8, i8* %11, i32 8
  %13 = bitcast i8* %12 to i8**
  %14 = load i8*, i8** %13
  %15 = icmp ne i8* %14, null
  br label %$4
$4:
  %16 = phi i64 [%7, %$3], [%10, %$5] ; # X
  %17 = phi i8* [%8, %$3], [%11, %$5] ; # Crt
  %18 = phi i1 [0, %$3], [%15, %$5] ; # ->
  br label %$2
$2:
  %19 = phi i64 [%3, %$1], [%16, %$4] ; # X
  %20 = phi i8* [%4, %$1], [%17, %$4] ; # Crt
  %21 = phi i1 [1, %$1], [%18, %$4] ; # ->
  br i1 %21, label %$6, label %$7
$6:
  %22 = phi i64 [%19, %$2] ; # X
  %23 = phi i8* [%20, %$2] ; # Crt
; # (let R (cnt (shr (val $StkSize) 10)) (while Crt (let Crt: (corout...
; # (val $StkSize)
  %24 = load i64, i64* @$StkSize
; # (shr (val $StkSize) 10)
  %25 = lshr i64 %24, 10
; # (cnt (shr (val $StkSize) 10))
  %26 = shl i64 %25, 4
  %27 = or i64 %26, 2
; # (while Crt (let Crt: (coroutine Crt) (when (Crt: tag) (let P (Crt...
  br label %$9
$9:
  %28 = phi i64 [%22, %$6], [%73, %$13] ; # X
  %29 = phi i8* [%23, %$6], [%78, %$13] ; # Crt
  %30 = phi i64 [%27, %$6], [%75, %$13] ; # R
  %31 = icmp ne i8* %29, null
  br i1 %31, label %$10, label %$11
$10:
  %32 = phi i64 [%28, %$9] ; # X
  %33 = phi i8* [%29, %$9] ; # Crt
  %34 = phi i64 [%30, %$9] ; # R
; # (let Crt: (coroutine Crt) (when (Crt: tag) (let P (Crt: lim) (whi...
; # (when (Crt: tag) (let P (Crt: lim) (while (== 7 (val P)) (inc 'P)...
; # (Crt: tag)
  %35 = ptrtoint i8* %33 to i64
  %36 = inttoptr i64 %35 to i64*
  %37 = load i64, i64* %36
  %38 = icmp ne i64 %37, 0
  br i1 %38, label %$12, label %$13
$12:
  %39 = phi i64 [%32, %$10] ; # X
  %40 = phi i8* [%33, %$10] ; # Crt
  %41 = phi i64 [%34, %$10] ; # R
; # (let P (Crt: lim) (while (== 7 (val P)) (inc 'P)) (setq R (cons2 ...
; # (Crt: lim)
  %42 = getelementptr i8, i8* %33, i32 40
  %43 = bitcast i8* %42 to i8**
  %44 = load i8*, i8** %43
; # (while (== 7 (val P)) (inc 'P))
  br label %$14
$14:
  %45 = phi i64 [%39, %$12], [%51, %$15] ; # X
  %46 = phi i8* [%40, %$12], [%52, %$15] ; # Crt
  %47 = phi i64 [%41, %$12], [%53, %$15] ; # R
  %48 = phi i8* [%44, %$12], [%55, %$15] ; # P
; # (val P)
  %49 = load i8, i8* %48
; # (== 7 (val P))
  %50 = icmp eq i8 7, %49
  br i1 %50, label %$15, label %$16
$15:
  %51 = phi i64 [%45, %$14] ; # X
  %52 = phi i8* [%46, %$14] ; # Crt
  %53 = phi i64 [%47, %$14] ; # R
  %54 = phi i8* [%48, %$14] ; # P
; # (inc 'P)
  %55 = getelementptr i8, i8* %54, i32 1
  br label %$14
$16:
  %56 = phi i64 [%45, %$14] ; # X
  %57 = phi i8* [%46, %$14] ; # Crt
  %58 = phi i64 [%47, %$14] ; # R
  %59 = phi i8* [%48, %$14] ; # P
; # (Crt: tag)
  %60 = ptrtoint i8* %33 to i64
  %61 = inttoptr i64 %60 to i64*
  %62 = load i64, i64* %61
; # (Crt: lim)
  %63 = getelementptr i8, i8* %33, i32 40
  %64 = bitcast i8* %63 to i8**
  %65 = load i8*, i8** %64
; # (- P (Crt: lim))
  %66 = ptrtoint i8* %59 to i64
  %67 = ptrtoint i8* %65 to i64
  %68 = sub i64 %66, %67
; # (shr (- P (Crt: lim)) 10)
  %69 = lshr i64 %68, 10
; # (cnt (shr (- P (Crt: lim)) 10))
  %70 = shl i64 %69, 4
  %71 = or i64 %70, 2
; # (cons2 (Crt: tag) (cnt (shr (- P (Crt: lim)) 10)) R)
  %72 = call i64 @cons2(i64 %62, i64 %71, i64 %58)
  br label %$13
$13:
  %73 = phi i64 [%32, %$10], [%56, %$16] ; # X
  %74 = phi i8* [%33, %$10], [%57, %$16] ; # Crt
  %75 = phi i64 [%34, %$10], [%72, %$16] ; # R
; # (Crt: nxt)
  %76 = getelementptr i8, i8* %33, i32 8
  %77 = bitcast i8* %76 to i8**
  %78 = load i8*, i8** %77
  br label %$9
$11:
  %79 = phi i64 [%28, %$9] ; # X
  %80 = phi i8* [%29, %$9] ; # Crt
  %81 = phi i64 [%30, %$9] ; # R
  br label %$8
$7:
  %82 = phi i64 [%19, %$2] ; # X
  %83 = phi i8* [%20, %$2] ; # Crt
; # (let N (evCnt Exe X) (set $StkSize (shl N 10)) (when (pair (shift...
; # (evCnt Exe X)
  %84 = call i64 @evCnt(i64 %0, i64 %82)
; # (set $StkSize (shl N 10))
; # (shl N 10)
  %85 = shl i64 %84, 10
  store i64 %85, i64* @$StkSize
; # (when (pair (shift X)) (set $StkSizeT (shl (evCnt Exe X) 10)))
; # (shift X)
  %86 = inttoptr i64 %82 to i64*
  %87 = getelementptr i64, i64* %86, i32 1
  %88 = load i64, i64* %87
; # (pair (shift X))
  %89 = and i64 %88, 15
  %90 = icmp eq i64 %89, 0
  br i1 %90, label %$17, label %$18
$17:
  %91 = phi i64 [%88, %$7] ; # X
  %92 = phi i8* [%83, %$7] ; # Crt
; # (set $StkSizeT (shl (evCnt Exe X) 10))
; # (evCnt Exe X)
  %93 = call i64 @evCnt(i64 %0, i64 %91)
; # (shl (evCnt Exe X) 10)
  %94 = shl i64 %93, 10
  store i64 %94, i64* @$StkSizeT
  br label %$18
$18:
  %95 = phi i64 [%88, %$7], [%91, %$17] ; # X
  %96 = phi i8* [%83, %$7], [%92, %$17] ; # Crt
; # (when Crt (let (Siz (val $StkSizeT) Stk (stack)) (memset ((corout...
  %97 = icmp ne i8* %96, null
  br i1 %97, label %$19, label %$20
$19:
  %98 = phi i64 [%95, %$18] ; # X
  %99 = phi i8* [%96, %$18] ; # Crt
; # (let (Siz (val $StkSizeT) Stk (stack)) (memset ((coroutine Crt) l...
; # (val $StkSizeT)
  %100 = load i64, i64* @$StkSizeT
; # (stack)
  %101 = call i8* @llvm.stacksave()
; # ((coroutine Crt) lim (stack (ofs Stk (- Siz))))
  %102 = getelementptr i8, i8* %99, i32 40
  %103 = bitcast i8* %102 to i8**
  %104 = sub i64 0, %100
  %105 = getelementptr i8, i8* %101, i64 %104
  call void @llvm.stackrestore(i8* %105)
  store i8* %105, i8** %103
; # (- Siz 256)
  %106 = sub i64 %100, 256
; # (memset ((coroutine Crt) lim (stack (ofs Stk (- Siz)))) 7 (- Siz ...
  call void @llvm.memset.p0i8.i64(i8* align 8 %105, i8 7, i64 %106, i1 0)
; # (stack Stk)
  call void @llvm.stackrestore(i8* %101)
  br label %$20
$20:
  %107 = phi i64 [%95, %$18], [%98, %$19] ; # X
  %108 = phi i8* [%96, %$18], [%99, %$19] ; # Crt
; # (cnt N)
  %109 = shl i64 %84, 4
  %110 = or i64 %109, 2
  br label %$8
$8:
  %111 = phi i64 [%79, %$11], [%107, %$20] ; # X
  %112 = phi i8* [%80, %$11], [%108, %$20] ; # Crt
  %113 = phi i64 [%81, %$11], [%110, %$20] ; # ->
  ret i64 %113
}

define i64 @tmDate(i64, i64, i64) align 8 {
$1:
; # (if (and (gt0 Y) (gt0 M) (>= 12 M) (gt0 D) (or (>= (i64 (val (ofs...
; # (and (gt0 Y) (gt0 M) (>= 12 M) (gt0 D) (or (>= (i64 (val (ofs $Mo...
; # (gt0 Y)
  %3 = icmp sgt i64 %0, 0
  br i1 %3, label %$3, label %$2
$3:
; # (gt0 M)
  %4 = icmp sgt i64 %1, 0
  br i1 %4, label %$4, label %$2
$4:
; # (>= 12 M)
  %5 = icmp uge i64 12, %1
  br i1 %5, label %$5, label %$2
$5:
; # (gt0 D)
  %6 = icmp sgt i64 %2, 0
  br i1 %6, label %$6, label %$2
$6:
; # (or (>= (i64 (val (ofs $Month M))) D) (and (== D 29) (== M 2) (=0...
; # (ofs $Month M)
  %7 = getelementptr i8, i8* bitcast ([13 x i8]* @$Month to i8*), i64 %1
; # (val (ofs $Month M))
  %8 = load i8, i8* %7
; # (i64 (val (ofs $Month M)))
  %9 = zext i8 %8 to i64
; # (>= (i64 (val (ofs $Month M))) D)
  %10 = icmp uge i64 %9, %2
  br i1 %10, label %$7, label %$8
$8:
; # (and (== D 29) (== M 2) (=0 (% Y 4)) (or (% Y 100) (=0 (% Y 400))...
; # (== D 29)
  %11 = icmp eq i64 %2, 29
  br i1 %11, label %$10, label %$9
$10:
; # (== M 2)
  %12 = icmp eq i64 %1, 2
  br i1 %12, label %$11, label %$9
$11:
; # (% Y 4)
  %13 = urem i64 %0, 4
; # (=0 (% Y 4))
  %14 = icmp eq i64 %13, 0
  br i1 %14, label %$12, label %$9
$12:
; # (or (% Y 100) (=0 (% Y 400)))
; # (% Y 100)
  %15 = urem i64 %0, 100
  %16 = icmp ne i64 %15, 0
  br i1 %16, label %$13, label %$14
$14:
; # (% Y 400)
  %17 = urem i64 %0, 400
; # (=0 (% Y 400))
  %18 = icmp eq i64 %17, 0
  br label %$13
$13:
  %19 = phi i1 [1, %$12], [%18, %$14] ; # ->
  br label %$9
$9:
  %20 = phi i1 [0, %$8], [0, %$10], [0, %$11], [%19, %$13] ; # ->
  br label %$7
$7:
  %21 = phi i1 [1, %$6], [%20, %$9] ; # ->
  br label %$2
$2:
  %22 = phi i1 [0, %$1], [0, %$3], [0, %$4], [0, %$5], [%21, %$7] ; # ->
  br i1 %22, label %$15, label %$16
$15:
; # (let N (/ (+ (* Y 12) M -3) 12) (cnt (- (+ (/ (+ (* Y 4404) (* M ...
; # (* Y 12)
  %23 = mul i64 %0, 12
; # (+ (* Y 12) M -3)
  %24 = add i64 %23, %1
  %25 = add i64 %24, -3
; # (/ (+ (* Y 12) M -3) 12)
  %26 = udiv i64 %25, 12
; # (* Y 4404)
  %27 = mul i64 %0, 4404
; # (* M 367)
  %28 = mul i64 %1, 367
; # (+ (* Y 4404) (* M 367) -1094)
  %29 = add i64 %27, %28
  %30 = add i64 %29, -1094
; # (/ (+ (* Y 4404) (* M 367) -1094) 12)
  %31 = udiv i64 %30, 12
; # (/ N 4)
  %32 = udiv i64 %26, 4
; # (/ N 400)
  %33 = udiv i64 %26, 400
; # (+ (/ (+ (* Y 4404) (* M 367) -1094) 12) (/ N 4) (/ N 400) D)
  %34 = add i64 %31, %32
  %35 = add i64 %34, %33
  %36 = add i64 %35, %2
; # (* 2 N)
  %37 = mul i64 2, %26
; # (/ N 100)
  %38 = udiv i64 %26, 100
; # (- (+ (/ (+ (* Y 4404) (* M 367) -1094) 12) (/ N 4) (/ N 400) D) ...
  %39 = sub i64 %36, %37
  %40 = sub i64 %39, %38
; # (cnt (- (+ (/ (+ (* Y 4404) (* M 367) -1094) 12) (/ N 4) (/ N 400...
  %41 = shl i64 %40, 4
  %42 = or i64 %41, 2
  br label %$17
$16:
  br label %$17
$17:
  %43 = phi i64 [%42, %$15], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$16] ; # ->
  ret i64 %43
}

define i64 @tmTime(i64, i64, i64) align 8 {
$1:
; # (if (and (ge0 H) (ge0 M) (> 60 M) (ge0 S) (> 60 S)) (cnt (+ (* H ...
; # (and (ge0 H) (ge0 M) (> 60 M) (ge0 S) (> 60 S))
; # (ge0 H)
  %3 = icmp sge i64 %0, 0
  br i1 %3, label %$3, label %$2
$3:
; # (ge0 M)
  %4 = icmp sge i64 %1, 0
  br i1 %4, label %$4, label %$2
$4:
; # (> 60 M)
  %5 = icmp ugt i64 60, %1
  br i1 %5, label %$5, label %$2
$5:
; # (ge0 S)
  %6 = icmp sge i64 %2, 0
  br i1 %6, label %$6, label %$2
$6:
; # (> 60 S)
  %7 = icmp ugt i64 60, %2
  br label %$2
$2:
  %8 = phi i1 [0, %$1], [0, %$3], [0, %$4], [0, %$5], [%7, %$6] ; # ->
  br i1 %8, label %$7, label %$8
$7:
; # (* H 3600)
  %9 = mul i64 %0, 3600
; # (* M 60)
  %10 = mul i64 %1, 60
; # (+ (* H 3600) (* M 60) S)
  %11 = add i64 %9, %10
  %12 = add i64 %11, %2
; # (cnt (+ (* H 3600) (* M 60) S))
  %13 = shl i64 %12, 4
  %14 = or i64 %13, 2
  br label %$9
$8:
  br label %$9
$9:
  %15 = phi i64 [%14, %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # ->
  ret i64 %15
}

define i64 @_Date(i64) align 8 {
$1:
; # (let X (cdr Exe) (cond ((atom X) (let N (getDate) (tmDate (& N (h...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (cond ((atom X) (let N (getDate) (tmDate (& N (hex "FFFF")) (& (s...
; # (atom X)
  %4 = and i64 %3, 15
  %5 = icmp ne i64 %4, 0
  br i1 %5, label %$4, label %$3
$4:
  %6 = phi i64 [%3, %$1] ; # X
; # (let N (getDate) (tmDate (& N (hex "FFFF")) (& (shr N 16) (hex "F...
; # (getDate)
  %7 = call i64 @getDate()
; # (& N (hex "FFFF"))
  %8 = and i64 %7, 65535
; # (shr N 16)
  %9 = lshr i64 %7, 16
; # (& (shr N 16) (hex "FF"))
  %10 = and i64 %9, 255
; # (shr N 24)
  %11 = lshr i64 %7, 24
; # (& (shr N 24) (hex "FF"))
  %12 = and i64 %11, 255
; # (tmDate (& N (hex "FFFF")) (& (shr N 16) (hex "FF")) (& (shr N 24...
  %13 = call i64 @tmDate(i64 %8, i64 %10, i64 %12)
  br label %$2
$3:
  %14 = phi i64 [%3, %$1] ; # X
; # (car X)
  %15 = inttoptr i64 %14 to i64*
  %16 = load i64, i64* %15
; # (eval (car X))
  %17 = and i64 %16, 6
  %18 = icmp ne i64 %17, 0
  br i1 %18, label %$7, label %$6
$7:
  br label %$5
$6:
  %19 = and i64 %16, 8
  %20 = icmp ne i64 %19, 0
  br i1 %20, label %$9, label %$8
$9:
  %21 = inttoptr i64 %16 to i64*
  %22 = load i64, i64* %21
  br label %$5
$8:
  %23 = call i64 @evList(i64 %16)
  br label %$5
$5:
  %24 = phi i64 [%16, %$7], [%22, %$9], [%23, %$8] ; # ->
; # (t? (eval (car X)))
  %25 = icmp eq i64 %24, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %25, label %$11, label %$10
$11:
  %26 = phi i64 [%14, %$5] ; # X
; # (let N (getGmDate) (tmDate (& N (hex "FFFF")) (& (shr N 16) (hex ...
; # (getGmDate)
  %27 = call i64 @getGmDate()
; # (& N (hex "FFFF"))
  %28 = and i64 %27, 65535
; # (shr N 16)
  %29 = lshr i64 %27, 16
; # (& (shr N 16) (hex "FF"))
  %30 = and i64 %29, 255
; # (shr N 24)
  %31 = lshr i64 %27, 24
; # (& (shr N 24) (hex "FF"))
  %32 = and i64 %31, 255
; # (tmDate (& N (hex "FFFF")) (& (shr N 16) (hex "FF")) (& (shr N 24...
  %33 = call i64 @tmDate(i64 %28, i64 %30, i64 %32)
  br label %$2
$10:
  %34 = phi i64 [%14, %$5] ; # X
; # (nil? @)
  %35 = icmp eq i64 %24, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %35, label %$13, label %$12
$13:
  %36 = phi i64 [%34, %$10] ; # X
  br label %$2
$12:
  %37 = phi i64 [%34, %$10] ; # X
; # (pair @)
  %38 = and i64 %24, 15
  %39 = icmp eq i64 %38, 0
  br i1 %39, label %$15, label %$14
$15:
  %40 = phi i64 [%37, %$12] ; # X
; # (let L @ (tmDate (xCnt Exe (++ L)) (xCnt Exe (++ L)) (xCnt Exe (c...
; # (++ L)
  %41 = inttoptr i64 %24 to i64*
  %42 = load i64, i64* %41
  %43 = getelementptr i64, i64* %41, i32 1
  %44 = load i64, i64* %43
; # (xCnt Exe (++ L))
  %45 = call i64 @xCnt(i64 %0, i64 %42)
; # (++ L)
  %46 = inttoptr i64 %44 to i64*
  %47 = load i64, i64* %46
  %48 = getelementptr i64, i64* %46, i32 1
  %49 = load i64, i64* %48
; # (xCnt Exe (++ L))
  %50 = call i64 @xCnt(i64 %0, i64 %47)
; # (car L)
  %51 = inttoptr i64 %49 to i64*
  %52 = load i64, i64* %51
; # (xCnt Exe (car L))
  %53 = call i64 @xCnt(i64 %0, i64 %52)
; # (tmDate (xCnt Exe (++ L)) (xCnt Exe (++ L)) (xCnt Exe (car L)))
  %54 = call i64 @tmDate(i64 %45, i64 %50, i64 %53)
  br label %$2
$14:
  %55 = phi i64 [%37, %$12] ; # X
; # (let N @ (cond ((pair (shift X)) (tmDate (xCnt Exe N) (evCnt Exe ...
; # (cond ((pair (shift X)) (tmDate (xCnt Exe N) (evCnt Exe X) (evCnt...
; # (shift X)
  %56 = inttoptr i64 %55 to i64*
  %57 = getelementptr i64, i64* %56, i32 1
  %58 = load i64, i64* %57
; # (pair (shift X))
  %59 = and i64 %58, 15
  %60 = icmp eq i64 %59, 0
  br i1 %60, label %$18, label %$17
$18:
  %61 = phi i64 [%58, %$14] ; # X
  %62 = phi i64 [%24, %$14] ; # N
; # (xCnt Exe N)
  %63 = call i64 @xCnt(i64 %0, i64 %62)
; # (evCnt Exe X)
  %64 = call i64 @evCnt(i64 %0, i64 %61)
; # (cdr X)
  %65 = inttoptr i64 %61 to i64*
  %66 = getelementptr i64, i64* %65, i32 1
  %67 = load i64, i64* %66
; # (evCnt Exe (cdr X))
  %68 = call i64 @evCnt(i64 %0, i64 %67)
; # (tmDate (xCnt Exe N) (evCnt Exe X) (evCnt Exe (cdr X)))
  %69 = call i64 @tmDate(i64 %63, i64 %64, i64 %68)
  br label %$16
$17:
  %70 = phi i64 [%58, %$14] ; # X
  %71 = phi i64 [%24, %$14] ; # N
; # (xCnt Exe N)
  %72 = call i64 @xCnt(i64 %0, i64 %71)
; # (lt0 (setq N (xCnt Exe N)))
  %73 = icmp slt i64 %72, 0
  br i1 %73, label %$20, label %$19
$20:
  %74 = phi i64 [%70, %$17] ; # X
  %75 = phi i64 [%72, %$17] ; # N
  br label %$16
$19:
  %76 = phi i64 [%70, %$17] ; # X
  %77 = phi i64 [%72, %$17] ; # N
; # (let Y (/ (- (* N 100) 20) 3652425) (setq N (+ N (- Y (/ Y 4))) Y...
; # (* N 100)
  %78 = mul i64 %77, 100
; # (- (* N 100) 20)
  %79 = sub i64 %78, 20
; # (/ (- (* N 100) 20) 3652425)
  %80 = udiv i64 %79, 3652425
; # (/ Y 4)
  %81 = udiv i64 %80, 4
; # (- Y (/ Y 4))
  %82 = sub i64 %80, %81
; # (+ N (- Y (/ Y 4)))
  %83 = add i64 %77, %82
; # (* N 100)
  %84 = mul i64 %83, 100
; # (- (* N 100) 20)
  %85 = sub i64 %84, 20
; # (/ (- (* N 100) 20) 36525)
  %86 = udiv i64 %85, 36525
; # (* Y 36525)
  %87 = mul i64 %86, 36525
; # (/ (* Y 36525) 100)
  %88 = udiv i64 %87, 100
; # (- N (/ (* Y 36525) 100))
  %89 = sub i64 %83, %88
; # (* (- N (/ (* Y 36525) 100)) 10)
  %90 = mul i64 %89, 10
; # (let (M (/ (- N 5) 306) D (/ (+ N (* M -306) 5) 10)) (if (> 10 M)...
; # (- N 5)
  %91 = sub i64 %90, 5
; # (/ (- N 5) 306)
  %92 = udiv i64 %91, 306
; # (* M -306)
  %93 = mul i64 %92, -306
; # (+ N (* M -306) 5)
  %94 = add i64 %90, %93
  %95 = add i64 %94, 5
; # (/ (+ N (* M -306) 5) 10)
  %96 = udiv i64 %95, 10
; # (if (> 10 M) (inc 'M 3) (inc 'Y) (dec 'M 9))
; # (> 10 M)
  %97 = icmp ugt i64 10, %92
  br i1 %97, label %$21, label %$22
$21:
  %98 = phi i64 [%76, %$19] ; # X
  %99 = phi i64 [%90, %$19] ; # N
  %100 = phi i64 [%86, %$19] ; # Y
  %101 = phi i64 [%92, %$19] ; # M
; # (inc 'M 3)
  %102 = add i64 %101, 3
  br label %$23
$22:
  %103 = phi i64 [%76, %$19] ; # X
  %104 = phi i64 [%90, %$19] ; # N
  %105 = phi i64 [%86, %$19] ; # Y
  %106 = phi i64 [%92, %$19] ; # M
; # (inc 'Y)
  %107 = add i64 %105, 1
; # (dec 'M 9)
  %108 = sub i64 %106, 9
  br label %$23
$23:
  %109 = phi i64 [%98, %$21], [%103, %$22] ; # X
  %110 = phi i64 [%99, %$21], [%104, %$22] ; # N
  %111 = phi i64 [%100, %$21], [%107, %$22] ; # Y
  %112 = phi i64 [%102, %$21], [%108, %$22] ; # M
  %113 = phi i64 [%102, %$21], [%108, %$22] ; # ->
; # (cnt Y)
  %114 = shl i64 %111, 4
  %115 = or i64 %114, 2
; # (cnt M)
  %116 = shl i64 %112, 4
  %117 = or i64 %116, 2
; # (cnt D)
  %118 = shl i64 %96, 4
  %119 = or i64 %118, 2
; # (cons (cnt D) $Nil)
  %120 = call i64 @cons(i64 %119, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (cons (cnt M) (cons (cnt D) $Nil))
  %121 = call i64 @cons(i64 %117, i64 %120)
; # (cons (cnt Y) (cons (cnt M) (cons (cnt D) $Nil)))
  %122 = call i64 @cons(i64 %115, i64 %121)
  br label %$16
$16:
  %123 = phi i64 [%61, %$18], [%74, %$20], [%109, %$23] ; # X
  %124 = phi i64 [%62, %$18], [%75, %$20], [%110, %$23] ; # N
  %125 = phi i64 [%69, %$18], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$20], [%122, %$23] ; # ->
  br label %$2
$2:
  %126 = phi i64 [%6, %$4], [%26, %$11], [%36, %$13], [%40, %$15], [%123, %$16] ; # X
  %127 = phi i64 [%13, %$4], [%33, %$11], [%24, %$13], [%54, %$15], [%125, %$16] ; # ->
  ret i64 %127
}

define i64 @_Time(i64) align 8 {
$1:
; # (let X (cdr Exe) (cond ((atom X) (cnt (getTime))) ((t? (eval (car...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (cond ((atom X) (cnt (getTime))) ((t? (eval (car X))) (if (lt0 (g...
; # (atom X)
  %4 = and i64 %3, 15
  %5 = icmp ne i64 %4, 0
  br i1 %5, label %$4, label %$3
$4:
  %6 = phi i64 [%3, %$1] ; # X
; # (getTime)
  %7 = call i64 @getTime()
; # (cnt (getTime))
  %8 = shl i64 %7, 4
  %9 = or i64 %8, 2
  br label %$2
$3:
  %10 = phi i64 [%3, %$1] ; # X
; # (car X)
  %11 = inttoptr i64 %10 to i64*
  %12 = load i64, i64* %11
; # (eval (car X))
  %13 = and i64 %12, 6
  %14 = icmp ne i64 %13, 0
  br i1 %14, label %$7, label %$6
$7:
  br label %$5
$6:
  %15 = and i64 %12, 8
  %16 = icmp ne i64 %15, 0
  br i1 %16, label %$9, label %$8
$9:
  %17 = inttoptr i64 %12 to i64*
  %18 = load i64, i64* %17
  br label %$5
$8:
  %19 = call i64 @evList(i64 %12)
  br label %$5
$5:
  %20 = phi i64 [%12, %$7], [%18, %$9], [%19, %$8] ; # ->
; # (t? (eval (car X)))
  %21 = icmp eq i64 %20, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %21, label %$11, label %$10
$11:
  %22 = phi i64 [%10, %$5] ; # X
; # (if (lt0 (getGmTime)) $Nil (cnt @))
; # (getGmTime)
  %23 = call i64 @getGmTime()
; # (lt0 (getGmTime))
  %24 = icmp slt i64 %23, 0
  br i1 %24, label %$12, label %$13
$12:
  %25 = phi i64 [%22, %$11] ; # X
  br label %$14
$13:
  %26 = phi i64 [%22, %$11] ; # X
; # (cnt @)
  %27 = shl i64 %23, 4
  %28 = or i64 %27, 2
  br label %$14
$14:
  %29 = phi i64 [%25, %$12], [%26, %$13] ; # X
  %30 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$12], [%28, %$13] ; # ->
  br label %$2
$10:
  %31 = phi i64 [%10, %$5] ; # X
; # (nil? @)
  %32 = icmp eq i64 %20, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %32, label %$16, label %$15
$16:
  %33 = phi i64 [%31, %$10] ; # X
  br label %$2
$15:
  %34 = phi i64 [%31, %$10] ; # X
; # (pair @)
  %35 = and i64 %20, 15
  %36 = icmp eq i64 %35, 0
  br i1 %36, label %$18, label %$17
$18:
  %37 = phi i64 [%34, %$15] ; # X
; # (let L @ (tmTime (xCnt Exe (++ L)) (xCnt Exe (++ L)) (if (pair L)...
; # (++ L)
  %38 = inttoptr i64 %20 to i64*
  %39 = load i64, i64* %38
  %40 = getelementptr i64, i64* %38, i32 1
  %41 = load i64, i64* %40
; # (xCnt Exe (++ L))
  %42 = call i64 @xCnt(i64 %0, i64 %39)
; # (++ L)
  %43 = inttoptr i64 %41 to i64*
  %44 = load i64, i64* %43
  %45 = getelementptr i64, i64* %43, i32 1
  %46 = load i64, i64* %45
; # (xCnt Exe (++ L))
  %47 = call i64 @xCnt(i64 %0, i64 %44)
; # (if (pair L) (xCnt Exe (car L)) 0)
; # (pair L)
  %48 = and i64 %46, 15
  %49 = icmp eq i64 %48, 0
  br i1 %49, label %$19, label %$20
$19:
  %50 = phi i64 [%37, %$18] ; # X
  %51 = phi i64 [%46, %$18] ; # L
; # (car L)
  %52 = inttoptr i64 %51 to i64*
  %53 = load i64, i64* %52
; # (xCnt Exe (car L))
  %54 = call i64 @xCnt(i64 %0, i64 %53)
  br label %$21
$20:
  %55 = phi i64 [%37, %$18] ; # X
  %56 = phi i64 [%46, %$18] ; # L
  br label %$21
$21:
  %57 = phi i64 [%50, %$19], [%55, %$20] ; # X
  %58 = phi i64 [%51, %$19], [%56, %$20] ; # L
  %59 = phi i64 [%54, %$19], [0, %$20] ; # ->
; # (tmTime (xCnt Exe (++ L)) (xCnt Exe (++ L)) (if (pair L) (xCnt Ex...
  %60 = call i64 @tmTime(i64 %42, i64 %47, i64 %59)
  br label %$2
$17:
  %61 = phi i64 [%34, %$15] ; # X
; # (let N @ (cond ((pair (shift X)) (tmTime (xCnt Exe N) (evCnt Exe ...
; # (cond ((pair (shift X)) (tmTime (xCnt Exe N) (evCnt Exe X) (if (p...
; # (shift X)
  %62 = inttoptr i64 %61 to i64*
  %63 = getelementptr i64, i64* %62, i32 1
  %64 = load i64, i64* %63
; # (pair (shift X))
  %65 = and i64 %64, 15
  %66 = icmp eq i64 %65, 0
  br i1 %66, label %$24, label %$23
$24:
  %67 = phi i64 [%64, %$17] ; # X
  %68 = phi i64 [%20, %$17] ; # N
; # (xCnt Exe N)
  %69 = call i64 @xCnt(i64 %0, i64 %68)
; # (evCnt Exe X)
  %70 = call i64 @evCnt(i64 %0, i64 %67)
; # (if (pair (shift X)) (evCnt Exe X) 0)
; # (shift X)
  %71 = inttoptr i64 %67 to i64*
  %72 = getelementptr i64, i64* %71, i32 1
  %73 = load i64, i64* %72
; # (pair (shift X))
  %74 = and i64 %73, 15
  %75 = icmp eq i64 %74, 0
  br i1 %75, label %$25, label %$26
$25:
  %76 = phi i64 [%73, %$24] ; # X
  %77 = phi i64 [%68, %$24] ; # N
; # (evCnt Exe X)
  %78 = call i64 @evCnt(i64 %0, i64 %76)
  br label %$27
$26:
  %79 = phi i64 [%73, %$24] ; # X
  %80 = phi i64 [%68, %$24] ; # N
  br label %$27
$27:
  %81 = phi i64 [%76, %$25], [%79, %$26] ; # X
  %82 = phi i64 [%77, %$25], [%80, %$26] ; # N
  %83 = phi i64 [%78, %$25], [0, %$26] ; # ->
; # (tmTime (xCnt Exe N) (evCnt Exe X) (if (pair (shift X)) (evCnt Ex...
  %84 = call i64 @tmTime(i64 %69, i64 %70, i64 %83)
  br label %$22
$23:
  %85 = phi i64 [%64, %$17] ; # X
  %86 = phi i64 [%20, %$17] ; # N
; # (xCnt Exe N)
  %87 = call i64 @xCnt(i64 %0, i64 %86)
; # (lt0 (setq N (xCnt Exe N)))
  %88 = icmp slt i64 %87, 0
  br i1 %88, label %$29, label %$28
$29:
  %89 = phi i64 [%85, %$23] ; # X
  %90 = phi i64 [%87, %$23] ; # N
  br label %$22
$28:
  %91 = phi i64 [%85, %$23] ; # X
  %92 = phi i64 [%87, %$23] ; # N
; # (/ N 3600)
  %93 = udiv i64 %92, 3600
; # (cnt (/ N 3600))
  %94 = shl i64 %93, 4
  %95 = or i64 %94, 2
; # (/ N 60)
  %96 = udiv i64 %92, 60
; # (% (/ N 60) 60)
  %97 = urem i64 %96, 60
; # (cnt (% (/ N 60) 60))
  %98 = shl i64 %97, 4
  %99 = or i64 %98, 2
; # (% N 60)
  %100 = urem i64 %92, 60
; # (cnt (% N 60))
  %101 = shl i64 %100, 4
  %102 = or i64 %101, 2
; # (cons (cnt (% N 60)) $Nil)
  %103 = call i64 @cons(i64 %102, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (cons (cnt (% (/ N 60) 60)) (cons (cnt (% N 60)) $Nil))
  %104 = call i64 @cons(i64 %99, i64 %103)
; # (cons (cnt (/ N 3600)) (cons (cnt (% (/ N 60) 60)) (cons (cnt (% ...
  %105 = call i64 @cons(i64 %95, i64 %104)
  br label %$22
$22:
  %106 = phi i64 [%81, %$27], [%89, %$29], [%91, %$28] ; # X
  %107 = phi i64 [%82, %$27], [%90, %$29], [%92, %$28] ; # N
  %108 = phi i64 [%84, %$27], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$29], [%105, %$28] ; # ->
  br label %$2
$2:
  %109 = phi i64 [%6, %$4], [%29, %$14], [%33, %$16], [%57, %$21], [%106, %$22] ; # X
  %110 = phi i64 [%9, %$4], [%30, %$14], [%20, %$16], [%60, %$21], [%108, %$22] ; # ->
  ret i64 %110
}

define i64 @_Usec(i64) align 8 {
$1:
; # (if (nil? (eval (cadr Exe))) (- (getUsec YES) (val $USec)) (getUs...
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (nil? (eval (cadr Exe)))
  %14 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %14, label %$7, label %$8
$7:
; # (getUsec YES)
  %15 = call i64 @getUsec(i1 1)
; # (val $USec)
  %16 = load i64, i64* @$USec
; # (- (getUsec YES) (val $USec))
  %17 = sub i64 %15, %16
  br label %$9
$8:
; # (getUsec NO)
  %18 = call i64 @getUsec(i1 0)
  br label %$9
$9:
  %19 = phi i64 [%17, %$7], [%18, %$8] ; # ->
; # (cnt (if (nil? (eval (cadr Exe))) (- (getUsec YES) (val $USec)) (...
  %20 = shl i64 %19, 4
  %21 = or i64 %20, 2
  ret i64 %21
}

define i64 @_Rt(i64) align 8 {
$1:
; # (let (X (cdr Exe) Rt (val $Rt) U (getUsec YES)) (prog1 (run (cdr ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (val $Rt)
  %4 = load i64, i64* @$Rt
; # (getUsec YES)
  %5 = call i64 @getUsec(i1 1)
; # (prog1 (run (cdr X)) (let D (- (- (getUsec YES) U) (- (val $Rt) R...
; # (cdr X)
  %6 = inttoptr i64 %3 to i64*
  %7 = getelementptr i64, i64* %6, i32 1
  %8 = load i64, i64* %7
; # (run (cdr X))
  br label %$2
$2:
  %9 = phi i64 [%8, %$1], [%31, %$11] ; # Prg
  %10 = inttoptr i64 %9 to i64*
  %11 = load i64, i64* %10
  %12 = getelementptr i64, i64* %10, i32 1
  %13 = load i64, i64* %12
  %14 = and i64 %13, 15
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$5, label %$3
$5:
  %16 = phi i64 [%13, %$2] ; # Prg
  %17 = and i64 %11, 6
  %18 = icmp ne i64 %17, 0
  br i1 %18, label %$8, label %$7
$8:
  br label %$6
$7:
  %19 = and i64 %11, 8
  %20 = icmp ne i64 %19, 0
  br i1 %20, label %$10, label %$9
$10:
  %21 = inttoptr i64 %11 to i64*
  %22 = load i64, i64* %21
  br label %$6
$9:
  %23 = call i64 @evList(i64 %11)
  br label %$6
$6:
  %24 = phi i64 [%11, %$8], [%22, %$10], [%23, %$9] ; # ->
  br label %$4
$3:
  %25 = phi i64 [%13, %$2] ; # Prg
  %26 = and i64 %11, 15
  %27 = icmp eq i64 %26, 0
  br i1 %27, label %$12, label %$11
$12:
  %28 = phi i64 [%25, %$3] ; # Prg
  %29 = call i64 @evList(i64 %11)
  %30 = icmp ne i64 %29, 0
  br label %$11
$11:
  %31 = phi i64 [%25, %$3], [%28, %$12] ; # Prg
  %32 = phi i1 [0, %$3], [%30, %$12] ; # ->
  br label %$2
$4:
  %33 = phi i64 [%16, %$6] ; # Prg
  %34 = phi i64 [%24, %$6] ; # ->
; # (let D (- (- (getUsec YES) U) (- (val $Rt) Rt)) (set $Rt (+ D (va...
; # (getUsec YES)
  %35 = call i64 @getUsec(i1 1)
; # (- (getUsec YES) U)
  %36 = sub i64 %35, %5
; # (val $Rt)
  %37 = load i64, i64* @$Rt
; # (- (val $Rt) Rt)
  %38 = sub i64 %37, %4
; # (- (- (getUsec YES) U) (- (val $Rt) Rt))
  %39 = sub i64 %36, %38
; # (set $Rt (+ D (val $Rt)) X (+ (car X) (shl D 4)))
; # (val $Rt)
  %40 = load i64, i64* @$Rt
; # (+ D (val $Rt))
  %41 = add i64 %39, %40
  store i64 %41, i64* @$Rt
; # (car X)
  %42 = inttoptr i64 %3 to i64*
  %43 = load i64, i64* %42
; # (shl D 4)
  %44 = shl i64 %39, 4
; # (+ (car X) (shl D 4))
  %45 = add i64 %43, %44
  %46 = inttoptr i64 %3 to i64*
  store i64 %45, i64* %46
  ret i64 %34
}

define i1 @sharedLib(i64) align 8 {
$1:
; # (let (Nm (xName Sym) S (bufString Nm (b8 (bufSize Nm))) P (strchr...
; # (xName Sym)
  %1 = call i64 @xName(i64 %0)
; # (bufSize Nm)
  %2 = call i64 @bufSize(i64 %1)
; # (b8 (bufSize Nm))
  %3 = alloca i8, i64 %2
; # (bufString Nm (b8 (bufSize Nm)))
  %4 = call i8* @bufString(i64 %1, i8* %3)
; # (strchr S (char ":"))
  %5 = call i8* @strchr(i8* %4, i32 58)
; # (and P (<> P S) (val 2 P) (let N (val $PilLen) (set P 0) (let (Le...
  %6 = icmp ne i8* %5, null
  br i1 %6, label %$3, label %$2
$3:
; # (<> P S)
  %7 = icmp ne i8* %5, %4
  br i1 %7, label %$4, label %$2
$4:
; # (val 2 P)
  %8 = getelementptr i8, i8* %5, i32 1
  %9 = load i8, i8* %8
  %10 = icmp ne i8 %9, 0
  br i1 %10, label %$5, label %$2
$5:
; # (let N (val $PilLen) (set P 0) (let (Len (strlen S) Q (b8 (+ N Le...
; # (val $PilLen)
  %11 = load i64, i64* @$PilLen
; # (set P 0)
  store i8 0, i8* %5
; # (let (Len (strlen S) Q (b8 (+ N Len (+ 4 3 1)))) (if (strchr S (c...
; # (strlen S)
  %12 = call i64 @strlen(i8* %4)
; # (+ 4 3 1)
; # (+ N Len (+ 4 3 1))
  %13 = add i64 %11, %12
  %14 = add i64 %13, 8
; # (b8 (+ N Len (+ 4 3 1)))
  %15 = alloca i8, i64 %14
; # (if (strchr S (char "/")) (strcpy Q S) (when N (memcpy Q (val $Pi...
; # (strchr S (char "/"))
  %16 = call i8* @strchr(i8* %4, i32 47)
  %17 = icmp ne i8* %16, null
  br i1 %17, label %$6, label %$7
$6:
  %18 = phi i64 [%12, %$5] ; # Len
; # (strcpy Q S)
  %19 = call i8* @strcpy(i8* %15, i8* %4)
  br label %$8
$7:
  %20 = phi i64 [%12, %$5] ; # Len
; # (when N (memcpy Q (val $PilHome) N))
  %21 = icmp ne i64 %11, 0
  br i1 %21, label %$9, label %$10
$9:
  %22 = phi i64 [%20, %$7] ; # Len
; # (val $PilHome)
  %23 = load i8*, i8** @$PilHome
; # (memcpy Q (val $PilHome) N)
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* %15, i8* %23, i64 %11, i1 0)
  br label %$10
$10:
  %24 = phi i64 [%20, %$7], [%22, %$9] ; # Len
; # (ofs Q N)
  %25 = getelementptr i8, i8* %15, i64 %11
; # (strcpy (ofs Q N) ($ "lib/"))
  %26 = call i8* @strcpy(i8* %25, i8* bitcast ([5 x i8]* @$25 to i8*))
; # (+ N 4)
  %27 = add i64 %11, 4
; # (ofs Q (+ N 4))
  %28 = getelementptr i8, i8* %15, i64 %27
; # (strcpy (ofs Q (+ N 4)) S)
  %29 = call i8* @strcpy(i8* %28, i8* %4)
; # (+ Len N 4)
  %30 = add i64 %24, %11
  %31 = add i64 %30, 4
  br label %$8
$8:
  %32 = phi i64 [%18, %$6], [%31, %$10] ; # Len
; # (ofs Q Len)
  %33 = getelementptr i8, i8* %15, i64 %32
; # (strcpy (ofs Q Len) ($ ".so"))
  %34 = call i8* @strcpy(i8* %33, i8* bitcast ([4 x i8]* @$26 to i8*))
; # (and (dlOpen Q) (dlsym @ (inc P)) (prog (set Sym (| (i64 @) 2)) Y...
; # (dlOpen Q)
  %35 = call i8* @dlOpen(i8* %15)
  %36 = icmp ne i8* %35, null
  br i1 %36, label %$12, label %$11
$12:
  %37 = phi i64 [%32, %$8] ; # Len
; # (inc P)
  %38 = getelementptr i8, i8* %5, i32 1
; # (dlsym @ (inc P))
  %39 = call i8* @dlsym(i8* %35, i8* %38)
  %40 = icmp ne i8* %39, null
  br i1 %40, label %$13, label %$11
$13:
  %41 = phi i64 [%37, %$12] ; # Len
; # (set Sym (| (i64 @) 2))
; # (i64 @)
  %42 = ptrtoint i8* %39 to i64
; # (| (i64 @) 2)
  %43 = or i64 %42, 2
  %44 = inttoptr i64 %0 to i64*
  store i64 %43, i64* %44
  br label %$11
$11:
  %45 = phi i64 [%32, %$8], [%37, %$12], [%41, %$13] ; # Len
  %46 = phi i1 [0, %$8], [0, %$12], [1, %$13] ; # ->
  br label %$2
$2:
  %47 = phi i1 [0, %$1], [0, %$3], [0, %$4], [%46, %$11] ; # ->
  ret i1 %47
}

define void @mark(i64) align 8 {
$1:
; # (let Tos 0 (loop (until (cnt? E) (let (P (any (& E -16)) Q (cdr P...
; # (loop (until (cnt? E) (let (P (any (& E -16)) Q (cdr P)) (? (=0 (...
  br label %$2
$2:
  %1 = phi i64 [%0, %$1], [%85, %$17] ; # E
  %2 = phi i64 [0, %$1], [%86, %$17] ; # Tos
; # (until (cnt? E) (let (P (any (& E -16)) Q (cdr P)) (? (=0 (& Q 1)...
  br label %$3
$3:
  %3 = phi i64 [%1, %$2], [%52, %$7] ; # E
  %4 = phi i64 [%2, %$2], [%48, %$7] ; # Tos
; # (cnt? E)
  %5 = and i64 %3, 2
  %6 = icmp ne i64 %5, 0
  br i1 %6, label %$5, label %$4
$4:
  %7 = phi i64 [%3, %$3] ; # E
  %8 = phi i64 [%4, %$3] ; # Tos
; # (let (P (any (& E -16)) Q (cdr P)) (? (=0 (& Q 1))) (set 2 P (set...
; # (& E -16)
  %9 = and i64 %7, -16
; # (any (& E -16))
; # (cdr P)
  %10 = inttoptr i64 %9 to i64*
  %11 = getelementptr i64, i64* %10, i32 1
  %12 = load i64, i64* %11
; # (? (=0 (& Q 1)))
; # (& Q 1)
  %13 = and i64 %12, 1
; # (=0 (& Q 1))
  %14 = icmp eq i64 %13, 0
  br i1 %14, label %$5, label %$6
$6:
  %15 = phi i64 [%7, %$4] ; # E
  %16 = phi i64 [%8, %$4] ; # Tos
  %17 = phi i64 [%12, %$4] ; # Q
; # (set 2 P (setq Q (& Q -2)))
; # (& Q -2)
  %18 = and i64 %17, -2
  %19 = inttoptr i64 %9 to i64*
  %20 = getelementptr i64, i64* %19, i32 1
  store i64 %18, i64* %20
; # (? (big? E) (until (cnt? Q) (let N (val (big Q)) (? (=0 (& N 1)))...
; # (big? E)
  %21 = and i64 %15, 4
  %22 = icmp ne i64 %21, 0
  br i1 %22, label %$8, label %$7
$8:
  %23 = phi i64 [%15, %$6] ; # E
  %24 = phi i64 [%16, %$6] ; # Tos
  %25 = phi i64 [%18, %$6] ; # Q
; # (until (cnt? Q) (let N (val (big Q)) (? (=0 (& N 1))) (setq Q (se...
  br label %$9
$9:
  %26 = phi i64 [%23, %$8], [%39, %$12] ; # E
  %27 = phi i64 [%24, %$8], [%40, %$12] ; # Tos
  %28 = phi i64 [%25, %$8], [%43, %$12] ; # Q
; # (cnt? Q)
  %29 = and i64 %28, 2
  %30 = icmp ne i64 %29, 0
  br i1 %30, label %$11, label %$10
$10:
  %31 = phi i64 [%26, %$9] ; # E
  %32 = phi i64 [%27, %$9] ; # Tos
  %33 = phi i64 [%28, %$9] ; # Q
; # (let N (val (big Q)) (? (=0 (& N 1))) (setq Q (set (big Q) (& N -...
; # (big Q)
  %34 = add i64 %33, 4
; # (val (big Q))
  %35 = inttoptr i64 %34 to i64*
  %36 = load i64, i64* %35
; # (? (=0 (& N 1)))
; # (& N 1)
  %37 = and i64 %36, 1
; # (=0 (& N 1))
  %38 = icmp eq i64 %37, 0
  br i1 %38, label %$11, label %$12
$12:
  %39 = phi i64 [%31, %$10] ; # E
  %40 = phi i64 [%32, %$10] ; # Tos
  %41 = phi i64 [%33, %$10] ; # Q
; # (set (big Q) (& N -2))
; # (big Q)
  %42 = add i64 %41, 4
; # (& N -2)
  %43 = and i64 %36, -2
  %44 = inttoptr i64 %42 to i64*
  store i64 %43, i64* %44
  br label %$9
$11:
  %45 = phi i64 [%26, %$9], [%31, %$10] ; # E
  %46 = phi i64 [%27, %$9], [%32, %$10] ; # Tos
  %47 = phi i64 [%28, %$9], [%33, %$10] ; # Q
  br label %$5
$7:
  %48 = phi i64 [%15, %$6] ; # E
  %49 = phi i64 [%16, %$6] ; # Tos
  %50 = phi i64 [%18, %$6] ; # Q
; # (let X E (setq E (val P)) (set P (| Tos 1)) (setq Tos X))
; # (val P)
  %51 = inttoptr i64 %9 to i64*
  %52 = load i64, i64* %51
; # (set P (| Tos 1))
; # (| Tos 1)
  %53 = or i64 %49, 1
  %54 = inttoptr i64 %9 to i64*
  store i64 %53, i64* %54
  br label %$3
$5:
  %55 = phi i64 [%3, %$3], [%7, %$4], [%45, %$11] ; # E
  %56 = phi i64 [%4, %$3], [%8, %$4], [%46, %$11] ; # Tos
; # (loop (let P (any (& Tos -16)) (unless P (ret)) (let Q (val P) (?...
  br label %$13
$13:
  %57 = phi i64 [%55, %$5], [%79, %$16] ; # E
  %58 = phi i64 [%56, %$5], [%82, %$16] ; # Tos
; # (let P (any (& Tos -16)) (unless P (ret)) (let Q (val P) (? (& Q ...
; # (& Tos -16)
  %59 = and i64 %58, -16
; # (any (& Tos -16))
; # (unless P (ret))
  %60 = icmp ne i64 %59, 0
  br i1 %60, label %$15, label %$14
$14:
  %61 = phi i64 [%57, %$13] ; # E
  %62 = phi i64 [%58, %$13] ; # Tos
; # (ret)
  ret void
$15:
  %63 = phi i64 [%57, %$13] ; # E
  %64 = phi i64 [%58, %$13] ; # Tos
; # (let Q (val P) (? (& Q 1) (set P E) (setq E (cdr P)) (set 2 P (& ...
; # (val P)
  %65 = inttoptr i64 %59 to i64*
  %66 = load i64, i64* %65
; # (? (& Q 1) (set P E) (setq E (cdr P)) (set 2 P (& Q -2)))
; # (& Q 1)
  %67 = and i64 %66, 1
  %68 = icmp ne i64 %67, 0
  br i1 %68, label %$18, label %$16
$18:
  %69 = phi i64 [%63, %$15] ; # E
  %70 = phi i64 [%64, %$15] ; # Tos
; # (set P E)
  %71 = inttoptr i64 %59 to i64*
  store i64 %69, i64* %71
; # (cdr P)
  %72 = inttoptr i64 %59 to i64*
  %73 = getelementptr i64, i64* %72, i32 1
  %74 = load i64, i64* %73
; # (set 2 P (& Q -2))
; # (& Q -2)
  %75 = and i64 %66, -2
  %76 = inttoptr i64 %59 to i64*
  %77 = getelementptr i64, i64* %76, i32 1
  store i64 %75, i64* %77
  br label %$17
$16:
  %78 = phi i64 [%63, %$15] ; # E
  %79 = phi i64 [%64, %$15] ; # Tos
; # (let X Tos (setq Tos (cdr P)) (set 2 P E) (setq E X))
; # (cdr P)
  %80 = inttoptr i64 %59 to i64*
  %81 = getelementptr i64, i64* %80, i32 1
  %82 = load i64, i64* %81
; # (set 2 P E)
  %83 = inttoptr i64 %59 to i64*
  %84 = getelementptr i64, i64* %83, i32 1
  store i64 %78, i64* %84
  br label %$13
$17:
  %85 = phi i64 [%74, %$18] ; # E
  %86 = phi i64 [%70, %$18] ; # Tos
  %87 = phi i64 [%75, %$18] ; # ->
  br label %$2
}

define void @gc() align 8 {
$1:
; # (set $DB $Nil)
  %0 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 232) to i64) to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %0
; # (let P $Nil (set P (| (val P) 1)) (setq P (ofs P 4)) (loop (set P...
; # (set P (| (val P) 1))
; # (val P)
  %1 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64) to i64*
  %2 = load i64, i64* %1
; # (| (val P) 1)
  %3 = or i64 %2, 1
  %4 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64) to i64*
  store i64 %3, i64* %4
; # (ofs P 4)
  %5 = add i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), 32
; # (loop (set P (| (val P) 1)) (? (== P $LastSym)) (setq P (ofs P 2)...
  br label %$2
$2:
  %6 = phi i64 [%5, %$1], [%13, %$3] ; # P
; # (set P (| (val P) 1))
; # (val P)
  %7 = inttoptr i64 %6 to i64*
  %8 = load i64, i64* %7
; # (| (val P) 1)
  %9 = or i64 %8, 1
  %10 = inttoptr i64 %6 to i64*
  store i64 %9, i64* %10
; # (? (== P $LastSym))
; # (== P $LastSym)
  %11 = icmp eq i64 %6, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 7096) to i64)
  br i1 %11, label %$4, label %$3
$3:
  %12 = phi i64 [%6, %$2] ; # P
; # (ofs P 2)
  %13 = add i64 %12, 16
  br label %$2
$4:
  %14 = phi i64 [%6, %$2] ; # P
  %15 = phi i64 [0, %$2] ; # ->
; # (let P (val $Heaps) (loop (let C CELLS (loop (set 2 P (| (cdr P) ...
; # (val $Heaps)
  %16 = load i64, i64* @$Heaps
; # (loop (let C CELLS (loop (set 2 P (| (cdr P) 1)) (setq P (ofs P 2...
  br label %$5
$5:
  %17 = phi i64 [%16, %$4], [%37, %$9] ; # P
; # (let C CELLS (loop (set 2 P (| (cdr P) 1)) (setq P (ofs P 2)) (? ...
; # (loop (set 2 P (| (cdr P) 1)) (setq P (ofs P 2)) (? (=0 (dec 'C))...
  br label %$6
$6:
  %18 = phi i64 [%17, %$5], [%29, %$7] ; # P
  %19 = phi i64 [65536, %$5], [%30, %$7] ; # C
; # (set 2 P (| (cdr P) 1))
; # (cdr P)
  %20 = inttoptr i64 %18 to i64*
  %21 = getelementptr i64, i64* %20, i32 1
  %22 = load i64, i64* %21
; # (| (cdr P) 1)
  %23 = or i64 %22, 1
  %24 = inttoptr i64 %18 to i64*
  %25 = getelementptr i64, i64* %24, i32 1
  store i64 %23, i64* %25
; # (ofs P 2)
  %26 = add i64 %18, 16
; # (? (=0 (dec 'C)))
; # (dec 'C)
  %27 = sub i64 %19, 1
; # (=0 (dec 'C))
  %28 = icmp eq i64 %27, 0
  br i1 %28, label %$8, label %$7
$7:
  %29 = phi i64 [%26, %$6] ; # P
  %30 = phi i64 [%27, %$6] ; # C
  br label %$6
$8:
  %31 = phi i64 [%26, %$6] ; # P
  %32 = phi i64 [%27, %$6] ; # C
  %33 = phi i64 [0, %$6] ; # ->
; # (val P)
  %34 = inttoptr i64 %31 to i64*
  %35 = load i64, i64* %34
; # (? (=0 P))
; # (=0 P)
  %36 = icmp eq i64 %35, 0
  br i1 %36, label %$10, label %$9
$9:
  %37 = phi i64 [%35, %$8] ; # P
  br label %$5
$10:
  %38 = phi i64 [%35, %$8] ; # P
  %39 = phi i64 [0, %$8] ; # ->
; # (let P (any (gcData)) (loop (mark (val P)) (? (== P $LispEnd)) (s...
; # (i8* $Intern)
  %40 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 0) to i64) to i8*
; # (any (gcData))
  %41 = ptrtoint i8* %40 to i64
; # (loop (mark (val P)) (? (== P $LispEnd)) (setq P (ofs P 1)))
  br label %$11
$11:
  %42 = phi i64 [%41, %$10], [%47, %$12] ; # P
; # (val P)
  %43 = inttoptr i64 %42 to i64*
  %44 = load i64, i64* %43
; # (mark (val P))
  call void @mark(i64 %44)
; # (? (== P $LispEnd))
; # (== P $LispEnd)
  %45 = icmp eq i64 %42, ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 416) to i64)
  br i1 %45, label %$13, label %$12
$12:
  %46 = phi i64 [%42, %$11] ; # P
; # (ofs P 1)
  %47 = add i64 %46, 8
  br label %$11
$13:
  %48 = phi i64 [%42, %$11] ; # P
  %49 = phi i64 [0, %$11] ; # ->
; # (let P (val $Link) (while P (mark (val P)) (shift P)))
; # (val $Link)
  %50 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %51 = load i64, i64* %50
; # (while P (mark (val P)) (shift P))
  br label %$14
$14:
  %52 = phi i64 [%51, %$13], [%59, %$15] ; # P
  %53 = icmp ne i64 %52, 0
  br i1 %53, label %$15, label %$16
$15:
  %54 = phi i64 [%52, %$14] ; # P
; # (val P)
  %55 = inttoptr i64 %54 to i64*
  %56 = load i64, i64* %55
; # (mark (val P))
  call void @mark(i64 %56)
; # (shift P)
  %57 = inttoptr i64 %54 to i64*
  %58 = getelementptr i64, i64* %57, i32 1
  %59 = load i64, i64* %58
  br label %$14
$16:
  %60 = phi i64 [%52, %$14] ; # P
; # (let P (val $Bind) (while P (mark (val P)) (mark (val 2 P)) (setq...
; # (val $Bind)
  %61 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  %62 = load i64, i64* %61
; # (while P (mark (val P)) (mark (val 2 P)) (setq P (val 3 P)))
  br label %$17
$17:
  %63 = phi i64 [%62, %$16], [%73, %$18] ; # P
  %64 = icmp ne i64 %63, 0
  br i1 %64, label %$18, label %$19
$18:
  %65 = phi i64 [%63, %$17] ; # P
; # (val P)
  %66 = inttoptr i64 %65 to i64*
  %67 = load i64, i64* %66
; # (mark (val P))
  call void @mark(i64 %67)
; # (val 2 P)
  %68 = inttoptr i64 %65 to i64*
  %69 = getelementptr i64, i64* %68, i32 1
  %70 = load i64, i64* %69
; # (mark (val 2 P))
  call void @mark(i64 %70)
; # (val 3 P)
  %71 = inttoptr i64 %65 to i64*
  %72 = getelementptr i64, i64* %71, i32 2
  %73 = load i64, i64* %72
  br label %$17
$19:
  %74 = phi i64 [%63, %$17] ; # P
; # (let Ca (val $Catch) (while Ca (let Ca: (caFrame Ca) (when (Ca: t...
; # (val $Catch)
  %75 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 32) to i8**)
; # (while Ca (let Ca: (caFrame Ca) (when (Ca: tag) (mark @)) (mark (...
  br label %$20
$20:
  %76 = phi i8* [%75, %$19], [%111, %$24] ; # Ca
  %77 = icmp ne i8* %76, null
  br i1 %77, label %$21, label %$22
$21:
  %78 = phi i8* [%76, %$20] ; # Ca
; # (let Ca: (caFrame Ca) (when (Ca: tag) (mark @)) (mark (Ca: fin)) ...
; # (when (Ca: tag) (mark @))
; # (Ca: tag)
  %79 = getelementptr i8, i8* %78, i32 8
  %80 = ptrtoint i8* %79 to i64
  %81 = inttoptr i64 %80 to i64*
  %82 = load i64, i64* %81
  %83 = icmp ne i64 %82, 0
  br i1 %83, label %$23, label %$24
$23:
  %84 = phi i8* [%78, %$21] ; # Ca
; # (mark @)
  call void @mark(i64 %82)
  br label %$24
$24:
  %85 = phi i8* [%78, %$21], [%84, %$23] ; # Ca
; # (Ca: fin)
  %86 = getelementptr i8, i8* %78, i32 16
  %87 = ptrtoint i8* %86 to i64
  %88 = inttoptr i64 %87 to i64*
  %89 = load i64, i64* %88
; # (mark (Ca: fin))
  call void @mark(i64 %89)
; # (Ca: intrn)
  %90 = getelementptr i8, i8* %78, i32 32
  %91 = ptrtoint i8* %90 to i64
  %92 = inttoptr i64 %91 to i64*
  %93 = load i64, i64* %92
; # (mark (Ca: intrn))
  call void @mark(i64 %93)
; # (Ca: trns1)
  %94 = getelementptr i8, i8* %78, i32 40
  %95 = ptrtoint i8* %94 to i64
  %96 = inttoptr i64 %95 to i64*
  %97 = load i64, i64* %96
; # (mark (Ca: trns1))
  call void @mark(i64 %97)
; # (Ca: trns2)
  %98 = getelementptr i8, i8* %78, i32 48
  %99 = ptrtoint i8* %98 to i64
  %100 = inttoptr i64 %99 to i64*
  %101 = load i64, i64* %100
; # (mark (Ca: trns2))
  call void @mark(i64 %101)
; # (Ca: priv1)
  %102 = getelementptr i8, i8* %78, i32 56
  %103 = ptrtoint i8* %102 to i64
  %104 = inttoptr i64 %103 to i64*
  %105 = load i64, i64* %104
; # (mark (Ca: priv1))
  call void @mark(i64 %105)
; # (Ca: priv2)
  %106 = getelementptr i8, i8* %78, i32 64
  %107 = ptrtoint i8* %106 to i64
  %108 = inttoptr i64 %107 to i64*
  %109 = load i64, i64* %108
; # (mark (Ca: priv2))
  call void @mark(i64 %109)
; # (Ca: link)
  %110 = bitcast i8* %78 to i8**
  %111 = load i8*, i8** %110
  br label %$20
$22:
  %112 = phi i8* [%76, %$20] ; # Ca
; # (let Crt (val $Coroutines) (while Crt (let Crt: (coroutine Crt) (...
; # (val $Coroutines)
  %113 = load i8*, i8** @$Coroutines
; # (while Crt (let Crt: (coroutine Crt) (when (Crt: tag) (mark (Crt:...
  br label %$25
$25:
  %114 = phi i8* [%113, %$22], [%253, %$29] ; # Crt
  %115 = icmp ne i8* %114, null
  br i1 %115, label %$26, label %$27
$26:
  %116 = phi i8* [%114, %$25] ; # Crt
; # (let Crt: (coroutine Crt) (when (Crt: tag) (mark (Crt: tag)) (mar...
; # (when (Crt: tag) (mark (Crt: tag)) (mark (Crt: otg)) (mark (Crt: ...
; # (Crt: tag)
  %117 = ptrtoint i8* %116 to i64
  %118 = inttoptr i64 %117 to i64*
  %119 = load i64, i64* %118
  %120 = icmp ne i64 %119, 0
  br i1 %120, label %$28, label %$29
$28:
  %121 = phi i8* [%116, %$26] ; # Crt
; # (Crt: tag)
  %122 = ptrtoint i8* %116 to i64
  %123 = inttoptr i64 %122 to i64*
  %124 = load i64, i64* %123
; # (mark (Crt: tag))
  call void @mark(i64 %124)
; # (Crt: otg)
  %125 = getelementptr i8, i8* %116, i32 24
  %126 = ptrtoint i8* %125 to i64
  %127 = inttoptr i64 %126 to i64*
  %128 = load i64, i64* %127
; # (mark (Crt: otg))
  call void @mark(i64 %128)
; # (Crt: prg)
  %129 = getelementptr i8, i8* %116, i32 32
  %130 = ptrtoint i8* %129 to i64
  %131 = inttoptr i64 %130 to i64*
  %132 = load i64, i64* %131
; # (mark (Crt: prg))
  call void @mark(i64 %132)
; # (when (Crt: at) (mark (Crt: at)) (mark (Crt: intrn)) (mark (Crt: ...
; # (Crt: at)
  %133 = getelementptr i8, i8* %116, i32 48
  %134 = ptrtoint i8* %133 to i64
  %135 = inttoptr i64 %134 to i64*
  %136 = load i64, i64* %135
  %137 = icmp ne i64 %136, 0
  br i1 %137, label %$30, label %$31
$30:
  %138 = phi i8* [%121, %$28] ; # Crt
; # (Crt: at)
  %139 = getelementptr i8, i8* %116, i32 48
  %140 = ptrtoint i8* %139 to i64
  %141 = inttoptr i64 %140 to i64*
  %142 = load i64, i64* %141
; # (mark (Crt: at))
  call void @mark(i64 %142)
; # (Crt: intrn)
  %143 = getelementptr i8, i8* %116, i32 112
  %144 = ptrtoint i8* %143 to i64
  %145 = inttoptr i64 %144 to i64*
  %146 = load i64, i64* %145
; # (mark (Crt: intrn))
  call void @mark(i64 %146)
; # (Crt: trns1)
  %147 = getelementptr i8, i8* %116, i32 120
  %148 = ptrtoint i8* %147 to i64
  %149 = inttoptr i64 %148 to i64*
  %150 = load i64, i64* %149
; # (mark (Crt: trns1))
  call void @mark(i64 %150)
; # (Crt: trns2)
  %151 = getelementptr i8, i8* %116, i32 128
  %152 = ptrtoint i8* %151 to i64
  %153 = inttoptr i64 %152 to i64*
  %154 = load i64, i64* %153
; # (mark (Crt: trns2))
  call void @mark(i64 %154)
; # (Crt: priv1)
  %155 = getelementptr i8, i8* %116, i32 136
  %156 = ptrtoint i8* %155 to i64
  %157 = inttoptr i64 %156 to i64*
  %158 = load i64, i64* %157
; # (mark (Crt: priv1))
  call void @mark(i64 %158)
; # (Crt: priv2)
  %159 = getelementptr i8, i8* %116, i32 144
  %160 = ptrtoint i8* %159 to i64
  %161 = inttoptr i64 %160 to i64*
  %162 = load i64, i64* %161
; # (mark (Crt: priv2))
  call void @mark(i64 %162)
; # (let P (Crt: (env $Link any)) (while P (mark (val P)) (shift P)))...
; # (Crt: (env $Link any))
  %163 = getelementptr i8, i8* %116, i32 152
  %164 = ptrtoint i8* %163 to i64
  %165 = inttoptr i64 %164 to i64*
  %166 = load i64, i64* %165
; # (while P (mark (val P)) (shift P))
  br label %$32
$32:
  %167 = phi i8* [%138, %$30], [%170, %$33] ; # Crt
  %168 = phi i64 [%166, %$30], [%176, %$33] ; # P
  %169 = icmp ne i64 %168, 0
  br i1 %169, label %$33, label %$34
$33:
  %170 = phi i8* [%167, %$32] ; # Crt
  %171 = phi i64 [%168, %$32] ; # P
; # (val P)
  %172 = inttoptr i64 %171 to i64*
  %173 = load i64, i64* %172
; # (mark (val P))
  call void @mark(i64 %173)
; # (shift P)
  %174 = inttoptr i64 %171 to i64*
  %175 = getelementptr i64, i64* %174, i32 1
  %176 = load i64, i64* %175
  br label %$32
$34:
  %177 = phi i8* [%167, %$32] ; # Crt
  %178 = phi i64 [%168, %$32] ; # P
; # (let P (Crt: (env $Bind any)) (while P (mark (val P)) (mark (val ...
; # (Crt: (env $Bind any))
  %179 = getelementptr i8, i8* %116, i32 152
  %180 = getelementptr i8, i8* %179, i32 8
  %181 = ptrtoint i8* %180 to i64
  %182 = inttoptr i64 %181 to i64*
  %183 = load i64, i64* %182
; # (while P (mark (val P)) (mark (val 2 P)) (setq P (val 3 P)))
  br label %$35
$35:
  %184 = phi i8* [%177, %$34], [%187, %$36] ; # Crt
  %185 = phi i64 [%183, %$34], [%196, %$36] ; # P
  %186 = icmp ne i64 %185, 0
  br i1 %186, label %$36, label %$37
$36:
  %187 = phi i8* [%184, %$35] ; # Crt
  %188 = phi i64 [%185, %$35] ; # P
; # (val P)
  %189 = inttoptr i64 %188 to i64*
  %190 = load i64, i64* %189
; # (mark (val P))
  call void @mark(i64 %190)
; # (val 2 P)
  %191 = inttoptr i64 %188 to i64*
  %192 = getelementptr i64, i64* %191, i32 1
  %193 = load i64, i64* %192
; # (mark (val 2 P))
  call void @mark(i64 %193)
; # (val 3 P)
  %194 = inttoptr i64 %188 to i64*
  %195 = getelementptr i64, i64* %194, i32 2
  %196 = load i64, i64* %195
  br label %$35
$37:
  %197 = phi i8* [%184, %$35] ; # Crt
  %198 = phi i64 [%185, %$35] ; # P
; # (let Ca (Crt: (env $Catch i8*)) (while Ca (let Ca: (caFrame Ca) (...
; # (Crt: (env $Catch i8*))
  %199 = getelementptr i8, i8* %116, i32 152
  %200 = getelementptr i8, i8* %199, i32 32
  %201 = bitcast i8* %200 to i8**
  %202 = load i8*, i8** %201
; # (while Ca (let Ca: (caFrame Ca) (when (Ca: tag) (mark (Ca: tag)))...
  br label %$38
$38:
  %203 = phi i8* [%197, %$37], [%219, %$42] ; # Crt
  %204 = phi i8* [%202, %$37], [%246, %$42] ; # Ca
  %205 = icmp ne i8* %204, null
  br i1 %205, label %$39, label %$40
$39:
  %206 = phi i8* [%203, %$38] ; # Crt
  %207 = phi i8* [%204, %$38] ; # Ca
; # (let Ca: (caFrame Ca) (when (Ca: tag) (mark (Ca: tag))) (mark (Ca...
; # (when (Ca: tag) (mark (Ca: tag)))
; # (Ca: tag)
  %208 = getelementptr i8, i8* %207, i32 8
  %209 = ptrtoint i8* %208 to i64
  %210 = inttoptr i64 %209 to i64*
  %211 = load i64, i64* %210
  %212 = icmp ne i64 %211, 0
  br i1 %212, label %$41, label %$42
$41:
  %213 = phi i8* [%206, %$39] ; # Crt
  %214 = phi i8* [%207, %$39] ; # Ca
; # (Ca: tag)
  %215 = getelementptr i8, i8* %207, i32 8
  %216 = ptrtoint i8* %215 to i64
  %217 = inttoptr i64 %216 to i64*
  %218 = load i64, i64* %217
; # (mark (Ca: tag))
  call void @mark(i64 %218)
  br label %$42
$42:
  %219 = phi i8* [%206, %$39], [%213, %$41] ; # Crt
  %220 = phi i8* [%207, %$39], [%214, %$41] ; # Ca
; # (Ca: fin)
  %221 = getelementptr i8, i8* %207, i32 16
  %222 = ptrtoint i8* %221 to i64
  %223 = inttoptr i64 %222 to i64*
  %224 = load i64, i64* %223
; # (mark (Ca: fin))
  call void @mark(i64 %224)
; # (Ca: intrn)
  %225 = getelementptr i8, i8* %207, i32 32
  %226 = ptrtoint i8* %225 to i64
  %227 = inttoptr i64 %226 to i64*
  %228 = load i64, i64* %227
; # (mark (Ca: intrn))
  call void @mark(i64 %228)
; # (Ca: trns1)
  %229 = getelementptr i8, i8* %207, i32 40
  %230 = ptrtoint i8* %229 to i64
  %231 = inttoptr i64 %230 to i64*
  %232 = load i64, i64* %231
; # (mark (Ca: trns1))
  call void @mark(i64 %232)
; # (Ca: trns2)
  %233 = getelementptr i8, i8* %207, i32 48
  %234 = ptrtoint i8* %233 to i64
  %235 = inttoptr i64 %234 to i64*
  %236 = load i64, i64* %235
; # (mark (Ca: trns2))
  call void @mark(i64 %236)
; # (Ca: priv1)
  %237 = getelementptr i8, i8* %207, i32 56
  %238 = ptrtoint i8* %237 to i64
  %239 = inttoptr i64 %238 to i64*
  %240 = load i64, i64* %239
; # (mark (Ca: priv1))
  call void @mark(i64 %240)
; # (Ca: priv2)
  %241 = getelementptr i8, i8* %207, i32 64
  %242 = ptrtoint i8* %241 to i64
  %243 = inttoptr i64 %242 to i64*
  %244 = load i64, i64* %243
; # (mark (Ca: priv2))
  call void @mark(i64 %244)
; # (Ca: link)
  %245 = bitcast i8* %207 to i8**
  %246 = load i8*, i8** %245
  br label %$38
$40:
  %247 = phi i8* [%203, %$38] ; # Crt
  %248 = phi i8* [%204, %$38] ; # Ca
  br label %$31
$31:
  %249 = phi i8* [%121, %$28], [%247, %$40] ; # Crt
  br label %$29
$29:
  %250 = phi i8* [%116, %$26], [%249, %$31] ; # Crt
; # (Crt: nxt)
  %251 = getelementptr i8, i8* %116, i32 8
  %252 = bitcast i8* %251 to i8**
  %253 = load i8*, i8** %252
  br label %$25
$27:
  %254 = phi i8* [%114, %$25] ; # Crt
; # (let (Tos 0 P (val $Extern)) (loop (loop (let X (any (& (cdr P) -...
; # (val $Extern)
  %255 = load i64, i64* @$Extern
; # (loop (loop (let X (any (& (cdr P) -2)) (set 2 P X) (let Y (any (...
  br label %$43
$43:
  %256 = phi i64 [0, %$27], [%373, %$58] ; # Tos
  %257 = phi i64 [%255, %$27], [%374, %$58] ; # P
; # (loop (let X (any (& (cdr P) -2)) (set 2 P X) (let Y (any (& (cdr...
  br label %$44
$44:
  %258 = phi i64 [%256, %$43], [%275, %$45] ; # Tos
  %259 = phi i64 [%257, %$43], [%269, %$45] ; # P
; # (let X (any (& (cdr P) -2)) (set 2 P X) (let Y (any (& (cdr X) -2...
; # (cdr P)
  %260 = inttoptr i64 %259 to i64*
  %261 = getelementptr i64, i64* %260, i32 1
  %262 = load i64, i64* %261
; # (& (cdr P) -2)
  %263 = and i64 %262, -2
; # (any (& (cdr P) -2))
; # (set 2 P X)
  %264 = inttoptr i64 %259 to i64*
  %265 = getelementptr i64, i64* %264, i32 1
  store i64 %263, i64* %265
; # (let Y (any (& (cdr X) -2)) (set 2 X Y) (? (atom Y)) (let Z P (se...
; # (cdr X)
  %266 = inttoptr i64 %263 to i64*
  %267 = getelementptr i64, i64* %266, i32 1
  %268 = load i64, i64* %267
; # (& (cdr X) -2)
  %269 = and i64 %268, -2
; # (any (& (cdr X) -2))
; # (set 2 X Y)
  %270 = inttoptr i64 %263 to i64*
  %271 = getelementptr i64, i64* %270, i32 1
  store i64 %269, i64* %271
; # (? (atom Y))
; # (atom Y)
  %272 = and i64 %269, 15
  %273 = icmp ne i64 %272, 0
  br i1 %273, label %$46, label %$45
$45:
  %274 = phi i64 [%258, %$44] ; # Tos
  %275 = phi i64 [%259, %$44] ; # P
; # (let Z P (setq P Y) (set 2 X Tos) (setq Tos Z))
; # (set 2 X Tos)
  %276 = inttoptr i64 %263 to i64*
  %277 = getelementptr i64, i64* %276, i32 1
  store i64 %274, i64* %277
  br label %$44
$46:
  %278 = phi i64 [%258, %$44] ; # Tos
  %279 = phi i64 [%259, %$44] ; # P
  %280 = phi i64 [0, %$44] ; # ->
; # (loop (let S (val P) (when (& (val S) 1) (let Tail (val (tail S))...
  br label %$47
$47:
  %281 = phi i64 [%278, %$46], [%370, %$64] ; # Tos
  %282 = phi i64 [%279, %$46], [%371, %$64] ; # P
; # (let S (val P) (when (& (val S) 1) (let Tail (val (tail S)) (unle...
; # (val P)
  %283 = inttoptr i64 %282 to i64*
  %284 = load i64, i64* %283
; # (when (& (val S) 1) (let Tail (val (tail S)) (unless (num? Tail) ...
; # (val S)
  %285 = inttoptr i64 %284 to i64*
  %286 = load i64, i64* %285
; # (& (val S) 1)
  %287 = and i64 %286, 1
  %288 = icmp ne i64 %287, 0
  br i1 %288, label %$48, label %$49
$48:
  %289 = phi i64 [%281, %$47] ; # Tos
  %290 = phi i64 [%282, %$47] ; # P
; # (let Tail (val (tail S)) (unless (num? Tail) (setq Tail (& Tail -...
; # (tail S)
  %291 = add i64 %284, -8
; # (val (tail S))
  %292 = inttoptr i64 %291 to i64*
  %293 = load i64, i64* %292
; # (unless (num? Tail) (setq Tail (& Tail -10)) (until (num? (shift ...
; # (num? Tail)
  %294 = and i64 %293, 6
  %295 = icmp ne i64 %294, 0
  br i1 %295, label %$51, label %$50
$50:
  %296 = phi i64 [%289, %$48] ; # Tos
  %297 = phi i64 [%290, %$48] ; # P
  %298 = phi i64 [%293, %$48] ; # Tail
; # (& Tail -10)
  %299 = and i64 %298, -10
; # (until (num? (shift Tail)) (setq Tail (& Tail -2)))
  br label %$52
$52:
  %300 = phi i64 [%296, %$50], [%308, %$53] ; # Tos
  %301 = phi i64 [%297, %$50], [%309, %$53] ; # P
  %302 = phi i64 [%299, %$50], [%311, %$53] ; # Tail
; # (shift Tail)
  %303 = inttoptr i64 %302 to i64*
  %304 = getelementptr i64, i64* %303, i32 1
  %305 = load i64, i64* %304
; # (num? (shift Tail))
  %306 = and i64 %305, 6
  %307 = icmp ne i64 %306, 0
  br i1 %307, label %$54, label %$53
$53:
  %308 = phi i64 [%300, %$52] ; # Tos
  %309 = phi i64 [%301, %$52] ; # P
  %310 = phi i64 [%305, %$52] ; # Tail
; # (& Tail -2)
  %311 = and i64 %310, -2
  br label %$52
$54:
  %312 = phi i64 [%300, %$52] ; # Tos
  %313 = phi i64 [%301, %$52] ; # P
  %314 = phi i64 [%305, %$52] ; # Tail
  br label %$51
$51:
  %315 = phi i64 [%289, %$48], [%312, %$54] ; # Tos
  %316 = phi i64 [%290, %$48], [%313, %$54] ; # P
  %317 = phi i64 [%293, %$48], [%314, %$54] ; # Tail
; # (add Tail Tail)
  %318 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %317, i64 %317)
  %319 = extractvalue {i64, i1} %318, 1
  %320 = extractvalue {i64, i1} %318, 0
; # (when @@ (mark S))
  br i1 %319, label %$55, label %$56
$55:
  %321 = phi i64 [%315, %$51] ; # Tos
  %322 = phi i64 [%316, %$51] ; # P
  %323 = phi i64 [%317, %$51] ; # Tail
; # (mark S)
  call void @mark(i64 %284)
  br label %$56
$56:
  %324 = phi i64 [%315, %$51], [%321, %$55] ; # Tos
  %325 = phi i64 [%316, %$51], [%322, %$55] ; # P
  %326 = phi i64 [%317, %$51], [%323, %$55] ; # Tail
  br label %$49
$49:
  %327 = phi i64 [%281, %$47], [%324, %$56] ; # Tos
  %328 = phi i64 [%282, %$47], [%325, %$56] ; # P
; # (let X (cdr P) (? (pair (car X)) (let Z P (setq P @) (set X Tos) ...
; # (cdr P)
  %329 = inttoptr i64 %328 to i64*
  %330 = getelementptr i64, i64* %329, i32 1
  %331 = load i64, i64* %330
; # (? (pair (car X)) (let Z P (setq P @) (set X Tos) (setq Tos (| Z ...
; # (car X)
  %332 = inttoptr i64 %331 to i64*
  %333 = load i64, i64* %332
; # (pair (car X))
  %334 = and i64 %333, 15
  %335 = icmp eq i64 %334, 0
  br i1 %335, label %$59, label %$57
$59:
  %336 = phi i64 [%327, %$49] ; # Tos
  %337 = phi i64 [%328, %$49] ; # P
; # (let Z P (setq P @) (set X Tos) (setq Tos (| Z 8)))
; # (set X Tos)
  %338 = inttoptr i64 %331 to i64*
  store i64 %336, i64* %338
; # (| Z 8)
  %339 = or i64 %337, 8
  br label %$58
$57:
  %340 = phi i64 [%327, %$49] ; # Tos
  %341 = phi i64 [%328, %$49] ; # P
; # (loop (unless Tos (goto 1)) (? (=0 (& Tos 8)) (let (X Tos Y (cdr ...
  br label %$60
$60:
  %342 = phi i64 [%340, %$57], [%368, %$63] ; # Tos
  %343 = phi i64 [%341, %$57], [%363, %$63] ; # P
; # (unless Tos (goto 1))
  %344 = icmp ne i64 %342, 0
  br i1 %344, label %$62, label %$61
$61:
  %345 = phi i64 [%342, %$60] ; # Tos
  %346 = phi i64 [%343, %$60] ; # P
; # (goto 1)
  br label %$-1
$62:
  %347 = phi i64 [%342, %$60] ; # Tos
  %348 = phi i64 [%343, %$60] ; # P
; # (? (=0 (& Tos 8)) (let (X Tos Y (cdr X)) (setq Tos (cdr Y)) (set ...
; # (& Tos 8)
  %349 = and i64 %347, 8
; # (=0 (& Tos 8))
  %350 = icmp eq i64 %349, 0
  br i1 %350, label %$65, label %$63
$65:
  %351 = phi i64 [%347, %$62] ; # Tos
  %352 = phi i64 [%348, %$62] ; # P
; # (let (X Tos Y (cdr X)) (setq Tos (cdr Y)) (set 2 Y P) (setq P X))...
; # (cdr X)
  %353 = inttoptr i64 %351 to i64*
  %354 = getelementptr i64, i64* %353, i32 1
  %355 = load i64, i64* %354
; # (cdr Y)
  %356 = inttoptr i64 %355 to i64*
  %357 = getelementptr i64, i64* %356, i32 1
  %358 = load i64, i64* %357
; # (set 2 Y P)
  %359 = inttoptr i64 %355 to i64*
  %360 = getelementptr i64, i64* %359, i32 1
  store i64 %352, i64* %360
  br label %$64
$63:
  %361 = phi i64 [%347, %$62] ; # Tos
  %362 = phi i64 [%348, %$62] ; # P
; # (& Tos -9)
  %363 = and i64 %361, -9
; # (let (X Tos Y (cdr X)) (setq Tos (car Y)) (set Y P) (setq P X))
; # (cdr X)
  %364 = inttoptr i64 %363 to i64*
  %365 = getelementptr i64, i64* %364, i32 1
  %366 = load i64, i64* %365
; # (car Y)
  %367 = inttoptr i64 %366 to i64*
  %368 = load i64, i64* %367
; # (set Y P)
  %369 = inttoptr i64 %366 to i64*
  store i64 %362, i64* %369
  br label %$60
$64:
  %370 = phi i64 [%358, %$65] ; # Tos
  %371 = phi i64 [%351, %$65] ; # P
  %372 = phi i64 [%351, %$65] ; # ->
  br label %$47
$58:
  %373 = phi i64 [%339, %$59] ; # Tos
  %374 = phi i64 [%333, %$59] ; # P
  %375 = phi i64 [%339, %$59] ; # ->
  br label %$43
$66:
; # (: 1 (when (val $DBs) (set $DB $Db1)) (when (& (val $Db1) 1) (set...
  br label %$-1
$-1:
; # (when (val $DBs) (set $DB $Db1))
; # (val $DBs)
  %376 = load i32, i32* @$DBs
  %377 = icmp ne i32 %376, 0
  br i1 %377, label %$67, label %$68
$67:
; # (set $DB $Db1)
  %378 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 232) to i64) to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 408) to i64), i64* %378
  br label %$68
$68:
; # (when (& (val $Db1) 1) (set $Db1 $Nil (tail $Db1) DB1))
; # (val $Db1)
  %379 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 408) to i64) to i64*
  %380 = load i64, i64* %379
; # (& (val $Db1) 1)
  %381 = and i64 %380, 1
  %382 = icmp ne i64 %381, 0
  br i1 %382, label %$69, label %$70
$69:
; # (set $Db1 $Nil (tail $Db1) DB1)
  %383 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 408) to i64) to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %383
; # (tail $Db1)
  %384 = add i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 408) to i64), -8
  %385 = inttoptr i64 %384 to i64*
  store i64 26, i64* %385
  br label %$70
$70:
; # (let (Tos 0 P (val $Extern)) (: 2 (loop (loop (let X (cdr P) (? (...
; # (val $Extern)
  %386 = load i64, i64* @$Extern
; # (: 2 (loop (loop (let X (cdr P) (? (atom (cdr X))) (let Z P (setq...
  br label %$-2
$-2:
  %387 = phi i64 [0, %$70], [%458, %$82] ; # Tos
  %388 = phi i64 [%386, %$70], [%465, %$82] ; # P
; # (loop (loop (let X (cdr P) (? (atom (cdr X))) (let Z P (setq P @)...
  br label %$71
$71:
  %389 = phi i64 [%387, %$-2], [%593, %$91] ; # Tos
  %390 = phi i64 [%388, %$-2], [%594, %$91] ; # P
; # (loop (let X (cdr P) (? (atom (cdr X))) (let Z P (setq P @) (set ...
  br label %$72
$72:
  %391 = phi i64 [%389, %$71], [%402, %$73] ; # Tos
  %392 = phi i64 [%390, %$71], [%398, %$73] ; # P
; # (let X (cdr P) (? (atom (cdr X))) (let Z P (setq P @) (set 2 X To...
; # (cdr P)
  %393 = inttoptr i64 %392 to i64*
  %394 = getelementptr i64, i64* %393, i32 1
  %395 = load i64, i64* %394
; # (? (atom (cdr X)))
; # (cdr X)
  %396 = inttoptr i64 %395 to i64*
  %397 = getelementptr i64, i64* %396, i32 1
  %398 = load i64, i64* %397
; # (atom (cdr X))
  %399 = and i64 %398, 15
  %400 = icmp ne i64 %399, 0
  br i1 %400, label %$74, label %$73
$73:
  %401 = phi i64 [%391, %$72] ; # Tos
  %402 = phi i64 [%392, %$72] ; # P
; # (let Z P (setq P @) (set 2 X Tos) (setq Tos Z))
; # (set 2 X Tos)
  %403 = inttoptr i64 %395 to i64*
  %404 = getelementptr i64, i64* %403, i32 1
  store i64 %401, i64* %404
  br label %$72
$74:
  %405 = phi i64 [%391, %$72] ; # Tos
  %406 = phi i64 [%392, %$72] ; # P
  %407 = phi i64 [0, %$72] ; # ->
; # (loop (when (& (val (val P)) 1) (set $ExtCnt (- (val $ExtCnt) 1))...
  br label %$75
$75:
  %408 = phi i64 [%405, %$74], [%590, %$97] ; # Tos
  %409 = phi i64 [%406, %$74], [%591, %$97] ; # P
; # (when (& (val (val P)) 1) (set $ExtCnt (- (val $ExtCnt) 1)) (let ...
; # (val P)
  %410 = inttoptr i64 %409 to i64*
  %411 = load i64, i64* %410
; # (val (val P))
  %412 = inttoptr i64 %411 to i64*
  %413 = load i64, i64* %412
; # (& (val (val P)) 1)
  %414 = and i64 %413, 1
  %415 = icmp ne i64 %414, 0
  br i1 %415, label %$76, label %$77
$76:
  %416 = phi i64 [%408, %$75] ; # Tos
  %417 = phi i64 [%409, %$75] ; # P
; # (set $ExtCnt (- (val $ExtCnt) 1))
; # (val $ExtCnt)
  %418 = load i64, i64* @$ExtCnt
; # (- (val $ExtCnt) 1)
  %419 = sub i64 %418, 1
  store i64 %419, i64* @$ExtCnt
; # (let X (cdr P) (when (atom X) (set 2 P (| X 1)) (setq P X) (goto ...
; # (cdr P)
  %420 = inttoptr i64 %417 to i64*
  %421 = getelementptr i64, i64* %420, i32 1
  %422 = load i64, i64* %421
; # (when (atom X) (set 2 P (| X 1)) (setq P X) (goto 4))
; # (atom X)
  %423 = and i64 %422, 15
  %424 = icmp ne i64 %423, 0
  br i1 %424, label %$78, label %$79
$78:
  %425 = phi i64 [%416, %$76] ; # Tos
  %426 = phi i64 [%417, %$76] ; # P
  %427 = phi i64 [%422, %$76] ; # X
; # (set 2 P (| X 1))
; # (| X 1)
  %428 = or i64 %427, 1
  %429 = inttoptr i64 %426 to i64*
  %430 = getelementptr i64, i64* %429, i32 1
  store i64 %428, i64* %430
; # (goto 4)
  br label %$-4
$79:
  %431 = phi i64 [%416, %$76] ; # Tos
  %432 = phi i64 [%417, %$76] ; # P
  %433 = phi i64 [%422, %$76] ; # X
; # (when (atom (car X)) (set 2 P (| X 1)) (setq P (cdr X)) (set 2 X ...
; # (car X)
  %434 = inttoptr i64 %433 to i64*
  %435 = load i64, i64* %434
; # (atom (car X))
  %436 = and i64 %435, 15
  %437 = icmp ne i64 %436, 0
  br i1 %437, label %$80, label %$81
$80:
  %438 = phi i64 [%431, %$79] ; # Tos
  %439 = phi i64 [%432, %$79] ; # P
  %440 = phi i64 [%433, %$79] ; # X
; # (set 2 P (| X 1))
; # (| X 1)
  %441 = or i64 %440, 1
  %442 = inttoptr i64 %439 to i64*
  %443 = getelementptr i64, i64* %442, i32 1
  store i64 %441, i64* %443
; # (cdr X)
  %444 = inttoptr i64 %440 to i64*
  %445 = getelementptr i64, i64* %444, i32 1
  %446 = load i64, i64* %445
; # (set 2 X (| P 1))
; # (| P 1)
  %447 = or i64 %446, 1
  %448 = inttoptr i64 %440 to i64*
  %449 = getelementptr i64, i64* %448, i32 1
  store i64 %447, i64* %449
; # (goto 4)
  br label %$-4
$81:
  %450 = phi i64 [%431, %$79] ; # Tos
  %451 = phi i64 [%432, %$79] ; # P
  %452 = phi i64 [%433, %$79] ; # X
; # (when (atom (cdr X)) (set 2 P (| X 1)) (setq P (car X)) (set 2 X ...
; # (cdr X)
  %453 = inttoptr i64 %452 to i64*
  %454 = getelementptr i64, i64* %453, i32 1
  %455 = load i64, i64* %454
; # (atom (cdr X))
  %456 = and i64 %455, 15
  %457 = icmp ne i64 %456, 0
  br i1 %457, label %$82, label %$83
$82:
  %458 = phi i64 [%450, %$81] ; # Tos
  %459 = phi i64 [%451, %$81] ; # P
  %460 = phi i64 [%452, %$81] ; # X
; # (set 2 P (| X 1))
; # (| X 1)
  %461 = or i64 %460, 1
  %462 = inttoptr i64 %459 to i64*
  %463 = getelementptr i64, i64* %462, i32 1
  store i64 %461, i64* %463
; # (car X)
  %464 = inttoptr i64 %460 to i64*
  %465 = load i64, i64* %464
; # (set 2 X (| (cdr X) 1))
; # (cdr X)
  %466 = inttoptr i64 %460 to i64*
  %467 = getelementptr i64, i64* %466, i32 1
  %468 = load i64, i64* %467
; # (| (cdr X) 1)
  %469 = or i64 %468, 1
  %470 = inttoptr i64 %460 to i64*
  %471 = getelementptr i64, i64* %470, i32 1
  store i64 %469, i64* %471
; # (goto 2)
  br label %$-2
$83:
  %472 = phi i64 [%450, %$81] ; # Tos
  %473 = phi i64 [%451, %$81] ; # P
  %474 = phi i64 [%452, %$81] ; # X
; # (let Y (cdr (shift X)) (when (atom (car Y)) (set P (car X) 2 (cdr...
; # (shift X)
  %475 = inttoptr i64 %474 to i64*
  %476 = getelementptr i64, i64* %475, i32 1
  %477 = load i64, i64* %476
; # (cdr (shift X))
  %478 = inttoptr i64 %477 to i64*
  %479 = getelementptr i64, i64* %478, i32 1
  %480 = load i64, i64* %479
; # (when (atom (car Y)) (set P (car X) 2 (cdr P) (cdr Y)) (goto 3))
; # (car Y)
  %481 = inttoptr i64 %480 to i64*
  %482 = load i64, i64* %481
; # (atom (car Y))
  %483 = and i64 %482, 15
  %484 = icmp ne i64 %483, 0
  br i1 %484, label %$84, label %$85
$84:
  %485 = phi i64 [%472, %$83] ; # Tos
  %486 = phi i64 [%473, %$83] ; # P
  %487 = phi i64 [%477, %$83] ; # X
  %488 = phi i64 [%480, %$83] ; # Y
; # (set P (car X) 2 (cdr P) (cdr Y))
; # (car X)
  %489 = inttoptr i64 %487 to i64*
  %490 = load i64, i64* %489
  %491 = inttoptr i64 %486 to i64*
  store i64 %490, i64* %491
; # (cdr P)
  %492 = inttoptr i64 %486 to i64*
  %493 = getelementptr i64, i64* %492, i32 1
  %494 = load i64, i64* %493
; # (cdr Y)
  %495 = inttoptr i64 %488 to i64*
  %496 = getelementptr i64, i64* %495, i32 1
  %497 = load i64, i64* %496
  %498 = inttoptr i64 %494 to i64*
  %499 = getelementptr i64, i64* %498, i32 1
  store i64 %497, i64* %499
; # (goto 3)
  br label %$-3
$85:
  %500 = phi i64 [%472, %$83] ; # Tos
  %501 = phi i64 [%473, %$83] ; # P
  %502 = phi i64 [%477, %$83] ; # X
  %503 = phi i64 [%480, %$83] ; # Y
; # (car Y)
  %504 = inttoptr i64 %503 to i64*
  %505 = load i64, i64* %504
; # (loop (? (atom (cadr Y)) (set P (car Y) (cdr X) (cddr Y))) (setq ...
  br label %$86
$86:
  %506 = phi i64 [%500, %$85], [%534, %$87] ; # Tos
  %507 = phi i64 [%501, %$85], [%535, %$87] ; # P
  %508 = phi i64 [%502, %$85], [%537, %$87] ; # X
  %509 = phi i64 [%505, %$85], [%514, %$87] ; # Y
; # (? (atom (cadr Y)) (set P (car Y) (cdr X) (cddr Y)))
; # (cadr Y)
  %510 = inttoptr i64 %509 to i64*
  %511 = getelementptr i64, i64* %510, i32 1
  %512 = load i64, i64* %511
  %513 = inttoptr i64 %512 to i64*
  %514 = load i64, i64* %513
; # (atom (cadr Y))
  %515 = and i64 %514, 15
  %516 = icmp ne i64 %515, 0
  br i1 %516, label %$89, label %$87
$89:
  %517 = phi i64 [%506, %$86] ; # Tos
  %518 = phi i64 [%507, %$86] ; # P
  %519 = phi i64 [%508, %$86] ; # X
  %520 = phi i64 [%509, %$86] ; # Y
; # (set P (car Y) (cdr X) (cddr Y))
; # (car Y)
  %521 = inttoptr i64 %520 to i64*
  %522 = load i64, i64* %521
  %523 = inttoptr i64 %518 to i64*
  store i64 %522, i64* %523
; # (cdr X)
  %524 = inttoptr i64 %519 to i64*
  %525 = getelementptr i64, i64* %524, i32 1
  %526 = load i64, i64* %525
; # (cddr Y)
  %527 = inttoptr i64 %520 to i64*
  %528 = getelementptr i64, i64* %527, i32 1
  %529 = load i64, i64* %528
  %530 = inttoptr i64 %529 to i64*
  %531 = getelementptr i64, i64* %530, i32 1
  %532 = load i64, i64* %531
  %533 = inttoptr i64 %526 to i64*
  store i64 %532, i64* %533
  br label %$88
$87:
  %534 = phi i64 [%506, %$86] ; # Tos
  %535 = phi i64 [%507, %$86] ; # P
  %536 = phi i64 [%508, %$86] ; # X
  %537 = phi i64 [%509, %$86] ; # Y
  br label %$86
$88:
  %538 = phi i64 [%517, %$89] ; # Tos
  %539 = phi i64 [%518, %$89] ; # P
  %540 = phi i64 [%519, %$89] ; # X
  %541 = phi i64 [%520, %$89] ; # Y
  %542 = phi i64 [%532, %$89] ; # ->
  br label %$77
$77:
  %543 = phi i64 [%408, %$75], [%538, %$88] ; # Tos
  %544 = phi i64 [%409, %$75], [%539, %$88] ; # P
; # (: 3 (let X (cdr P) (? (pair (car X)) (let Z P (setq P @) (set X ...
  br label %$-3
$-3:
  %545 = phi i64 [%485, %$84], [%543, %$77] ; # Tos
  %546 = phi i64 [%486, %$84], [%544, %$77] ; # P
; # (let X (cdr P) (? (pair (car X)) (let Z P (setq P @) (set X Tos) ...
; # (cdr P)
  %547 = inttoptr i64 %546 to i64*
  %548 = getelementptr i64, i64* %547, i32 1
  %549 = load i64, i64* %548
; # (? (pair (car X)) (let Z P (setq P @) (set X Tos) (setq Tos (| Z ...
; # (car X)
  %550 = inttoptr i64 %549 to i64*
  %551 = load i64, i64* %550
; # (pair (car X))
  %552 = and i64 %551, 15
  %553 = icmp eq i64 %552, 0
  br i1 %553, label %$92, label %$90
$92:
  %554 = phi i64 [%545, %$-3] ; # Tos
  %555 = phi i64 [%546, %$-3] ; # P
; # (let Z P (setq P @) (set X Tos) (setq Tos (| Z 8)))
; # (set X Tos)
  %556 = inttoptr i64 %549 to i64*
  store i64 %554, i64* %556
; # (| Z 8)
  %557 = or i64 %555, 8
  br label %$91
$90:
  %558 = phi i64 [%545, %$-3] ; # Tos
  %559 = phi i64 [%546, %$-3] ; # P
; # (: 4 (loop (unless Tos (goto 5)) (? (=0 (& Tos 8)) (let (X Tos Y ...
  br label %$-4
$-4:
  %560 = phi i64 [%425, %$78], [%438, %$80], [%558, %$90] ; # Tos
  %561 = phi i64 [%427, %$78], [%446, %$80], [%559, %$90] ; # P
; # (loop (unless Tos (goto 5)) (? (=0 (& Tos 8)) (let (X Tos Y (cdr ...
  br label %$93
$93:
  %562 = phi i64 [%560, %$-4], [%588, %$96] ; # Tos
  %563 = phi i64 [%561, %$-4], [%583, %$96] ; # P
; # (unless Tos (goto 5))
  %564 = icmp ne i64 %562, 0
  br i1 %564, label %$95, label %$94
$94:
  %565 = phi i64 [%562, %$93] ; # Tos
  %566 = phi i64 [%563, %$93] ; # P
; # (goto 5)
  br label %$-5
$95:
  %567 = phi i64 [%562, %$93] ; # Tos
  %568 = phi i64 [%563, %$93] ; # P
; # (? (=0 (& Tos 8)) (let (X Tos Y (cdr X)) (setq Tos (cdr Y)) (set ...
; # (& Tos 8)
  %569 = and i64 %567, 8
; # (=0 (& Tos 8))
  %570 = icmp eq i64 %569, 0
  br i1 %570, label %$98, label %$96
$98:
  %571 = phi i64 [%567, %$95] ; # Tos
  %572 = phi i64 [%568, %$95] ; # P
; # (let (X Tos Y (cdr X)) (setq Tos (cdr Y)) (set 2 Y P) (setq P X))...
; # (cdr X)
  %573 = inttoptr i64 %571 to i64*
  %574 = getelementptr i64, i64* %573, i32 1
  %575 = load i64, i64* %574
; # (cdr Y)
  %576 = inttoptr i64 %575 to i64*
  %577 = getelementptr i64, i64* %576, i32 1
  %578 = load i64, i64* %577
; # (set 2 Y P)
  %579 = inttoptr i64 %575 to i64*
  %580 = getelementptr i64, i64* %579, i32 1
  store i64 %572, i64* %580
  br label %$97
$96:
  %581 = phi i64 [%567, %$95] ; # Tos
  %582 = phi i64 [%568, %$95] ; # P
; # (let (X (& Tos -9) Y (cdr X)) (setq Tos (car Y)) (set Y P) (setq ...
; # (& Tos -9)
  %583 = and i64 %581, -9
; # (cdr X)
  %584 = inttoptr i64 %583 to i64*
  %585 = getelementptr i64, i64* %584, i32 1
  %586 = load i64, i64* %585
; # (car Y)
  %587 = inttoptr i64 %586 to i64*
  %588 = load i64, i64* %587
; # (set Y P)
  %589 = inttoptr i64 %586 to i64*
  store i64 %582, i64* %589
  br label %$93
$97:
  %590 = phi i64 [%578, %$98] ; # Tos
  %591 = phi i64 [%571, %$98] ; # P
  %592 = phi i64 [%571, %$98] ; # ->
  br label %$75
$91:
  %593 = phi i64 [%557, %$92] ; # Tos
  %594 = phi i64 [%551, %$92] ; # P
  %595 = phi i64 [%557, %$92] ; # ->
  br label %$71
$99:
; # (: 5 (set $Extern P))
  br label %$-5
$-5:
  %596 = phi i64 [%565, %$94], [%593, %$99] ; # Tos
  %597 = phi i64 [%566, %$94], [%594, %$99] ; # P
; # (set $Extern P)
  store i64 %597, i64* @$Extern
; # (let (Avail 0 Heap (val $Heaps) Cnt (val $GcCount)) (ifn Cnt (let...
; # (val $Heaps)
  %598 = load i64, i64* @$Heaps
; # (val $GcCount)
  %599 = load i64, i64* @$GcCount
; # (ifn Cnt (let H (any $Heaps) (loop (let (A Avail P (ofs Heap (- H...
  %600 = icmp ne i64 %599, 0
  br i1 %600, label %$101, label %$100
$100:
  %601 = phi i64 [0, %$-5] ; # Avail
  %602 = phi i64 [%598, %$-5] ; # Heap
  %603 = phi i64 [%599, %$-5] ; # Cnt
; # (let H (any $Heaps) (loop (let (A Avail P (ofs Heap (- HEAP 2))) ...
; # (any $Heaps)
  %604 = ptrtoint i64* @$Heaps to i64
; # (loop (let (A Avail P (ofs Heap (- HEAP 2))) (setq Cnt CELLS) (lo...
  br label %$103
$103:
  %605 = phi i64 [%601, %$100], [%673, %$112] ; # Avail
  %606 = phi i64 [%602, %$100], [%674, %$112] ; # Heap
  %607 = phi i64 [%603, %$100], [%675, %$112] ; # Cnt
  %608 = phi i64 [%604, %$100], [%676, %$112] ; # H
; # (let (A Avail P (ofs Heap (- HEAP 2))) (setq Cnt CELLS) (loop (wh...
; # (- HEAP 2)
; # (ofs Heap (- HEAP 2))
  %609 = add i64 %606, 1048560
; # (loop (when (& (cdr P) 1) (set P Avail) (setq Avail P) (dec 'Cnt)...
  br label %$104
$104:
  %610 = phi i64 [%605, %$103], [%633, %$107] ; # Avail
  %611 = phi i64 [%606, %$103], [%634, %$107] ; # Heap
  %612 = phi i64 [65536, %$103], [%635, %$107] ; # Cnt
  %613 = phi i64 [%608, %$103], [%636, %$107] ; # H
  %614 = phi i64 [%609, %$103], [%638, %$107] ; # P
; # (when (& (cdr P) 1) (set P Avail) (setq Avail P) (dec 'Cnt))
; # (cdr P)
  %615 = inttoptr i64 %614 to i64*
  %616 = getelementptr i64, i64* %615, i32 1
  %617 = load i64, i64* %616
; # (& (cdr P) 1)
  %618 = and i64 %617, 1
  %619 = icmp ne i64 %618, 0
  br i1 %619, label %$105, label %$106
$105:
  %620 = phi i64 [%610, %$104] ; # Avail
  %621 = phi i64 [%611, %$104] ; # Heap
  %622 = phi i64 [%612, %$104] ; # Cnt
  %623 = phi i64 [%613, %$104] ; # H
  %624 = phi i64 [%614, %$104] ; # P
; # (set P Avail)
  %625 = inttoptr i64 %624 to i64*
  store i64 %620, i64* %625
; # (dec 'Cnt)
  %626 = sub i64 %622, 1
  br label %$106
$106:
  %627 = phi i64 [%610, %$104], [%624, %$105] ; # Avail
  %628 = phi i64 [%611, %$104], [%621, %$105] ; # Heap
  %629 = phi i64 [%612, %$104], [%626, %$105] ; # Cnt
  %630 = phi i64 [%613, %$104], [%623, %$105] ; # H
  %631 = phi i64 [%614, %$104], [%624, %$105] ; # P
; # (? (== P Heap))
; # (== P Heap)
  %632 = icmp eq i64 %631, %628
  br i1 %632, label %$108, label %$107
$107:
  %633 = phi i64 [%627, %$106] ; # Avail
  %634 = phi i64 [%628, %$106] ; # Heap
  %635 = phi i64 [%629, %$106] ; # Cnt
  %636 = phi i64 [%630, %$106] ; # H
  %637 = phi i64 [%631, %$106] ; # P
; # (ofs P -2)
  %638 = add i64 %637, -16
  br label %$104
$108:
  %639 = phi i64 [%627, %$106] ; # Avail
  %640 = phi i64 [%628, %$106] ; # Heap
  %641 = phi i64 [%629, %$106] ; # Cnt
  %642 = phi i64 [%630, %$106] ; # H
  %643 = phi i64 [%631, %$106] ; # P
  %644 = phi i64 [0, %$106] ; # ->
; # (if Cnt (setq Heap (val (setq H (ofs Heap HEAP)))) (setq Avail A ...
  %645 = icmp ne i64 %641, 0
  br i1 %645, label %$109, label %$110
$109:
  %646 = phi i64 [%639, %$108] ; # Avail
  %647 = phi i64 [%640, %$108] ; # Heap
  %648 = phi i64 [%641, %$108] ; # Cnt
  %649 = phi i64 [%642, %$108] ; # H
  %650 = phi i64 [%643, %$108] ; # P
; # (ofs Heap HEAP)
  %651 = add i64 %647, 1048576
; # (val (setq H (ofs Heap HEAP)))
  %652 = inttoptr i64 %651 to i64*
  %653 = load i64, i64* %652
  br label %$111
$110:
  %654 = phi i64 [%639, %$108] ; # Avail
  %655 = phi i64 [%640, %$108] ; # Heap
  %656 = phi i64 [%641, %$108] ; # Cnt
  %657 = phi i64 [%642, %$108] ; # H
  %658 = phi i64 [%643, %$108] ; # P
; # (inc HEAP)
; # (val (inc HEAP) Heap)
  %659 = inttoptr i64 %655 to i64*
  %660 = getelementptr i64, i64* %659, i32 131072
  %661 = load i64, i64* %660
; # (val H)
  %662 = inttoptr i64 %657 to i64*
  %663 = load i64, i64* %662
; # (i8* (val H))
  %664 = inttoptr i64 %663 to i8*
; # (free (i8* (val H)))
  call void @free(i8* %664)
; # (set H Heap)
  %665 = inttoptr i64 %657 to i64*
  store i64 %661, i64* %665
  br label %$111
$111:
  %666 = phi i64 [%646, %$109], [%605, %$110] ; # Avail
  %667 = phi i64 [%653, %$109], [%661, %$110] ; # Heap
  %668 = phi i64 [%648, %$109], [%656, %$110] ; # Cnt
  %669 = phi i64 [%651, %$109], [%657, %$110] ; # H
  %670 = phi i64 [%650, %$109], [%658, %$110] ; # P
  %671 = phi i64 [%653, %$109], [%661, %$110] ; # ->
; # (? (=0 Heap))
; # (=0 Heap)
  %672 = icmp eq i64 %667, 0
  br i1 %672, label %$113, label %$112
$112:
  %673 = phi i64 [%666, %$111] ; # Avail
  %674 = phi i64 [%667, %$111] ; # Heap
  %675 = phi i64 [%668, %$111] ; # Cnt
  %676 = phi i64 [%669, %$111] ; # H
  br label %$103
$113:
  %677 = phi i64 [%666, %$111] ; # Avail
  %678 = phi i64 [%667, %$111] ; # Heap
  %679 = phi i64 [%668, %$111] ; # Cnt
  %680 = phi i64 [%669, %$111] ; # H
  %681 = phi i64 [0, %$111] ; # ->
; # (set $Avail Avail)
  store i64 %677, i64* @$Avail
  br label %$102
$101:
  %682 = phi i64 [0, %$-5] ; # Avail
  %683 = phi i64 [%598, %$-5] ; # Heap
  %684 = phi i64 [%599, %$-5] ; # Cnt
; # (loop (let P (ofs Heap (- HEAP 2)) (loop (when (& (cdr P) 1) (set...
  br label %$114
$114:
  %685 = phi i64 [%682, %$101], [%723, %$120] ; # Avail
  %686 = phi i64 [%683, %$101], [%724, %$120] ; # Heap
  %687 = phi i64 [%684, %$101], [%725, %$120] ; # Cnt
; # (let P (ofs Heap (- HEAP 2)) (loop (when (& (cdr P) 1) (set P Ava...
; # (- HEAP 2)
; # (ofs Heap (- HEAP 2))
  %688 = add i64 %686, 1048560
; # (loop (when (& (cdr P) 1) (set P Avail) (setq Avail P) (dec 'Cnt)...
  br label %$115
$115:
  %689 = phi i64 [%685, %$114], [%709, %$118] ; # Avail
  %690 = phi i64 [%686, %$114], [%710, %$118] ; # Heap
  %691 = phi i64 [%687, %$114], [%711, %$118] ; # Cnt
  %692 = phi i64 [%688, %$114], [%713, %$118] ; # P
; # (when (& (cdr P) 1) (set P Avail) (setq Avail P) (dec 'Cnt))
; # (cdr P)
  %693 = inttoptr i64 %692 to i64*
  %694 = getelementptr i64, i64* %693, i32 1
  %695 = load i64, i64* %694
; # (& (cdr P) 1)
  %696 = and i64 %695, 1
  %697 = icmp ne i64 %696, 0
  br i1 %697, label %$116, label %$117
$116:
  %698 = phi i64 [%689, %$115] ; # Avail
  %699 = phi i64 [%690, %$115] ; # Heap
  %700 = phi i64 [%691, %$115] ; # Cnt
  %701 = phi i64 [%692, %$115] ; # P
; # (set P Avail)
  %702 = inttoptr i64 %701 to i64*
  store i64 %698, i64* %702
; # (dec 'Cnt)
  %703 = sub i64 %700, 1
  br label %$117
$117:
  %704 = phi i64 [%689, %$115], [%701, %$116] ; # Avail
  %705 = phi i64 [%690, %$115], [%699, %$116] ; # Heap
  %706 = phi i64 [%691, %$115], [%703, %$116] ; # Cnt
  %707 = phi i64 [%692, %$115], [%701, %$116] ; # P
; # (? (== P Heap))
; # (== P Heap)
  %708 = icmp eq i64 %707, %705
  br i1 %708, label %$119, label %$118
$118:
  %709 = phi i64 [%704, %$117] ; # Avail
  %710 = phi i64 [%705, %$117] ; # Heap
  %711 = phi i64 [%706, %$117] ; # Cnt
  %712 = phi i64 [%707, %$117] ; # P
; # (ofs P -2)
  %713 = add i64 %712, -16
  br label %$115
$119:
  %714 = phi i64 [%704, %$117] ; # Avail
  %715 = phi i64 [%705, %$117] ; # Heap
  %716 = phi i64 [%706, %$117] ; # Cnt
  %717 = phi i64 [%707, %$117] ; # P
  %718 = phi i64 [0, %$117] ; # ->
; # (? (=0 (setq Heap (val (inc HEAP) Heap))))
; # (inc HEAP)
; # (val (inc HEAP) Heap)
  %719 = inttoptr i64 %715 to i64*
  %720 = getelementptr i64, i64* %719, i32 131072
  %721 = load i64, i64* %720
; # (=0 (setq Heap (val (inc HEAP) Heap)))
  %722 = icmp eq i64 %721, 0
  br i1 %722, label %$121, label %$120
$120:
  %723 = phi i64 [%714, %$119] ; # Avail
  %724 = phi i64 [%721, %$119] ; # Heap
  %725 = phi i64 [%716, %$119] ; # Cnt
  br label %$114
$121:
  %726 = phi i64 [%714, %$119] ; # Avail
  %727 = phi i64 [%721, %$119] ; # Heap
  %728 = phi i64 [%716, %$119] ; # Cnt
  %729 = phi i64 [0, %$119] ; # ->
; # (set $Avail Avail)
  store i64 %726, i64* @$Avail
; # (while (ge0 Cnt) (heapAlloc) (dec 'Cnt CELLS))
  br label %$122
$122:
  %730 = phi i64 [%726, %$121], [%734, %$123] ; # Avail
  %731 = phi i64 [%727, %$121], [%735, %$123] ; # Heap
  %732 = phi i64 [%728, %$121], [%737, %$123] ; # Cnt
; # (ge0 Cnt)
  %733 = icmp sge i64 %732, 0
  br i1 %733, label %$123, label %$124
$123:
  %734 = phi i64 [%730, %$122] ; # Avail
  %735 = phi i64 [%731, %$122] ; # Heap
  %736 = phi i64 [%732, %$122] ; # Cnt
; # (heapAlloc)
  call void @heapAlloc()
; # (dec 'Cnt CELLS)
  %737 = sub i64 %736, 65536
  br label %$122
$124:
  %738 = phi i64 [%730, %$122] ; # Avail
  %739 = phi i64 [%731, %$122] ; # Heap
  %740 = phi i64 [%732, %$122] ; # Cnt
  br label %$102
$102:
  %741 = phi i64 [%677, %$113], [%738, %$124] ; # Avail
  %742 = phi i64 [%678, %$113], [%739, %$124] ; # Heap
  %743 = phi i64 [%679, %$113], [%740, %$124] ; # Cnt
  ret void
}

define void @need3() align 8 {
$1:
; # (let P (val $Avail) (unless (and P (setq P (car P)) (car P)) (gc)...
; # (val $Avail)
  %0 = load i64, i64* @$Avail
; # (unless (and P (setq P (car P)) (car P)) (gc))
; # (and P (setq P (car P)) (car P))
  %1 = icmp ne i64 %0, 0
  br i1 %1, label %$3, label %$2
$3:
  %2 = phi i64 [%0, %$1] ; # P
; # (car P)
  %3 = inttoptr i64 %2 to i64*
  %4 = load i64, i64* %3
  %5 = icmp ne i64 %4, 0
  br i1 %5, label %$4, label %$2
$4:
  %6 = phi i64 [%4, %$3] ; # P
; # (car P)
  %7 = inttoptr i64 %6 to i64*
  %8 = load i64, i64* %7
  %9 = icmp ne i64 %8, 0
  br label %$2
$2:
  %10 = phi i64 [%0, %$1], [%4, %$3], [%6, %$4] ; # P
  %11 = phi i1 [0, %$1], [0, %$3], [%9, %$4] ; # ->
  br i1 %11, label %$6, label %$5
$5:
  %12 = phi i64 [%10, %$2] ; # P
; # (gc)
  call void @gc()
  br label %$6
$6:
  %13 = phi i64 [%10, %$2], [%12, %$5] ; # P
  ret void
}

define i64 @_Gc(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (eval (car X))) (if (nil? Y) (gc) (set $GcCou...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (car X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (car X))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (if (nil? Y) (gc) (set $GcCount (shl (xCnt Exe Y) 16)) (gc) (set ...
; # (nil? Y)
  %14 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %14, label %$7, label %$8
$7:
  %15 = phi i64 [%3, %$2] ; # X
; # (gc)
  call void @gc()
  br label %$9
$8:
  %16 = phi i64 [%3, %$2] ; # X
; # (set $GcCount (shl (xCnt Exe Y) 16))
; # (xCnt Exe Y)
  %17 = call i64 @xCnt(i64 %0, i64 %13)
; # (shl (xCnt Exe Y) 16)
  %18 = shl i64 %17, 16
  store i64 %18, i64* @$GcCount
; # (gc)
  call void @gc()
; # (set $GcCount (if (atom (shift X)) CELLS (shl (evCnt Exe X) 16)))...
; # (if (atom (shift X)) CELLS (shl (evCnt Exe X) 16))
; # (shift X)
  %19 = inttoptr i64 %16 to i64*
  %20 = getelementptr i64, i64* %19, i32 1
  %21 = load i64, i64* %20
; # (atom (shift X))
  %22 = and i64 %21, 15
  %23 = icmp ne i64 %22, 0
  br i1 %23, label %$10, label %$11
$10:
  %24 = phi i64 [%21, %$8] ; # X
  br label %$12
$11:
  %25 = phi i64 [%21, %$8] ; # X
; # (evCnt Exe X)
  %26 = call i64 @evCnt(i64 %0, i64 %25)
; # (shl (evCnt Exe X) 16)
  %27 = shl i64 %26, 16
  br label %$12
$12:
  %28 = phi i64 [%24, %$10], [%25, %$11] ; # X
  %29 = phi i64 [65536, %$10], [%27, %$11] ; # ->
  store i64 %29, i64* @$GcCount
  br label %$9
$9:
  %30 = phi i64 [%15, %$7], [%28, %$12] ; # X
  ret i64 %13
}

define i64 @cons(i64, i64) align 8 {
$1:
; # (let P (val $Avail) (unless P (save2 Car Cdr (gc)) (setq P (val $...
; # (val $Avail)
  %2 = load i64, i64* @$Avail
; # (unless P (save2 Car Cdr (gc)) (setq P (val $Avail)))
  %3 = icmp ne i64 %2, 0
  br i1 %3, label %$3, label %$2
$2:
  %4 = phi i64 [%2, %$1] ; # P
; # (save2 Car Cdr (gc))
  %5 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %6 = load i64, i64* %5
  %7 = alloca i64, i64 2, align 16
  %8 = ptrtoint i64* %7 to i64
  %9 = inttoptr i64 %8 to i64*
  store i64 %0, i64* %9
  %10 = add i64 %8, 8
  %11 = inttoptr i64 %10 to i64*
  store i64 %6, i64* %11
  %12 = alloca i64, i64 2, align 16
  %13 = ptrtoint i64* %12 to i64
  %14 = inttoptr i64 %13 to i64*
  store i64 %1, i64* %14
  %15 = add i64 %13, 8
  %16 = inttoptr i64 %15 to i64*
  store i64 %8, i64* %16
  %17 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %13, i64* %17
; # (gc)
  call void @gc()
; # drop
  %18 = inttoptr i64 %8 to i64*
  %19 = getelementptr i64, i64* %18, i32 1
  %20 = load i64, i64* %19
  %21 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %20, i64* %21
; # (val $Avail)
  %22 = load i64, i64* @$Avail
  br label %$3
$3:
  %23 = phi i64 [%2, %$1], [%22, %$2] ; # P
; # (set $Avail (car P))
; # (car P)
  %24 = inttoptr i64 %23 to i64*
  %25 = load i64, i64* %24
  store i64 %25, i64* @$Avail
; # (set P Car)
  %26 = inttoptr i64 %23 to i64*
  store i64 %0, i64* %26
; # (set 2 P Cdr)
  %27 = inttoptr i64 %23 to i64*
  %28 = getelementptr i64, i64* %27, i32 1
  store i64 %1, i64* %28
  ret i64 %23
}

define i64 @cons2(i64, i64, i64) align 8 {
$1:
; # (let P (val $Avail) (when P (let Q (val P) (when Q (set $Avail (c...
; # (val $Avail)
  %3 = load i64, i64* @$Avail
; # (when P (let Q (val P) (when Q (set $Avail (car Q)) (set P Car1) ...
  %4 = icmp ne i64 %3, 0
  br i1 %4, label %$2, label %$3
$2:
; # (let Q (val P) (when Q (set $Avail (car Q)) (set P Car1) (set 2 P...
; # (val P)
  %5 = inttoptr i64 %3 to i64*
  %6 = load i64, i64* %5
; # (when Q (set $Avail (car Q)) (set P Car1) (set 2 P Cdr1) (set Q P...
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$5
$4:
; # (set $Avail (car Q))
; # (car Q)
  %8 = inttoptr i64 %6 to i64*
  %9 = load i64, i64* %8
  store i64 %9, i64* @$Avail
; # (set P Car1)
  %10 = inttoptr i64 %3 to i64*
  store i64 %0, i64* %10
; # (set 2 P Cdr1)
  %11 = inttoptr i64 %3 to i64*
  %12 = getelementptr i64, i64* %11, i32 1
  store i64 %1, i64* %12
; # (set Q P)
  %13 = inttoptr i64 %6 to i64*
  store i64 %3, i64* %13
; # (set 2 Q Cdr2)
  %14 = inttoptr i64 %6 to i64*
  %15 = getelementptr i64, i64* %14, i32 1
  store i64 %2, i64* %15
; # (ret Q)
  ret i64 %6
$5:
  br label %$3
$3:
; # (save2 Car1 Cdr1 (save Cdr2 (gc)))
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %17 = load i64, i64* %16
  %18 = alloca i64, i64 2, align 16
  %19 = ptrtoint i64* %18 to i64
  %20 = inttoptr i64 %19 to i64*
  store i64 %0, i64* %20
  %21 = add i64 %19, 8
  %22 = inttoptr i64 %21 to i64*
  store i64 %17, i64* %22
  %23 = alloca i64, i64 2, align 16
  %24 = ptrtoint i64* %23 to i64
  %25 = inttoptr i64 %24 to i64*
  store i64 %1, i64* %25
  %26 = add i64 %24, 8
  %27 = inttoptr i64 %26 to i64*
  store i64 %19, i64* %27
  %28 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %24, i64* %28
; # (save Cdr2 (gc))
  %29 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %30 = load i64, i64* %29
  %31 = alloca i64, i64 2, align 16
  %32 = ptrtoint i64* %31 to i64
  %33 = inttoptr i64 %32 to i64*
  store i64 %2, i64* %33
  %34 = add i64 %32, 8
  %35 = inttoptr i64 %34 to i64*
  store i64 %30, i64* %35
  %36 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %32, i64* %36
; # (gc)
  call void @gc()
; # drop
  %37 = inttoptr i64 %32 to i64*
  %38 = getelementptr i64, i64* %37, i32 1
  %39 = load i64, i64* %38
  %40 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %39, i64* %40
; # drop
  %41 = inttoptr i64 %19 to i64*
  %42 = getelementptr i64, i64* %41, i32 1
  %43 = load i64, i64* %42
  %44 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %43, i64* %44
; # (let (P (val $Avail) Q (val P)) (set $Avail (car Q)) (set P Car1)...
; # (val $Avail)
  %45 = load i64, i64* @$Avail
; # (val P)
  %46 = inttoptr i64 %45 to i64*
  %47 = load i64, i64* %46
; # (set $Avail (car Q))
; # (car Q)
  %48 = inttoptr i64 %47 to i64*
  %49 = load i64, i64* %48
  store i64 %49, i64* @$Avail
; # (set P Car1)
  %50 = inttoptr i64 %45 to i64*
  store i64 %0, i64* %50
; # (set 2 P Cdr1)
  %51 = inttoptr i64 %45 to i64*
  %52 = getelementptr i64, i64* %51, i32 1
  store i64 %1, i64* %52
; # (set Q P)
  %53 = inttoptr i64 %47 to i64*
  store i64 %45, i64* %53
; # (set 2 Q Cdr2)
  %54 = inttoptr i64 %47 to i64*
  %55 = getelementptr i64, i64* %54, i32 1
  store i64 %2, i64* %55
  ret i64 %47
}

define i64 @cons3(i64, i64, i64, i64) align 8 {
$1:
; # (let P (val $Avail) (when P (let Q (val P) (when Q (let R (val Q)...
; # (val $Avail)
  %4 = load i64, i64* @$Avail
; # (when P (let Q (val P) (when Q (let R (val Q) (when R (set $Avail...
  %5 = icmp ne i64 %4, 0
  br i1 %5, label %$2, label %$3
$2:
; # (let Q (val P) (when Q (let R (val Q) (when R (set $Avail (car R)...
; # (val P)
  %6 = inttoptr i64 %4 to i64*
  %7 = load i64, i64* %6
; # (when Q (let R (val Q) (when R (set $Avail (car R)) (set P Car1) ...
  %8 = icmp ne i64 %7, 0
  br i1 %8, label %$4, label %$5
$4:
; # (let R (val Q) (when R (set $Avail (car R)) (set P Car1) (set 2 P...
; # (val Q)
  %9 = inttoptr i64 %7 to i64*
  %10 = load i64, i64* %9
; # (when R (set $Avail (car R)) (set P Car1) (set 2 P Cdr1) (set Q C...
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$7
$6:
; # (set $Avail (car R))
; # (car R)
  %12 = inttoptr i64 %10 to i64*
  %13 = load i64, i64* %12
  store i64 %13, i64* @$Avail
; # (set P Car1)
  %14 = inttoptr i64 %4 to i64*
  store i64 %0, i64* %14
; # (set 2 P Cdr1)
  %15 = inttoptr i64 %4 to i64*
  %16 = getelementptr i64, i64* %15, i32 1
  store i64 %1, i64* %16
; # (set Q Car2)
  %17 = inttoptr i64 %7 to i64*
  store i64 %2, i64* %17
; # (set 2 Q Cdr2)
  %18 = inttoptr i64 %7 to i64*
  %19 = getelementptr i64, i64* %18, i32 1
  store i64 %3, i64* %19
; # (set R P)
  %20 = inttoptr i64 %10 to i64*
  store i64 %4, i64* %20
; # (set 2 R Q)
  %21 = inttoptr i64 %10 to i64*
  %22 = getelementptr i64, i64* %21, i32 1
  store i64 %7, i64* %22
; # (ret R)
  ret i64 %10
$7:
  br label %$5
$5:
  br label %$3
$3:
; # (save2 Car1 Cdr1 (save2 Car2 Cdr2 (gc)))
  %23 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %24 = load i64, i64* %23
  %25 = alloca i64, i64 2, align 16
  %26 = ptrtoint i64* %25 to i64
  %27 = inttoptr i64 %26 to i64*
  store i64 %0, i64* %27
  %28 = add i64 %26, 8
  %29 = inttoptr i64 %28 to i64*
  store i64 %24, i64* %29
  %30 = alloca i64, i64 2, align 16
  %31 = ptrtoint i64* %30 to i64
  %32 = inttoptr i64 %31 to i64*
  store i64 %1, i64* %32
  %33 = add i64 %31, 8
  %34 = inttoptr i64 %33 to i64*
  store i64 %26, i64* %34
  %35 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %31, i64* %35
; # (save2 Car2 Cdr2 (gc))
  %36 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %37 = load i64, i64* %36
  %38 = alloca i64, i64 2, align 16
  %39 = ptrtoint i64* %38 to i64
  %40 = inttoptr i64 %39 to i64*
  store i64 %2, i64* %40
  %41 = add i64 %39, 8
  %42 = inttoptr i64 %41 to i64*
  store i64 %37, i64* %42
  %43 = alloca i64, i64 2, align 16
  %44 = ptrtoint i64* %43 to i64
  %45 = inttoptr i64 %44 to i64*
  store i64 %3, i64* %45
  %46 = add i64 %44, 8
  %47 = inttoptr i64 %46 to i64*
  store i64 %39, i64* %47
  %48 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %44, i64* %48
; # (gc)
  call void @gc()
; # drop
  %49 = inttoptr i64 %39 to i64*
  %50 = getelementptr i64, i64* %49, i32 1
  %51 = load i64, i64* %50
  %52 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %51, i64* %52
; # drop
  %53 = inttoptr i64 %26 to i64*
  %54 = getelementptr i64, i64* %53, i32 1
  %55 = load i64, i64* %54
  %56 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %55, i64* %56
; # (let (P (val $Avail) Q (val P) R (val Q)) (set $Avail (car R)) (s...
; # (val $Avail)
  %57 = load i64, i64* @$Avail
; # (val P)
  %58 = inttoptr i64 %57 to i64*
  %59 = load i64, i64* %58
; # (val Q)
  %60 = inttoptr i64 %59 to i64*
  %61 = load i64, i64* %60
; # (set $Avail (car R))
; # (car R)
  %62 = inttoptr i64 %61 to i64*
  %63 = load i64, i64* %62
  store i64 %63, i64* @$Avail
; # (set P Car1)
  %64 = inttoptr i64 %57 to i64*
  store i64 %0, i64* %64
; # (set 2 P Cdr1)
  %65 = inttoptr i64 %57 to i64*
  %66 = getelementptr i64, i64* %65, i32 1
  store i64 %1, i64* %66
; # (set Q Car2)
  %67 = inttoptr i64 %59 to i64*
  store i64 %2, i64* %67
; # (set 2 Q Cdr2)
  %68 = inttoptr i64 %59 to i64*
  %69 = getelementptr i64, i64* %68, i32 1
  store i64 %3, i64* %69
; # (set R P)
  %70 = inttoptr i64 %61 to i64*
  store i64 %57, i64* %70
; # (set 2 R Q)
  %71 = inttoptr i64 %61 to i64*
  %72 = getelementptr i64, i64* %71, i32 1
  store i64 %59, i64* %72
  ret i64 %61
}

define i64 @consSym(i64, i64) align 8 {
$1:
; # (let P (val $Avail) (unless P (if Val (save2 Name Val (gc)) (save...
; # (val $Avail)
  %2 = load i64, i64* @$Avail
; # (unless P (if Val (save2 Name Val (gc)) (save Name (gc))) (setq P...
  %3 = icmp ne i64 %2, 0
  br i1 %3, label %$3, label %$2
$2:
  %4 = phi i64 [%2, %$1] ; # P
; # (if Val (save2 Name Val (gc)) (save Name (gc)))
  %5 = icmp ne i64 %1, 0
  br i1 %5, label %$4, label %$5
$4:
  %6 = phi i64 [%4, %$2] ; # P
; # (save2 Name Val (gc))
  %7 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %8 = load i64, i64* %7
  %9 = alloca i64, i64 2, align 16
  %10 = ptrtoint i64* %9 to i64
  %11 = inttoptr i64 %10 to i64*
  store i64 %0, i64* %11
  %12 = add i64 %10, 8
  %13 = inttoptr i64 %12 to i64*
  store i64 %8, i64* %13
  %14 = alloca i64, i64 2, align 16
  %15 = ptrtoint i64* %14 to i64
  %16 = inttoptr i64 %15 to i64*
  store i64 %1, i64* %16
  %17 = add i64 %15, 8
  %18 = inttoptr i64 %17 to i64*
  store i64 %10, i64* %18
  %19 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %15, i64* %19
; # (gc)
  call void @gc()
; # drop
  %20 = inttoptr i64 %10 to i64*
  %21 = getelementptr i64, i64* %20, i32 1
  %22 = load i64, i64* %21
  %23 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %22, i64* %23
  br label %$6
$5:
  %24 = phi i64 [%4, %$2] ; # P
; # (save Name (gc))
  %25 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %26 = load i64, i64* %25
  %27 = alloca i64, i64 2, align 16
  %28 = ptrtoint i64* %27 to i64
  %29 = inttoptr i64 %28 to i64*
  store i64 %0, i64* %29
  %30 = add i64 %28, 8
  %31 = inttoptr i64 %30 to i64*
  store i64 %26, i64* %31
  %32 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %28, i64* %32
; # (gc)
  call void @gc()
; # drop
  %33 = inttoptr i64 %28 to i64*
  %34 = getelementptr i64, i64* %33, i32 1
  %35 = load i64, i64* %34
  %36 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %35, i64* %36
  br label %$6
$6:
  %37 = phi i64 [%6, %$4], [%24, %$5] ; # P
; # (val $Avail)
  %38 = load i64, i64* @$Avail
  br label %$3
$3:
  %39 = phi i64 [%2, %$1], [%38, %$6] ; # P
; # (set $Avail (car P))
; # (car P)
  %40 = inttoptr i64 %39 to i64*
  %41 = load i64, i64* %40
  store i64 %41, i64* @$Avail
; # (set P Name)
  %42 = inttoptr i64 %39 to i64*
  store i64 %0, i64* %42
; # (let S (sym P) (set S (if Val @ S)) S)
; # (sym P)
  %43 = or i64 %39, 8
; # (set S (if Val @ S))
; # (if Val @ S)
  %44 = icmp ne i64 %1, 0
  br i1 %44, label %$7, label %$8
$7:
  %45 = phi i64 [%39, %$3] ; # P
  br label %$9
$8:
  %46 = phi i64 [%39, %$3] ; # P
  br label %$9
$9:
  %47 = phi i64 [%45, %$7], [%46, %$8] ; # P
  %48 = phi i64 [%1, %$7], [%43, %$8] ; # ->
  %49 = inttoptr i64 %43 to i64*
  store i64 %48, i64* %49
  ret i64 %43
}

define i64 @consStr(i64) align 8 {
$1:
; # (if (== Name ZERO) $Nil (tailcall (consSym Name 0)))
; # (== Name ZERO)
  %1 = icmp eq i64 %0, 2
  br i1 %1, label %$2, label %$3
$2:
  br label %$4
$3:
; # (consSym Name 0)
  %2 = tail call i64 @consSym(i64 %0, i64 0)
  br label %$4
$4:
  %3 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%2, %$3] ; # ->
  ret i64 %3
}

define i64 @consExt(i64) align 8 {
$1:
; # (set $ExtCnt (+ (val $ExtCnt) 1))
; # (val $ExtCnt)
  %1 = load i64, i64* @$ExtCnt
; # (+ (val $ExtCnt) 1)
  %2 = add i64 %1, 1
  store i64 %2, i64* @$ExtCnt
; # (sign Name)
  %3 = or i64 %0, 8
; # (consSym (sign Name) $Nil)
  %4 = tail call i64 @consSym(i64 %3, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  ret i64 %4
}

define i64 @boxNum(i64) align 8 {
$1:
; # (let P (val $Avail) (unless P (gc) (setq P (val $Avail))) (set $A...
; # (val $Avail)
  %1 = load i64, i64* @$Avail
; # (unless P (gc) (setq P (val $Avail)))
  %2 = icmp ne i64 %1, 0
  br i1 %2, label %$3, label %$2
$2:
  %3 = phi i64 [%1, %$1] ; # P
; # (gc)
  call void @gc()
; # (val $Avail)
  %4 = load i64, i64* @$Avail
  br label %$3
$3:
  %5 = phi i64 [%1, %$1], [%4, %$2] ; # P
; # (set $Avail (car P))
; # (car P)
  %6 = inttoptr i64 %5 to i64*
  %7 = load i64, i64* %6
  store i64 %7, i64* @$Avail
; # (set P Dig)
  %8 = inttoptr i64 %5 to i64*
  store i64 %0, i64* %8
; # (set 2 P ZERO)
  %9 = inttoptr i64 %5 to i64*
  %10 = getelementptr i64, i64* %9, i32 1
  store i64 2, i64* %10
; # (big P)
  %11 = add i64 %5, 4
  ret i64 %11
}

define i64 @consNum(i64, i64) align 8 {
$1:
; # (let P (val $Avail) (unless P (save Big (gc)) (setq P (val $Avail...
; # (val $Avail)
  %2 = load i64, i64* @$Avail
; # (unless P (save Big (gc)) (setq P (val $Avail)))
  %3 = icmp ne i64 %2, 0
  br i1 %3, label %$3, label %$2
$2:
  %4 = phi i64 [%2, %$1] ; # P
; # (save Big (gc))
  %5 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %6 = load i64, i64* %5
  %7 = alloca i64, i64 2, align 16
  %8 = ptrtoint i64* %7 to i64
  %9 = inttoptr i64 %8 to i64*
  store i64 %1, i64* %9
  %10 = add i64 %8, 8
  %11 = inttoptr i64 %10 to i64*
  store i64 %6, i64* %11
  %12 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %8, i64* %12
; # (gc)
  call void @gc()
; # drop
  %13 = inttoptr i64 %8 to i64*
  %14 = getelementptr i64, i64* %13, i32 1
  %15 = load i64, i64* %14
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %15, i64* %16
; # (val $Avail)
  %17 = load i64, i64* @$Avail
  br label %$3
$3:
  %18 = phi i64 [%2, %$1], [%17, %$2] ; # P
; # (set $Avail (car P))
; # (car P)
  %19 = inttoptr i64 %18 to i64*
  %20 = load i64, i64* %19
  store i64 %20, i64* @$Avail
; # (set P Dig)
  %21 = inttoptr i64 %18 to i64*
  store i64 %0, i64* %21
; # (set 2 P Big)
  %22 = inttoptr i64 %18 to i64*
  %23 = getelementptr i64, i64* %22, i32 1
  store i64 %1, i64* %23
; # (big P)
  %24 = add i64 %18, 4
  ret i64 %24
}

define i64 @box(i64) align 8 {
$1:
; # (if (ge0 N) (box64 N) (sign (box64 (- N))))
; # (ge0 N)
  %1 = icmp sge i64 %0, 0
  br i1 %1, label %$2, label %$3
$2:
; # (box64 N)
  %2 = and i64 %0, 17293822569102704640
  %3 = icmp ne i64 %2, 0
  br i1 %3, label %$5, label %$6
$5:
  %4 = call i64 @boxNum(i64 %0)
  br label %$7
$6:
  %5 = shl i64 %0, 4
  %6 = or i64 %5, 2
  br label %$7
$7:
  %7 = phi i64 [%4, %$5], [%6, %$6] ; # ->
  br label %$4
$3:
; # (- N)
  %8 = sub i64 0, %0
; # (box64 (- N))
  %9 = and i64 %8, 17293822569102704640
  %10 = icmp ne i64 %9, 0
  br i1 %10, label %$8, label %$9
$8:
  %11 = call i64 @boxNum(i64 %8)
  br label %$10
$9:
  %12 = shl i64 %8, 4
  %13 = or i64 %12, 2
  br label %$10
$10:
  %14 = phi i64 [%11, %$8], [%13, %$9] ; # ->
; # (sign (box64 (- N)))
  %15 = or i64 %14, 8
  br label %$4
$4:
  %16 = phi i64 [%7, %$7], [%15, %$10] ; # ->
  ret i64 %16
}

define void @divErr(i64) align 8 {
$1:
; # (err Exe 0 ($ "Div/0") null)
  call void @err(i64 %0, i64 0, i8* bitcast ([6 x i8]* @$27 to i8*), i8* null)
  unreachable
}

define i8 @symByte(i64*) align 8 {
$1:
; # (let C (val P) (unless C (let Nm (val 2 P) (cond ((== Nm ZERO) (r...
; # (val P)
  %1 = load i64, i64* %0
; # (unless C (let Nm (val 2 P) (cond ((== Nm ZERO) (ret (i8 0))) ((c...
  %2 = icmp ne i64 %1, 0
  br i1 %2, label %$3, label %$2
$2:
  %3 = phi i64 [%1, %$1] ; # C
; # (let Nm (val 2 P) (cond ((== Nm ZERO) (ret (i8 0))) ((cnt? Nm) (s...
; # (val 2 P)
  %4 = getelementptr i64, i64* %0, i32 1
  %5 = load i64, i64* %4
; # (cond ((== Nm ZERO) (ret (i8 0))) ((cnt? Nm) (setq C (int Nm)) (s...
; # (== Nm ZERO)
  %6 = icmp eq i64 %5, 2
  br i1 %6, label %$6, label %$5
$6:
  %7 = phi i64 [%3, %$2] ; # C
; # (i8 0)
; # (ret (i8 0))
  ret i8 0
$5:
  %8 = phi i64 [%3, %$2] ; # C
; # (cnt? Nm)
  %9 = and i64 %5, 2
  %10 = icmp ne i64 %9, 0
  br i1 %10, label %$8, label %$7
$8:
  %11 = phi i64 [%8, %$5] ; # C
; # (int Nm)
  %12 = lshr i64 %5, 4
; # (set 2 P ZERO)
  %13 = getelementptr i64, i64* %0, i32 1
  store i64 2, i64* %13
  br label %$4
$7:
  %14 = phi i64 [%8, %$5] ; # C
; # (set P (val (dig Nm)))
; # (dig Nm)
  %15 = add i64 %5, -4
; # (val (dig Nm))
  %16 = inttoptr i64 %15 to i64*
  %17 = load i64, i64* %16
  store i64 %17, i64* %0
; # (set 2 P (val (big Nm)))
; # (big Nm)
  %18 = add i64 %5, 4
; # (val (big Nm))
  %19 = inttoptr i64 %18 to i64*
  %20 = load i64, i64* %19
  %21 = getelementptr i64, i64* %0, i32 1
  store i64 %20, i64* %21
  br label %$4
$4:
  %22 = phi i64 [%12, %$8], [%17, %$7] ; # C
  %23 = phi i64 [2, %$8], [%20, %$7] ; # ->
  br label %$3
$3:
  %24 = phi i64 [%1, %$1], [%22, %$4] ; # C
; # (set P (shr C 8))
; # (shr C 8)
  %25 = lshr i64 %24, 8
  store i64 %25, i64* %0
; # (i8 C)
  %26 = trunc i64 %24 to i8
  ret i8 %26
}

define i32 @symChar(i64*) align 8 {
$1:
; # (let C (i32 (symByte P)) (cond ((>= 127 C) C) ((== C (hex "FF")) ...
; # (symByte P)
  %1 = call i8 @symByte(i64* %0)
; # (i32 (symByte P))
  %2 = zext i8 %1 to i32
; # (cond ((>= 127 C) C) ((== C (hex "FF")) (i32 TOP)) (T (| (shl (if...
; # (>= 127 C)
  %3 = icmp sge i32 127, %2
  br i1 %3, label %$4, label %$3
$4:
  br label %$2
$3:
; # (== C (hex "FF"))
  %4 = icmp eq i32 %2, 255
  br i1 %4, label %$6, label %$5
$6:
; # (i32 TOP)
  br label %$2
$5:
; # (ifn (& C (hex "20")) (& C (hex "1F")) (| (shl (ifn (& C (hex "10...
; # (& C (hex "20"))
  %5 = and i32 %2, 32
  %6 = icmp ne i32 %5, 0
  br i1 %6, label %$8, label %$7
$7:
; # (& C (hex "1F"))
  %7 = and i32 %2, 31
  br label %$9
$8:
; # (ifn (& C (hex "10")) (& C (hex "0F")) (| (shl (& C (hex "7")) 6)...
; # (& C (hex "10"))
  %8 = and i32 %2, 16
  %9 = icmp ne i32 %8, 0
  br i1 %9, label %$11, label %$10
$10:
; # (& C (hex "0F"))
  %10 = and i32 %2, 15
  br label %$12
$11:
; # (& C (hex "7"))
  %11 = and i32 %2, 7
; # (shl (& C (hex "7")) 6)
  %12 = shl i32 %11, 6
; # (symByte P)
  %13 = call i8 @symByte(i64* %0)
; # (i32 (symByte P))
  %14 = zext i8 %13 to i32
; # (& (i32 (symByte P)) (hex "3F"))
  %15 = and i32 %14, 63
; # (| (shl (& C (hex "7")) 6) (& (i32 (symByte P)) (hex "3F")))
  %16 = or i32 %12, %15
  br label %$12
$12:
  %17 = phi i32 [%10, %$10], [%16, %$11] ; # ->
; # (shl (ifn (& C (hex "10")) (& C (hex "0F")) (| (shl (& C (hex "7"...
  %18 = shl i32 %17, 6
; # (symByte P)
  %19 = call i8 @symByte(i64* %0)
; # (i32 (symByte P))
  %20 = zext i8 %19 to i32
; # (& (i32 (symByte P)) (hex "3F"))
  %21 = and i32 %20, 63
; # (| (shl (ifn (& C (hex "10")) (& C (hex "0F")) (| (shl (& C (hex ...
  %22 = or i32 %18, %21
  br label %$9
$9:
  %23 = phi i32 [%7, %$7], [%22, %$12] ; # ->
; # (shl (ifn (& C (hex "20")) (& C (hex "1F")) (| (shl (ifn (& C (he...
  %24 = shl i32 %23, 6
; # (symByte P)
  %25 = call i8 @symByte(i64* %0)
; # (i32 (symByte P))
  %26 = zext i8 %25 to i32
; # (& (i32 (symByte P)) (hex "3F"))
  %27 = and i32 %26, 63
; # (| (shl (ifn (& C (hex "20")) (& C (hex "1F")) (| (shl (ifn (& C ...
  %28 = or i32 %24, %27
  br label %$2
$2:
  %29 = phi i32 [%2, %$4], [1114112, %$6], [%28, %$9] ; # ->
  ret i32 %29
}

define void @byteNum(i8, i64*) align 8 {
$1:
; # (let (Cnt (val P) Nm (val 3 P)) (if (cnt? Nm) (cond ((== Cnt 67) ...
; # (val P)
  %2 = load i64, i64* %1
; # (val 3 P)
  %3 = getelementptr i64, i64* %1, i32 2
  %4 = load i64, i64* %3
; # (if (cnt? Nm) (cond ((== Cnt 67) (set 3 P (set 2 P (consNum (shr ...
; # (cnt? Nm)
  %5 = and i64 %4, 2
  %6 = icmp ne i64 %5, 0
  br i1 %6, label %$2, label %$3
$2:
; # (cond ((== Cnt 67) (set 3 P (set 2 P (consNum (shr Nm 3) (cnt (i6...
; # (== Cnt 67)
  %7 = icmp eq i64 %2, 67
  br i1 %7, label %$7, label %$6
$7:
; # (set 3 P (set 2 P (consNum (shr Nm 3) (cnt (i64 B)))))
; # (set 2 P (consNum (shr Nm 3) (cnt (i64 B))))
; # (shr Nm 3)
  %8 = lshr i64 %4, 3
; # (i64 B)
  %9 = zext i8 %0 to i64
; # (cnt (i64 B))
  %10 = shl i64 %9, 4
  %11 = or i64 %10, 2
; # (consNum (shr Nm 3) (cnt (i64 B)))
  %12 = call i64 @consNum(i64 %8, i64 %11)
  %13 = getelementptr i64, i64* %1, i32 1
  store i64 %12, i64* %13
  %14 = getelementptr i64, i64* %1, i32 2
  store i64 %12, i64* %14
; # (set P 12)
  store i64 12, i64* %1
  br label %$5
$6:
; # (and (== Cnt 59) (>= B 32))
; # (== Cnt 59)
  %15 = icmp eq i64 %2, 59
  br i1 %15, label %$9, label %$8
$9:
; # (>= B 32)
  %16 = icmp uge i8 %0, 32
  br label %$8
$8:
  %17 = phi i1 [0, %$6], [%16, %$9] ; # ->
  br i1 %17, label %$11, label %$10
$11:
; # (set 3 P (set 2 P (boxNum (| (shr Nm 3) (shl (i64 B) 56)))))
; # (set 2 P (boxNum (| (shr Nm 3) (shl (i64 B) 56))))
; # (shr Nm 3)
  %18 = lshr i64 %4, 3
; # (i64 B)
  %19 = zext i8 %0 to i64
; # (shl (i64 B) 56)
  %20 = shl i64 %19, 56
; # (| (shr Nm 3) (shl (i64 B) 56))
  %21 = or i64 %18, %20
; # (boxNum (| (shr Nm 3) (shl (i64 B) 56)))
  %22 = call i64 @boxNum(i64 %21)
  %23 = getelementptr i64, i64* %1, i32 1
  store i64 %22, i64* %23
  %24 = getelementptr i64, i64* %1, i32 2
  store i64 %22, i64* %24
; # (set P 4)
  store i64 4, i64* %1
  br label %$5
$10:
; # (set 3 P (| Nm (shl (i64 B) Cnt)) P (+ Cnt 8))
; # (i64 B)
  %25 = zext i8 %0 to i64
; # (shl (i64 B) Cnt)
  %26 = shl i64 %25, %2
; # (| Nm (shl (i64 B) Cnt))
  %27 = or i64 %4, %26
  %28 = getelementptr i64, i64* %1, i32 2
  store i64 %27, i64* %28
; # (+ Cnt 8)
  %29 = add i64 %2, 8
  store i64 %29, i64* %1
  br label %$5
$5:
  %30 = phi i64 [12, %$7], [4, %$11], [%29, %$10] ; # ->
  br label %$4
$3:
; # (let (Q (val 2 P) N (val (big Q))) (cond ((== Cnt 68) (set 2 P (s...
; # (val 2 P)
  %31 = getelementptr i64, i64* %1, i32 1
  %32 = load i64, i64* %31
; # (big Q)
  %33 = add i64 %32, 4
; # (val (big Q))
  %34 = inttoptr i64 %33 to i64*
  %35 = load i64, i64* %34
; # (cond ((== Cnt 68) (set 2 P (set (big Q) (consNum (int N) (cnt (i...
; # (== Cnt 68)
  %36 = icmp eq i64 %2, 68
  br i1 %36, label %$14, label %$13
$14:
; # (set 2 P (set (big Q) (consNum (int N) (cnt (i64 B)))))
; # (set (big Q) (consNum (int N) (cnt (i64 B))))
; # (big Q)
  %37 = add i64 %32, 4
; # (int N)
  %38 = lshr i64 %35, 4
; # (i64 B)
  %39 = zext i8 %0 to i64
; # (cnt (i64 B))
  %40 = shl i64 %39, 4
  %41 = or i64 %40, 2
; # (consNum (int N) (cnt (i64 B)))
  %42 = call i64 @consNum(i64 %38, i64 %41)
  %43 = inttoptr i64 %37 to i64*
  store i64 %42, i64* %43
  %44 = getelementptr i64, i64* %1, i32 1
  store i64 %42, i64* %44
; # (set P 12)
  store i64 12, i64* %1
  br label %$12
$13:
; # (and (== Cnt 60) (>= B 16))
; # (== Cnt 60)
  %45 = icmp eq i64 %2, 60
  br i1 %45, label %$16, label %$15
$16:
; # (>= B 16)
  %46 = icmp uge i8 %0, 16
  br label %$15
$15:
  %47 = phi i1 [0, %$13], [%46, %$16] ; # ->
  br i1 %47, label %$18, label %$17
$18:
; # (set 2 P (set (big Q) (boxNum (| (int N) (shl (i64 B) 56)))))
; # (set (big Q) (boxNum (| (int N) (shl (i64 B) 56))))
; # (big Q)
  %48 = add i64 %32, 4
; # (int N)
  %49 = lshr i64 %35, 4
; # (i64 B)
  %50 = zext i8 %0 to i64
; # (shl (i64 B) 56)
  %51 = shl i64 %50, 56
; # (| (int N) (shl (i64 B) 56))
  %52 = or i64 %49, %51
; # (boxNum (| (int N) (shl (i64 B) 56)))
  %53 = call i64 @boxNum(i64 %52)
  %54 = inttoptr i64 %48 to i64*
  store i64 %53, i64* %54
  %55 = getelementptr i64, i64* %1, i32 1
  store i64 %53, i64* %55
; # (set P 4)
  store i64 4, i64* %1
  br label %$12
$17:
; # (set (big Q) (| N (shl (i64 B) Cnt)) P (+ Cnt 8))
; # (big Q)
  %56 = add i64 %32, 4
; # (i64 B)
  %57 = zext i8 %0 to i64
; # (shl (i64 B) Cnt)
  %58 = shl i64 %57, %2
; # (| N (shl (i64 B) Cnt))
  %59 = or i64 %35, %58
  %60 = inttoptr i64 %56 to i64*
  store i64 %59, i64* %60
; # (+ Cnt 8)
  %61 = add i64 %2, 8
  store i64 %61, i64* %1
  br label %$12
$12:
  %62 = phi i64 [12, %$14], [4, %$18], [%61, %$17] ; # ->
  br label %$4
$4:
  %63 = phi i64 [%30, %$5], [%62, %$12] ; # ->
  ret void
}

define void @byteSym(i8, i64*) align 8 {
$1:
; # (let (Cnt (val P) Nm (val 3 P)) (if (cnt? Nm) (if (> 60 Cnt) (set...
; # (val P)
  %2 = load i64, i64* %1
; # (val 3 P)
  %3 = getelementptr i64, i64* %1, i32 2
  %4 = load i64, i64* %3
; # (if (cnt? Nm) (if (> 60 Cnt) (set 3 P (| Nm (shl (i64 B) Cnt)) P ...
; # (cnt? Nm)
  %5 = and i64 %4, 2
  %6 = icmp ne i64 %5, 0
  br i1 %6, label %$2, label %$3
$2:
; # (if (> 60 Cnt) (set 3 P (| Nm (shl (i64 B) Cnt)) P (+ Cnt 8)) (se...
; # (> 60 Cnt)
  %7 = icmp ugt i64 60, %2
  br i1 %7, label %$5, label %$6
$5:
; # (set 3 P (| Nm (shl (i64 B) Cnt)) P (+ Cnt 8))
; # (i64 B)
  %8 = zext i8 %0 to i64
; # (shl (i64 B) Cnt)
  %9 = shl i64 %8, %2
; # (| Nm (shl (i64 B) Cnt))
  %10 = or i64 %4, %9
  %11 = getelementptr i64, i64* %1, i32 2
  store i64 %10, i64* %11
; # (+ Cnt 8)
  %12 = add i64 %2, 8
  store i64 %12, i64* %1
  br label %$7
$6:
; # (set 3 P (set 2 P (boxNum (| (int Nm) (shl (i64 B) 56)))))
; # (set 2 P (boxNum (| (int Nm) (shl (i64 B) 56))))
; # (int Nm)
  %13 = lshr i64 %4, 4
; # (i64 B)
  %14 = zext i8 %0 to i64
; # (shl (i64 B) 56)
  %15 = shl i64 %14, 56
; # (| (int Nm) (shl (i64 B) 56))
  %16 = or i64 %13, %15
; # (boxNum (| (int Nm) (shl (i64 B) 56)))
  %17 = call i64 @boxNum(i64 %16)
  %18 = getelementptr i64, i64* %1, i32 1
  store i64 %17, i64* %18
  %19 = getelementptr i64, i64* %1, i32 2
  store i64 %17, i64* %19
; # (set P 4)
  store i64 4, i64* %1
  br label %$7
$7:
  %20 = phi i64 [%12, %$5], [4, %$6] ; # ->
  br label %$4
$3:
; # (let (Q (val 2 P) N (val (big Q))) (if (> 60 Cnt) (set (big Q) (|...
; # (val 2 P)
  %21 = getelementptr i64, i64* %1, i32 1
  %22 = load i64, i64* %21
; # (big Q)
  %23 = add i64 %22, 4
; # (val (big Q))
  %24 = inttoptr i64 %23 to i64*
  %25 = load i64, i64* %24
; # (if (> 60 Cnt) (set (big Q) (| N (shl (i64 B) Cnt)) P (+ Cnt 8)) ...
; # (> 60 Cnt)
  %26 = icmp ugt i64 60, %2
  br i1 %26, label %$8, label %$9
$8:
; # (set (big Q) (| N (shl (i64 B) Cnt)) P (+ Cnt 8))
; # (big Q)
  %27 = add i64 %22, 4
; # (i64 B)
  %28 = zext i8 %0 to i64
; # (shl (i64 B) Cnt)
  %29 = shl i64 %28, %2
; # (| N (shl (i64 B) Cnt))
  %30 = or i64 %25, %29
  %31 = inttoptr i64 %27 to i64*
  store i64 %30, i64* %31
; # (+ Cnt 8)
  %32 = add i64 %2, 8
  store i64 %32, i64* %1
  br label %$10
$9:
; # (set 2 P (set (big Q) (boxNum (| (int N) (shl (i64 B) 56)))))
; # (set (big Q) (boxNum (| (int N) (shl (i64 B) 56))))
; # (big Q)
  %33 = add i64 %22, 4
; # (int N)
  %34 = lshr i64 %25, 4
; # (i64 B)
  %35 = zext i8 %0 to i64
; # (shl (i64 B) 56)
  %36 = shl i64 %35, 56
; # (| (int N) (shl (i64 B) 56))
  %37 = or i64 %34, %36
; # (boxNum (| (int N) (shl (i64 B) 56)))
  %38 = call i64 @boxNum(i64 %37)
  %39 = inttoptr i64 %33 to i64*
  store i64 %38, i64* %39
  %40 = getelementptr i64, i64* %1, i32 1
  store i64 %38, i64* %40
; # (set P 4)
  store i64 4, i64* %1
  br label %$10
$10:
  %41 = phi i64 [%32, %$8], [4, %$9] ; # ->
  br label %$4
$4:
  %42 = phi i64 [%20, %$7], [%41, %$10] ; # ->
  ret void
}

define void @charSym(i32, i64*) align 8 {
$1:
; # (cond ((>= 127 C) (byteSym (i8 C) P)) ((== TOP C) (byteSym (hex "...
; # (>= 127 C)
  %2 = icmp sge i32 127, %0
  br i1 %2, label %$4, label %$3
$4:
; # (i8 C)
  %3 = trunc i32 %0 to i8
; # (byteSym (i8 C) P)
  call void @byteSym(i8 %3, i64* %1)
  br label %$2
$3:
; # (== TOP C)
  %4 = icmp eq i32 1114112, %0
  br i1 %4, label %$6, label %$5
$6:
; # (byteSym (hex "FF") P)
  call void @byteSym(i8 255, i64* %1)
  br label %$2
$5:
; # (cond ((> (hex "800") C) (byteSym (i8 (| (hex "C0") (& (shr C 6) ...
; # (> (hex "800") C)
  %5 = icmp sgt i32 2048, %0
  br i1 %5, label %$9, label %$8
$9:
; # (shr C 6)
  %6 = lshr i32 %0, 6
; # (& (shr C 6) (hex "1F"))
  %7 = and i32 %6, 31
; # (| (hex "C0") (& (shr C 6) (hex "1F")))
  %8 = or i32 192, %7
; # (i8 (| (hex "C0") (& (shr C 6) (hex "1F"))))
  %9 = trunc i32 %8 to i8
; # (byteSym (i8 (| (hex "C0") (& (shr C 6) (hex "1F")))) P)
  call void @byteSym(i8 %9, i64* %1)
  br label %$7
$8:
; # (> (hex "10000") C)
  %10 = icmp sgt i32 65536, %0
  br i1 %10, label %$11, label %$10
$11:
; # (shr C 12)
  %11 = lshr i32 %0, 12
; # (& (shr C 12) (hex "0F"))
  %12 = and i32 %11, 15
; # (| (hex "E0") (& (shr C 12) (hex "0F")))
  %13 = or i32 224, %12
; # (i8 (| (hex "E0") (& (shr C 12) (hex "0F"))))
  %14 = trunc i32 %13 to i8
; # (byteSym (i8 (| (hex "E0") (& (shr C 12) (hex "0F")))) P)
  call void @byteSym(i8 %14, i64* %1)
; # (shr C 6)
  %15 = lshr i32 %0, 6
; # (& (shr C 6) (hex "3F"))
  %16 = and i32 %15, 63
; # (| (hex "80") (& (shr C 6) (hex "3F")))
  %17 = or i32 128, %16
; # (i8 (| (hex "80") (& (shr C 6) (hex "3F"))))
  %18 = trunc i32 %17 to i8
; # (byteSym (i8 (| (hex "80") (& (shr C 6) (hex "3F")))) P)
  call void @byteSym(i8 %18, i64* %1)
  br label %$7
$10:
; # (shr C 18)
  %19 = lshr i32 %0, 18
; # (& (shr C 18) (hex "07"))
  %20 = and i32 %19, 7
; # (| (hex "F0") (& (shr C 18) (hex "07")))
  %21 = or i32 240, %20
; # (i8 (| (hex "F0") (& (shr C 18) (hex "07"))))
  %22 = trunc i32 %21 to i8
; # (byteSym (i8 (| (hex "F0") (& (shr C 18) (hex "07")))) P)
  call void @byteSym(i8 %22, i64* %1)
; # (shr C 12)
  %23 = lshr i32 %0, 12
; # (& (shr C 12) (hex "3F"))
  %24 = and i32 %23, 63
; # (| (hex "80") (& (shr C 12) (hex "3F")))
  %25 = or i32 128, %24
; # (i8 (| (hex "80") (& (shr C 12) (hex "3F"))))
  %26 = trunc i32 %25 to i8
; # (byteSym (i8 (| (hex "80") (& (shr C 12) (hex "3F")))) P)
  call void @byteSym(i8 %26, i64* %1)
; # (shr C 6)
  %27 = lshr i32 %0, 6
; # (& (shr C 6) (hex "3F"))
  %28 = and i32 %27, 63
; # (| (hex "80") (& (shr C 6) (hex "3F")))
  %29 = or i32 128, %28
; # (i8 (| (hex "80") (& (shr C 6) (hex "3F"))))
  %30 = trunc i32 %29 to i8
; # (byteSym (i8 (| (hex "80") (& (shr C 6) (hex "3F")))) P)
  call void @byteSym(i8 %30, i64* %1)
  br label %$7
$7:
; # (& C (hex "3F"))
  %31 = and i32 %0, 63
; # (| (hex "80") (& C (hex "3F")))
  %32 = or i32 128, %31
; # (i8 (| (hex "80") (& C (hex "3F"))))
  %33 = trunc i32 %32 to i8
; # (byteSym (i8 (| (hex "80") (& C (hex "3F")))) P)
  call void @byteSym(i8 %33, i64* %1)
  br label %$2
$2:
  ret void
}

define i64 @zapZero(i64) align 8 {
$1:
; # (let (P (push N) X P Y P Z T) (until (cnt? (setq Z (val (big N)))...
; # (push N)
  %1 = alloca i64, i64 1
  %2 = ptrtoint i64* %1 to i64
  %3 = inttoptr i64 %2 to i64*
  store i64 %0, i64* %3
; # (until (cnt? (setq Z (val (big N)))) (when (val (dig N)) (setq X ...
  br label %$2
$2:
  %4 = phi i64 [%0, %$1], [%30, %$6] ; # N
  %5 = phi i64 [%2, %$1], [%25, %$6] ; # X
  %6 = phi i64 [%2, %$1], [%28, %$6] ; # Y
; # (big N)
  %7 = add i64 %4, 4
; # (val (big N))
  %8 = inttoptr i64 %7 to i64*
  %9 = load i64, i64* %8
; # (cnt? (setq Z (val (big N))))
  %10 = and i64 %9, 2
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$4, label %$3
$3:
  %12 = phi i64 [%4, %$2] ; # N
  %13 = phi i64 [%5, %$2] ; # X
  %14 = phi i64 [%6, %$2] ; # Y
  %15 = phi i64 [%9, %$2] ; # Z
; # (when (val (dig N)) (setq X Y))
; # (dig N)
  %16 = add i64 %12, -4
; # (val (dig N))
  %17 = inttoptr i64 %16 to i64*
  %18 = load i64, i64* %17
  %19 = icmp ne i64 %18, 0
  br i1 %19, label %$5, label %$6
$5:
  %20 = phi i64 [%12, %$3] ; # N
  %21 = phi i64 [%13, %$3] ; # X
  %22 = phi i64 [%14, %$3] ; # Y
  %23 = phi i64 [%15, %$3] ; # Z
  br label %$6
$6:
  %24 = phi i64 [%12, %$3], [%20, %$5] ; # N
  %25 = phi i64 [%13, %$3], [%22, %$5] ; # X
  %26 = phi i64 [%14, %$3], [%22, %$5] ; # Y
  %27 = phi i64 [%15, %$3], [%23, %$5] ; # Z
; # (big N)
  %28 = add i64 %24, 4
; # (val Y)
  %29 = inttoptr i64 %28 to i64*
  %30 = load i64, i64* %29
  br label %$2
$4:
  %31 = phi i64 [%4, %$2] ; # N
  %32 = phi i64 [%5, %$2] ; # X
  %33 = phi i64 [%6, %$2] ; # Y
  %34 = phi i64 [%9, %$2] ; # Z
; # (when (== Z ZERO) (cond ((setq N (val (dig N))) (unless (& N (hex...
; # (== Z ZERO)
  %35 = icmp eq i64 %34, 2
  br i1 %35, label %$7, label %$8
$7:
  %36 = phi i64 [%31, %$4] ; # N
  %37 = phi i64 [%32, %$4] ; # X
  %38 = phi i64 [%33, %$4] ; # Y
  %39 = phi i64 [%34, %$4] ; # Z
; # (cond ((setq N (val (dig N))) (unless (& N (hex "F000000000000000...
; # (dig N)
  %40 = add i64 %36, -4
; # (val (dig N))
  %41 = inttoptr i64 %40 to i64*
  %42 = load i64, i64* %41
  %43 = icmp ne i64 %42, 0
  br i1 %43, label %$11, label %$10
$11:
  %44 = phi i64 [%42, %$7] ; # N
  %45 = phi i64 [%37, %$7] ; # X
  %46 = phi i64 [%38, %$7] ; # Y
  %47 = phi i64 [%39, %$7] ; # Z
; # (unless (& N (hex "F000000000000000")) (set Y (cnt N)))
; # (& N (hex "F000000000000000"))
  %48 = and i64 %44, 17293822569102704640
  %49 = icmp ne i64 %48, 0
  br i1 %49, label %$13, label %$12
$12:
  %50 = phi i64 [%44, %$11] ; # N
  %51 = phi i64 [%45, %$11] ; # X
  %52 = phi i64 [%46, %$11] ; # Y
  %53 = phi i64 [%47, %$11] ; # Z
; # (set Y (cnt N))
; # (cnt N)
  %54 = shl i64 %50, 4
  %55 = or i64 %54, 2
  %56 = inttoptr i64 %52 to i64*
  store i64 %55, i64* %56
  br label %$13
$13:
  %57 = phi i64 [%44, %$11], [%50, %$12] ; # N
  %58 = phi i64 [%45, %$11], [%51, %$12] ; # X
  %59 = phi i64 [%46, %$11], [%52, %$12] ; # Y
  %60 = phi i64 [%47, %$11], [%53, %$12] ; # Z
  br label %$9
$10:
  %61 = phi i64 [%42, %$7] ; # N
  %62 = phi i64 [%37, %$7] ; # X
  %63 = phi i64 [%38, %$7] ; # Y
  %64 = phi i64 [%39, %$7] ; # Z
; # (val X)
  %65 = inttoptr i64 %62 to i64*
  %66 = load i64, i64* %65
; # (dig (val X))
  %67 = add i64 %66, -4
; # (val (dig (val X)))
  %68 = inttoptr i64 %67 to i64*
  %69 = load i64, i64* %68
; # (& (setq N (val (dig (val X)))) (hex "F000000000000000"))
  %70 = and i64 %69, 17293822569102704640
  %71 = icmp ne i64 %70, 0
  br i1 %71, label %$15, label %$14
$15:
  %72 = phi i64 [%69, %$10] ; # N
  %73 = phi i64 [%62, %$10] ; # X
  %74 = phi i64 [%63, %$10] ; # Y
  %75 = phi i64 [%64, %$10] ; # Z
; # (set (big (val X)) ZERO)
; # (val X)
  %76 = inttoptr i64 %73 to i64*
  %77 = load i64, i64* %76
; # (big (val X))
  %78 = add i64 %77, 4
  %79 = inttoptr i64 %78 to i64*
  store i64 2, i64* %79
  br label %$9
$14:
  %80 = phi i64 [%69, %$10] ; # N
  %81 = phi i64 [%62, %$10] ; # X
  %82 = phi i64 [%63, %$10] ; # Y
  %83 = phi i64 [%64, %$10] ; # Z
; # (set X (cnt N))
; # (cnt N)
  %84 = shl i64 %80, 4
  %85 = or i64 %84, 2
  %86 = inttoptr i64 %81 to i64*
  store i64 %85, i64* %86
  br label %$9
$9:
  %87 = phi i64 [%57, %$13], [%72, %$15], [%80, %$14] ; # N
  %88 = phi i64 [%58, %$13], [%73, %$15], [%81, %$14] ; # X
  %89 = phi i64 [%59, %$13], [%74, %$15], [%82, %$14] ; # Y
  %90 = phi i64 [%60, %$13], [%75, %$15], [%83, %$14] ; # Z
  br label %$8
$8:
  %91 = phi i64 [%31, %$4], [%87, %$9] ; # N
  %92 = phi i64 [%32, %$4], [%88, %$9] ; # X
  %93 = phi i64 [%33, %$4], [%89, %$9] ; # Y
  %94 = phi i64 [%34, %$4], [%90, %$9] ; # Z
; # (val P)
  %95 = inttoptr i64 %2 to i64*
  %96 = load i64, i64* %95
  ret i64 %96
}

define i64 @twiceBig(i64) align 8 {
$1:
; # (let (X N A (val (dig X)) Y (val (big X))) (set (dig X) (shl A 1)...
; # (dig X)
  %1 = add i64 %0, -4
; # (val (dig X))
  %2 = inttoptr i64 %1 to i64*
  %3 = load i64, i64* %2
; # (big X)
  %4 = add i64 %0, 4
; # (val (big X))
  %5 = inttoptr i64 %4 to i64*
  %6 = load i64, i64* %5
; # (set (dig X) (shl A 1))
; # (dig X)
  %7 = add i64 %0, -4
; # (shl A 1)
  %8 = shl i64 %3, 1
  %9 = inttoptr i64 %7 to i64*
  store i64 %8, i64* %9
; # (while (big? Y) (let B (val (dig Y)) (set (dig (setq X Y)) (| (sh...
  br label %$2
$2:
  %10 = phi i64 [%0, %$1], [%17, %$3] ; # X
  %11 = phi i64 [%3, %$1], [%20, %$3] ; # A
  %12 = phi i64 [%6, %$1], [%28, %$3] ; # Y
; # (big? Y)
  %13 = and i64 %12, 4
  %14 = icmp ne i64 %13, 0
  br i1 %14, label %$3, label %$4
$3:
  %15 = phi i64 [%10, %$2] ; # X
  %16 = phi i64 [%11, %$2] ; # A
  %17 = phi i64 [%12, %$2] ; # Y
; # (let B (val (dig Y)) (set (dig (setq X Y)) (| (shl B 1) (shl 0 A ...
; # (dig Y)
  %18 = add i64 %17, -4
; # (val (dig Y))
  %19 = inttoptr i64 %18 to i64*
  %20 = load i64, i64* %19
; # (set (dig (setq X Y)) (| (shl B 1) (shl 0 A 1)))
; # (dig (setq X Y))
  %21 = add i64 %17, -4
; # (shl B 1)
  %22 = shl i64 %20, 1
; # (shl 0 A 1)
  %23 = call i64 @llvm.fshl.i64(i64 0, i64 %16, i64 1)
; # (| (shl B 1) (shl 0 A 1))
  %24 = or i64 %22, %23
  %25 = inttoptr i64 %21 to i64*
  store i64 %24, i64* %25
; # (big Y)
  %26 = add i64 %17, 4
; # (val (big Y))
  %27 = inttoptr i64 %26 to i64*
  %28 = load i64, i64* %27
  br label %$2
$4:
  %29 = phi i64 [%10, %$2] ; # X
  %30 = phi i64 [%11, %$2] ; # A
  %31 = phi i64 [%12, %$2] ; # Y
; # (set (big X) (box64 (| (shl (int Y) 1) (shl 0 A 1))))
; # (big X)
  %32 = add i64 %29, 4
; # (int Y)
  %33 = lshr i64 %31, 4
; # (shl (int Y) 1)
  %34 = shl i64 %33, 1
; # (shl 0 A 1)
  %35 = call i64 @llvm.fshl.i64(i64 0, i64 %30, i64 1)
; # (| (shl (int Y) 1) (shl 0 A 1))
  %36 = or i64 %34, %35
; # (box64 (| (shl (int Y) 1) (shl 0 A 1)))
  %37 = and i64 %36, 17293822569102704640
  %38 = icmp ne i64 %37, 0
  br i1 %38, label %$5, label %$6
$5:
  %39 = call i64 @boxNum(i64 %36)
  br label %$7
$6:
  %40 = shl i64 %36, 4
  %41 = or i64 %40, 2
  br label %$7
$7:
  %42 = phi i64 [%39, %$5], [%41, %$6] ; # ->
  %43 = inttoptr i64 %32 to i64*
  store i64 %42, i64* %43
  ret i64 %0
}

define i64 @twice(i64) align 8 {
$1:
; # (if (cnt? N) (let X (add N N) (if @@ (boxNum (shr N 3)) (x| X 6))...
; # (cnt? N)
  %1 = and i64 %0, 2
  %2 = icmp ne i64 %1, 0
  br i1 %2, label %$2, label %$3
$2:
; # (let X (add N N) (if @@ (boxNum (shr N 3)) (x| X 6)))
; # (add N N)
  %3 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %0, i64 %0)
  %4 = extractvalue {i64, i1} %3, 1
  %5 = extractvalue {i64, i1} %3, 0
; # (if @@ (boxNum (shr N 3)) (x| X 6))
  br i1 %4, label %$5, label %$6
$5:
; # (shr N 3)
  %6 = lshr i64 %0, 3
; # (boxNum (shr N 3))
  %7 = call i64 @boxNum(i64 %6)
  br label %$7
$6:
; # (x| X 6)
  %8 = xor i64 %5, 6
  br label %$7
$7:
  %9 = phi i64 [%7, %$5], [%8, %$6] ; # ->
  br label %$4
$3:
; # (twiceBig N)
  %10 = call i64 @twiceBig(i64 %0)
  br label %$4
$4:
  %11 = phi i64 [%9, %$7], [%10, %$3] ; # ->
  ret i64 %11
}

define i64 @half(i64) align 8 {
$1:
; # (if (cnt? N) (| (& (shr N 1) -10) 2) (let (X N A (shr (val (dig X...
; # (cnt? N)
  %1 = and i64 %0, 2
  %2 = icmp ne i64 %1, 0
  br i1 %2, label %$2, label %$3
$2:
; # (shr N 1)
  %3 = lshr i64 %0, 1
; # (& (shr N 1) -10)
  %4 = and i64 %3, -10
; # (| (& (shr N 1) -10) 2)
  %5 = or i64 %4, 2
  br label %$4
$3:
; # (let (X N A (shr (val (dig X)) 1) Y (val (big X))) (if (big? Y) (...
; # (dig X)
  %6 = add i64 %0, -4
; # (val (dig X))
  %7 = inttoptr i64 %6 to i64*
  %8 = load i64, i64* %7
; # (shr (val (dig X)) 1)
  %9 = lshr i64 %8, 1
; # (big X)
  %10 = add i64 %0, 4
; # (val (big X))
  %11 = inttoptr i64 %10 to i64*
  %12 = load i64, i64* %11
; # (if (big? Y) (let Z (val (big Y)) (loop (let B (val (dig Y)) (set...
; # (big? Y)
  %13 = and i64 %12, 4
  %14 = icmp ne i64 %13, 0
  br i1 %14, label %$5, label %$6
$5:
  %15 = phi i64 [%0, %$3] ; # X
  %16 = phi i64 [%9, %$3] ; # A
  %17 = phi i64 [%12, %$3] ; # Y
; # (let Z (val (big Y)) (loop (let B (val (dig Y)) (set (dig X) (| (...
; # (big Y)
  %18 = add i64 %17, 4
; # (val (big Y))
  %19 = inttoptr i64 %18 to i64*
  %20 = load i64, i64* %19
; # (loop (let B (val (dig Y)) (set (dig X) (| (shr B 0 1) A)) (setq ...
  br label %$8
$8:
  %21 = phi i64 [%15, %$5], [%37, %$9] ; # X
  %22 = phi i64 [%16, %$5], [%36, %$9] ; # A
  %23 = phi i64 [%17, %$5], [%38, %$9] ; # Y
  %24 = phi i64 [%20, %$5], [%41, %$9] ; # Z
; # (let B (val (dig Y)) (set (dig X) (| (shr B 0 1) A)) (setq A (shr...
; # (dig Y)
  %25 = add i64 %23, -4
; # (val (dig Y))
  %26 = inttoptr i64 %25 to i64*
  %27 = load i64, i64* %26
; # (set (dig X) (| (shr B 0 1) A))
; # (dig X)
  %28 = add i64 %21, -4
; # (shr B 0 1)
  %29 = call i64 @llvm.fshr.i64(i64 %27, i64 0, i64 1)
; # (| (shr B 0 1) A)
  %30 = or i64 %29, %22
  %31 = inttoptr i64 %28 to i64*
  store i64 %30, i64* %31
; # (shr B 1)
  %32 = lshr i64 %27, 1
; # (? (cnt? Z))
; # (cnt? Z)
  %33 = and i64 %24, 2
  %34 = icmp ne i64 %33, 0
  br i1 %34, label %$10, label %$9
$9:
  %35 = phi i64 [%21, %$8] ; # X
  %36 = phi i64 [%32, %$8] ; # A
  %37 = phi i64 [%23, %$8] ; # Y
  %38 = phi i64 [%24, %$8] ; # Z
; # (big Z)
  %39 = add i64 %38, 4
; # (val (big Z))
  %40 = inttoptr i64 %39 to i64*
  %41 = load i64, i64* %40
  br label %$8
$10:
  %42 = phi i64 [%21, %$8] ; # X
  %43 = phi i64 [%32, %$8] ; # A
  %44 = phi i64 [%23, %$8] ; # Y
  %45 = phi i64 [%24, %$8] ; # Z
  %46 = phi i64 [0, %$8] ; # ->
; # (int Z)
  %47 = lshr i64 %45, 4
; # (shr Z 0 1)
  %48 = call i64 @llvm.fshr.i64(i64 %47, i64 0, i64 1)
; # (| (shr Z 0 1) A)
  %49 = or i64 %48, %43
; # (ifn (or (setq Z (shr Z 1)) (& A (hex "F000000000000000"))) (set ...
; # (or (setq Z (shr Z 1)) (& A (hex "F000000000000000")))
; # (shr Z 1)
  %50 = lshr i64 %47, 1
  %51 = icmp ne i64 %50, 0
  br i1 %51, label %$11, label %$12
$12:
  %52 = phi i64 [%42, %$10] ; # X
  %53 = phi i64 [%49, %$10] ; # A
  %54 = phi i64 [%44, %$10] ; # Y
  %55 = phi i64 [%50, %$10] ; # Z
; # (& A (hex "F000000000000000"))
  %56 = and i64 %53, 17293822569102704640
  %57 = icmp ne i64 %56, 0
  br label %$11
$11:
  %58 = phi i64 [%42, %$10], [%52, %$12] ; # X
  %59 = phi i64 [%49, %$10], [%53, %$12] ; # A
  %60 = phi i64 [%44, %$10], [%54, %$12] ; # Y
  %61 = phi i64 [%50, %$10], [%55, %$12] ; # Z
  %62 = phi i1 [1, %$10], [%57, %$12] ; # ->
  br i1 %62, label %$14, label %$13
$13:
  %63 = phi i64 [%58, %$11] ; # X
  %64 = phi i64 [%59, %$11] ; # A
  %65 = phi i64 [%60, %$11] ; # Y
  %66 = phi i64 [%61, %$11] ; # Z
; # (set (big X) (cnt A))
; # (big X)
  %67 = add i64 %63, 4
; # (cnt A)
  %68 = shl i64 %64, 4
  %69 = or i64 %68, 2
  %70 = inttoptr i64 %67 to i64*
  store i64 %69, i64* %70
  br label %$15
$14:
  %71 = phi i64 [%58, %$11] ; # X
  %72 = phi i64 [%59, %$11] ; # A
  %73 = phi i64 [%60, %$11] ; # Y
  %74 = phi i64 [%61, %$11] ; # Z
; # (set (dig Y) A)
; # (dig Y)
  %75 = add i64 %73, -4
  %76 = inttoptr i64 %75 to i64*
  store i64 %72, i64* %76
; # (set (big Y) (cnt Z))
; # (big Y)
  %77 = add i64 %73, 4
; # (cnt Z)
  %78 = shl i64 %74, 4
  %79 = or i64 %78, 2
  %80 = inttoptr i64 %77 to i64*
  store i64 %79, i64* %80
  br label %$15
$15:
  %81 = phi i64 [%63, %$13], [%71, %$14] ; # X
  %82 = phi i64 [%64, %$13], [%72, %$14] ; # A
  %83 = phi i64 [%65, %$13], [%73, %$14] ; # Y
  %84 = phi i64 [%66, %$13], [%74, %$14] ; # Z
  %85 = phi i64 [%69, %$13], [%79, %$14] ; # ->
  br label %$7
$6:
  %86 = phi i64 [%0, %$3] ; # X
  %87 = phi i64 [%9, %$3] ; # A
  %88 = phi i64 [%12, %$3] ; # Y
; # (int Y)
  %89 = lshr i64 %88, 4
; # (shr Y 0 1)
  %90 = call i64 @llvm.fshr.i64(i64 %89, i64 0, i64 1)
; # (| (shr Y 0 1) A)
  %91 = or i64 %90, %87
; # (unless (or (setq Y (shr Y 1)) (& A (hex "F000000000000000"))) (r...
; # (or (setq Y (shr Y 1)) (& A (hex "F000000000000000")))
; # (shr Y 1)
  %92 = lshr i64 %89, 1
  %93 = icmp ne i64 %92, 0
  br i1 %93, label %$16, label %$17
$17:
  %94 = phi i64 [%86, %$6] ; # X
  %95 = phi i64 [%91, %$6] ; # A
  %96 = phi i64 [%92, %$6] ; # Y
; # (& A (hex "F000000000000000"))
  %97 = and i64 %95, 17293822569102704640
  %98 = icmp ne i64 %97, 0
  br label %$16
$16:
  %99 = phi i64 [%86, %$6], [%94, %$17] ; # X
  %100 = phi i64 [%91, %$6], [%95, %$17] ; # A
  %101 = phi i64 [%92, %$6], [%96, %$17] ; # Y
  %102 = phi i1 [1, %$6], [%98, %$17] ; # ->
  br i1 %102, label %$19, label %$18
$18:
  %103 = phi i64 [%99, %$16] ; # X
  %104 = phi i64 [%100, %$16] ; # A
  %105 = phi i64 [%101, %$16] ; # Y
; # (cnt A)
  %106 = shl i64 %104, 4
  %107 = or i64 %106, 2
; # (ret (cnt A))
  ret i64 %107
$19:
  %108 = phi i64 [%99, %$16] ; # X
  %109 = phi i64 [%100, %$16] ; # A
  %110 = phi i64 [%101, %$16] ; # Y
; # (set (dig X) A)
; # (dig X)
  %111 = add i64 %108, -4
  %112 = inttoptr i64 %111 to i64*
  store i64 %109, i64* %112
; # (set (big X) (cnt Y))
; # (big X)
  %113 = add i64 %108, 4
; # (cnt Y)
  %114 = shl i64 %110, 4
  %115 = or i64 %114, 2
  %116 = inttoptr i64 %113 to i64*
  store i64 %115, i64* %116
  br label %$7
$7:
  %117 = phi i64 [%81, %$15], [%108, %$19] ; # X
  %118 = phi i64 [%82, %$15], [%109, %$19] ; # A
  %119 = phi i64 [%83, %$15], [%110, %$19] ; # Y
  %120 = phi i64 [%85, %$15], [%115, %$19] ; # ->
  br label %$4
$4:
  %121 = phi i64 [%5, %$2], [%0, %$7] ; # ->
  ret i64 %121
}

define i64 @tenfold(i64) align 8 {
$1:
; # (if (cnt? N) (box64 (* 10 (int N))) (let (X N Lo (mul 10 (val (di...
; # (cnt? N)
  %1 = and i64 %0, 2
  %2 = icmp ne i64 %1, 0
  br i1 %2, label %$2, label %$3
$2:
; # (int N)
  %3 = lshr i64 %0, 4
; # (* 10 (int N))
  %4 = mul i64 10, %3
; # (box64 (* 10 (int N)))
  %5 = and i64 %4, 17293822569102704640
  %6 = icmp ne i64 %5, 0
  br i1 %6, label %$5, label %$6
$5:
  %7 = call i64 @boxNum(i64 %4)
  br label %$7
$6:
  %8 = shl i64 %4, 4
  %9 = or i64 %8, 2
  br label %$7
$7:
  %10 = phi i64 [%7, %$5], [%9, %$6] ; # ->
  br label %$4
$3:
; # (let (X N Lo (mul 10 (val (dig X))) Hi @@@) (loop (set (dig X) Lo...
; # (dig X)
  %11 = add i64 %0, -4
; # (val (dig X))
  %12 = inttoptr i64 %11 to i64*
  %13 = load i64, i64* %12
; # (mul 10 (val (dig X)))
  %14 = zext i64 %13 to i128
  %15 = mul i128 10, %14
  %16 = lshr i128 %15, 64
  %17 = trunc i128 %16 to i64
  %18 = trunc i128 %15 to i64
; # (loop (set (dig X) Lo) (? (cnt? (val (big X))) (set (big X) (box6...
  br label %$8
$8:
  %19 = phi i64 [%0, %$3], [%26, %$9] ; # X
  %20 = phi i64 [%18, %$3], [%56, %$9] ; # Lo
  %21 = phi i64 [%17, %$3], [%58, %$9] ; # Hi
; # (set (dig X) Lo)
; # (dig X)
  %22 = add i64 %19, -4
  %23 = inttoptr i64 %22 to i64*
  store i64 %20, i64* %23
; # (? (cnt? (val (big X))) (set (big X) (box64 (+ Hi (* 10 (int @)))...
; # (big X)
  %24 = add i64 %19, 4
; # (val (big X))
  %25 = inttoptr i64 %24 to i64*
  %26 = load i64, i64* %25
; # (cnt? (val (big X)))
  %27 = and i64 %26, 2
  %28 = icmp ne i64 %27, 0
  br i1 %28, label %$11, label %$9
$11:
  %29 = phi i64 [%19, %$8] ; # X
  %30 = phi i64 [%20, %$8] ; # Lo
  %31 = phi i64 [%21, %$8] ; # Hi
; # (set (big X) (box64 (+ Hi (* 10 (int @)))))
; # (big X)
  %32 = add i64 %29, 4
; # (int @)
  %33 = lshr i64 %26, 4
; # (* 10 (int @))
  %34 = mul i64 10, %33
; # (+ Hi (* 10 (int @)))
  %35 = add i64 %31, %34
; # (box64 (+ Hi (* 10 (int @))))
  %36 = and i64 %35, 17293822569102704640
  %37 = icmp ne i64 %36, 0
  br i1 %37, label %$12, label %$13
$12:
  %38 = call i64 @boxNum(i64 %35)
  br label %$14
$13:
  %39 = shl i64 %35, 4
  %40 = or i64 %39, 2
  br label %$14
$14:
  %41 = phi i64 [%38, %$12], [%40, %$13] ; # ->
  %42 = inttoptr i64 %32 to i64*
  store i64 %41, i64* %42
  br label %$10
$9:
  %43 = phi i64 [%19, %$8] ; # X
  %44 = phi i64 [%20, %$8] ; # Lo
  %45 = phi i64 [%21, %$8] ; # Hi
; # (dig X)
  %46 = add i64 %26, -4
; # (val (dig X))
  %47 = inttoptr i64 %46 to i64*
  %48 = load i64, i64* %47
; # (mul 10 (val (dig X)))
  %49 = zext i64 %48 to i128
  %50 = mul i128 10, %49
  %51 = lshr i128 %50, 64
  %52 = trunc i128 %51 to i64
  %53 = trunc i128 %50 to i64
; # (add (mul 10 (val (dig X))) Hi)
  %54 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %53, i64 %45)
  %55 = extractvalue {i64, i1} %54, 1
  %56 = extractvalue {i64, i1} %54, 0
; # (+ @@@ @@)
  %57 = zext i1 %55 to i64
  %58 = add i64 %52, %57
  br label %$8
$10:
  %59 = phi i64 [%29, %$14] ; # X
  %60 = phi i64 [%30, %$14] ; # Lo
  %61 = phi i64 [%31, %$14] ; # Hi
  %62 = phi i64 [%41, %$14] ; # ->
  br label %$4
$4:
  %63 = phi i64 [%10, %$7], [%0, %$10] ; # ->
  ret i64 %63
}

define i64 @shlu(i64) align 8 {
$1:
; # (if (cnt? N) (let X (add N N) (if @@ (boxNum (shr N 3)) (x| X 6))...
; # (cnt? N)
  %1 = and i64 %0, 2
  %2 = icmp ne i64 %1, 0
  br i1 %2, label %$2, label %$3
$2:
; # (let X (add N N) (if @@ (boxNum (shr N 3)) (x| X 6)))
; # (add N N)
  %3 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %0, i64 %0)
  %4 = extractvalue {i64, i1} %3, 1
  %5 = extractvalue {i64, i1} %3, 0
; # (if @@ (boxNum (shr N 3)) (x| X 6))
  br i1 %4, label %$5, label %$6
$5:
; # (shr N 3)
  %6 = lshr i64 %0, 3
; # (boxNum (shr N 3))
  %7 = call i64 @boxNum(i64 %6)
  br label %$7
$6:
; # (x| X 6)
  %8 = xor i64 %5, 6
  br label %$7
$7:
  %9 = phi i64 [%7, %$5], [%8, %$6] ; # ->
  br label %$4
$3:
; # (let (A (val (dig N)) X (boxNum (shl A 1)) Y (val (big N)) R (sav...
; # (dig N)
  %10 = add i64 %0, -4
; # (val (dig N))
  %11 = inttoptr i64 %10 to i64*
  %12 = load i64, i64* %11
; # (shl A 1)
  %13 = shl i64 %12, 1
; # (boxNum (shl A 1))
  %14 = call i64 @boxNum(i64 %13)
; # (big N)
  %15 = add i64 %0, 4
; # (val (big N))
  %16 = inttoptr i64 %15 to i64*
  %17 = load i64, i64* %16
; # (save X)
  %18 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %19 = load i64, i64* %18
  %20 = alloca i64, i64 2, align 16
  %21 = ptrtoint i64* %20 to i64
  %22 = inttoptr i64 %21 to i64*
  store i64 %14, i64* %22
  %23 = add i64 %21, 8
  %24 = inttoptr i64 %23 to i64*
  store i64 %19, i64* %24
  %25 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %21, i64* %25
; # (while (big? Y) (let B (val (dig Y)) (setq X (set (big X) (boxNum...
  br label %$8
$8:
  %26 = phi i64 [%12, %$3], [%36, %$9] ; # A
  %27 = phi i64 [%14, %$3], [%41, %$9] ; # X
  %28 = phi i64 [%17, %$3], [%45, %$9] ; # Y
; # (big? Y)
  %29 = and i64 %28, 4
  %30 = icmp ne i64 %29, 0
  br i1 %30, label %$9, label %$10
$9:
  %31 = phi i64 [%26, %$8] ; # A
  %32 = phi i64 [%27, %$8] ; # X
  %33 = phi i64 [%28, %$8] ; # Y
; # (let B (val (dig Y)) (setq X (set (big X) (boxNum (| (shl B 1) (s...
; # (dig Y)
  %34 = add i64 %33, -4
; # (val (dig Y))
  %35 = inttoptr i64 %34 to i64*
  %36 = load i64, i64* %35
; # (set (big X) (boxNum (| (shl B 1) (shl 0 A 1))))
; # (big X)
  %37 = add i64 %32, 4
; # (shl B 1)
  %38 = shl i64 %36, 1
; # (shl 0 A 1)
  %39 = call i64 @llvm.fshl.i64(i64 0, i64 %31, i64 1)
; # (| (shl B 1) (shl 0 A 1))
  %40 = or i64 %38, %39
; # (boxNum (| (shl B 1) (shl 0 A 1)))
  %41 = call i64 @boxNum(i64 %40)
  %42 = inttoptr i64 %37 to i64*
  store i64 %41, i64* %42
; # (big Y)
  %43 = add i64 %33, 4
; # (val (big Y))
  %44 = inttoptr i64 %43 to i64*
  %45 = load i64, i64* %44
  br label %$8
$10:
  %46 = phi i64 [%26, %$8] ; # A
  %47 = phi i64 [%27, %$8] ; # X
  %48 = phi i64 [%28, %$8] ; # Y
; # (set (big X) (box64 (| (shl (int Y) 1) (shl 0 A 1))))
; # (big X)
  %49 = add i64 %47, 4
; # (int Y)
  %50 = lshr i64 %48, 4
; # (shl (int Y) 1)
  %51 = shl i64 %50, 1
; # (shl 0 A 1)
  %52 = call i64 @llvm.fshl.i64(i64 0, i64 %46, i64 1)
; # (| (shl (int Y) 1) (shl 0 A 1))
  %53 = or i64 %51, %52
; # (box64 (| (shl (int Y) 1) (shl 0 A 1)))
  %54 = and i64 %53, 17293822569102704640
  %55 = icmp ne i64 %54, 0
  br i1 %55, label %$11, label %$12
$11:
  %56 = call i64 @boxNum(i64 %53)
  br label %$13
$12:
  %57 = shl i64 %53, 4
  %58 = or i64 %57, 2
  br label %$13
$13:
  %59 = phi i64 [%56, %$11], [%58, %$12] ; # ->
  %60 = inttoptr i64 %49 to i64*
  store i64 %59, i64* %60
; # (drop *Safe)
  %61 = inttoptr i64 %21 to i64*
  %62 = getelementptr i64, i64* %61, i32 1
  %63 = load i64, i64* %62
  %64 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %63, i64* %64
  br label %$4
$4:
  %65 = phi i64 [%9, %$7], [%14, %$13] ; # ->
  ret i64 %65
}

define i64 @shru(i64) align 8 {
$1:
; # (if (cnt? N) (| (& (shr N 1) -10) 2) (let A (shr (val (dig N)) 1)...
; # (cnt? N)
  %1 = and i64 %0, 2
  %2 = icmp ne i64 %1, 0
  br i1 %2, label %$2, label %$3
$2:
  %3 = phi i64 [%0, %$1] ; # N
; # (shr N 1)
  %4 = lshr i64 %3, 1
; # (& (shr N 1) -10)
  %5 = and i64 %4, -10
; # (| (& (shr N 1) -10) 2)
  %6 = or i64 %5, 2
  br label %$4
$3:
  %7 = phi i64 [%0, %$1] ; # N
; # (let A (shr (val (dig N)) 1) (if (big? (setq N (val (big N)))) (l...
; # (dig N)
  %8 = add i64 %7, -4
; # (val (dig N))
  %9 = inttoptr i64 %8 to i64*
  %10 = load i64, i64* %9
; # (shr (val (dig N)) 1)
  %11 = lshr i64 %10, 1
; # (if (big? (setq N (val (big N)))) (let (B (val (dig N)) P (boxNum...
; # (big N)
  %12 = add i64 %7, 4
; # (val (big N))
  %13 = inttoptr i64 %12 to i64*
  %14 = load i64, i64* %13
; # (big? (setq N (val (big N))))
  %15 = and i64 %14, 4
  %16 = icmp ne i64 %15, 0
  br i1 %16, label %$5, label %$6
$5:
  %17 = phi i64 [%14, %$3] ; # N
  %18 = phi i64 [%11, %$3] ; # A
; # (let (B (val (dig N)) P (boxNum (| (shr B 0 1) A)) R (save P)) (l...
; # (dig N)
  %19 = add i64 %17, -4
; # (val (dig N))
  %20 = inttoptr i64 %19 to i64*
  %21 = load i64, i64* %20
; # (shr B 0 1)
  %22 = call i64 @llvm.fshr.i64(i64 %21, i64 0, i64 1)
; # (| (shr B 0 1) A)
  %23 = or i64 %22, %18
; # (boxNum (| (shr B 0 1) A))
  %24 = call i64 @boxNum(i64 %23)
; # (save P)
  %25 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %26 = load i64, i64* %25
  %27 = alloca i64, i64 2, align 16
  %28 = ptrtoint i64* %27 to i64
  %29 = inttoptr i64 %28 to i64*
  store i64 %24, i64* %29
  %30 = add i64 %28, 8
  %31 = inttoptr i64 %30 to i64*
  store i64 %26, i64* %31
  %32 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %28, i64* %32
; # (loop (setq A (shr B 1)) (? (cnt? (setq N (val (big N))))) (setq ...
  br label %$8
$8:
  %33 = phi i64 [%17, %$5], [%43, %$9] ; # N
  %34 = phi i64 [%18, %$5], [%44, %$9] ; # A
  %35 = phi i64 [%21, %$5], [%49, %$9] ; # B
  %36 = phi i64 [%24, %$5], [%53, %$9] ; # P
; # (shr B 1)
  %37 = lshr i64 %35, 1
; # (? (cnt? (setq N (val (big N)))))
; # (big N)
  %38 = add i64 %33, 4
; # (val (big N))
  %39 = inttoptr i64 %38 to i64*
  %40 = load i64, i64* %39
; # (cnt? (setq N (val (big N))))
  %41 = and i64 %40, 2
  %42 = icmp ne i64 %41, 0
  br i1 %42, label %$10, label %$9
$9:
  %43 = phi i64 [%40, %$8] ; # N
  %44 = phi i64 [%37, %$8] ; # A
  %45 = phi i64 [%35, %$8] ; # B
  %46 = phi i64 [%36, %$8] ; # P
; # (dig N)
  %47 = add i64 %43, -4
; # (val (dig N))
  %48 = inttoptr i64 %47 to i64*
  %49 = load i64, i64* %48
; # (set (big P) (boxNum (| (shr B 0 1) A)))
; # (big P)
  %50 = add i64 %46, 4
; # (shr B 0 1)
  %51 = call i64 @llvm.fshr.i64(i64 %49, i64 0, i64 1)
; # (| (shr B 0 1) A)
  %52 = or i64 %51, %44
; # (boxNum (| (shr B 0 1) A))
  %53 = call i64 @boxNum(i64 %52)
  %54 = inttoptr i64 %50 to i64*
  store i64 %53, i64* %54
  br label %$8
$10:
  %55 = phi i64 [%40, %$8] ; # N
  %56 = phi i64 [%37, %$8] ; # A
  %57 = phi i64 [%35, %$8] ; # B
  %58 = phi i64 [%36, %$8] ; # P
  %59 = phi i64 [0, %$8] ; # ->
; # (int N)
  %60 = lshr i64 %55, 4
; # (shr N 0 1)
  %61 = call i64 @llvm.fshr.i64(i64 %60, i64 0, i64 1)
; # (| (shr N 0 1) A)
  %62 = or i64 %61, %56
; # (set (big P) (ifn (or (setq N (shr N 1)) (& A (hex "F000000000000...
; # (big P)
  %63 = add i64 %58, 4
; # (ifn (or (setq N (shr N 1)) (& A (hex "F000000000000000"))) (cnt ...
; # (or (setq N (shr N 1)) (& A (hex "F000000000000000")))
; # (shr N 1)
  %64 = lshr i64 %60, 1
  %65 = icmp ne i64 %64, 0
  br i1 %65, label %$11, label %$12
$12:
  %66 = phi i64 [%64, %$10] ; # N
  %67 = phi i64 [%62, %$10] ; # A
  %68 = phi i64 [%57, %$10] ; # B
  %69 = phi i64 [%58, %$10] ; # P
; # (& A (hex "F000000000000000"))
  %70 = and i64 %67, 17293822569102704640
  %71 = icmp ne i64 %70, 0
  br label %$11
$11:
  %72 = phi i64 [%64, %$10], [%66, %$12] ; # N
  %73 = phi i64 [%62, %$10], [%67, %$12] ; # A
  %74 = phi i64 [%57, %$10], [%68, %$12] ; # B
  %75 = phi i64 [%58, %$10], [%69, %$12] ; # P
  %76 = phi i1 [1, %$10], [%71, %$12] ; # ->
  br i1 %76, label %$14, label %$13
$13:
  %77 = phi i64 [%72, %$11] ; # N
  %78 = phi i64 [%73, %$11] ; # A
  %79 = phi i64 [%74, %$11] ; # B
  %80 = phi i64 [%75, %$11] ; # P
; # (cnt A)
  %81 = shl i64 %78, 4
  %82 = or i64 %81, 2
  br label %$15
$14:
  %83 = phi i64 [%72, %$11] ; # N
  %84 = phi i64 [%73, %$11] ; # A
  %85 = phi i64 [%74, %$11] ; # B
  %86 = phi i64 [%75, %$11] ; # P
; # (prog1 (boxNum A) (set (big @) (cnt N)))
; # (boxNum A)
  %87 = call i64 @boxNum(i64 %84)
; # (set (big @) (cnt N))
; # (big @)
  %88 = add i64 %87, 4
; # (cnt N)
  %89 = shl i64 %83, 4
  %90 = or i64 %89, 2
  %91 = inttoptr i64 %88 to i64*
  store i64 %90, i64* %91
  br label %$15
$15:
  %92 = phi i64 [%77, %$13], [%83, %$14] ; # N
  %93 = phi i64 [%78, %$13], [%84, %$14] ; # A
  %94 = phi i64 [%79, %$13], [%85, %$14] ; # B
  %95 = phi i64 [%80, %$13], [%86, %$14] ; # P
  %96 = phi i64 [%82, %$13], [%87, %$14] ; # ->
  %97 = inttoptr i64 %63 to i64*
  store i64 %96, i64* %97
; # (drop *Safe)
  %98 = inttoptr i64 %28 to i64*
  %99 = getelementptr i64, i64* %98, i32 1
  %100 = load i64, i64* %99
  %101 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %100, i64* %101
  br label %$7
$6:
  %102 = phi i64 [%14, %$3] ; # N
  %103 = phi i64 [%11, %$3] ; # A
; # (int N)
  %104 = lshr i64 %102, 4
; # (shr N 0 1)
  %105 = call i64 @llvm.fshr.i64(i64 %104, i64 0, i64 1)
; # (| (shr N 0 1) A)
  %106 = or i64 %105, %103
; # (ifn (or (setq N (shr N 1)) (& A (hex "F000000000000000"))) (cnt ...
; # (or (setq N (shr N 1)) (& A (hex "F000000000000000")))
; # (shr N 1)
  %107 = lshr i64 %104, 1
  %108 = icmp ne i64 %107, 0
  br i1 %108, label %$16, label %$17
$17:
  %109 = phi i64 [%107, %$6] ; # N
  %110 = phi i64 [%106, %$6] ; # A
; # (& A (hex "F000000000000000"))
  %111 = and i64 %110, 17293822569102704640
  %112 = icmp ne i64 %111, 0
  br label %$16
$16:
  %113 = phi i64 [%107, %$6], [%109, %$17] ; # N
  %114 = phi i64 [%106, %$6], [%110, %$17] ; # A
  %115 = phi i1 [1, %$6], [%112, %$17] ; # ->
  br i1 %115, label %$19, label %$18
$18:
  %116 = phi i64 [%113, %$16] ; # N
  %117 = phi i64 [%114, %$16] ; # A
; # (cnt A)
  %118 = shl i64 %117, 4
  %119 = or i64 %118, 2
  br label %$20
$19:
  %120 = phi i64 [%113, %$16] ; # N
  %121 = phi i64 [%114, %$16] ; # A
; # (prog1 (boxNum A) (set (big @) (cnt N)))
; # (boxNum A)
  %122 = call i64 @boxNum(i64 %121)
; # (set (big @) (cnt N))
; # (big @)
  %123 = add i64 %122, 4
; # (cnt N)
  %124 = shl i64 %120, 4
  %125 = or i64 %124, 2
  %126 = inttoptr i64 %123 to i64*
  store i64 %125, i64* %126
  br label %$20
$20:
  %127 = phi i64 [%116, %$18], [%120, %$19] ; # N
  %128 = phi i64 [%117, %$18], [%121, %$19] ; # A
  %129 = phi i64 [%119, %$18], [%122, %$19] ; # ->
  br label %$7
$7:
  %130 = phi i64 [%92, %$15], [%127, %$20] ; # N
  %131 = phi i64 [%93, %$15], [%128, %$20] ; # A
  %132 = phi i64 [%24, %$15], [%129, %$20] ; # ->
  br label %$4
$4:
  %133 = phi i64 [%3, %$2], [%130, %$7] ; # N
  %134 = phi i64 [%6, %$2], [%132, %$7] ; # ->
  ret i64 %134
}

define i64 @andu(i64, i64) align 8 {
$1:
; # (cond ((cnt? A) (& A (if (cnt? B) B (cnt (val (dig B)))))) ((cnt?...
; # (cnt? A)
  %2 = and i64 %0, 2
  %3 = icmp ne i64 %2, 0
  br i1 %3, label %$4, label %$3
$4:
  %4 = phi i64 [%0, %$1] ; # A
  %5 = phi i64 [%1, %$1] ; # B
; # (if (cnt? B) B (cnt (val (dig B))))
; # (cnt? B)
  %6 = and i64 %5, 2
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$5, label %$6
$5:
  %8 = phi i64 [%4, %$4] ; # A
  %9 = phi i64 [%5, %$4] ; # B
  br label %$7
$6:
  %10 = phi i64 [%4, %$4] ; # A
  %11 = phi i64 [%5, %$4] ; # B
; # (dig B)
  %12 = add i64 %11, -4
; # (val (dig B))
  %13 = inttoptr i64 %12 to i64*
  %14 = load i64, i64* %13
; # (cnt (val (dig B)))
  %15 = shl i64 %14, 4
  %16 = or i64 %15, 2
  br label %$7
$7:
  %17 = phi i64 [%8, %$5], [%10, %$6] ; # A
  %18 = phi i64 [%9, %$5], [%11, %$6] ; # B
  %19 = phi i64 [%9, %$5], [%16, %$6] ; # ->
; # (& A (if (cnt? B) B (cnt (val (dig B)))))
  %20 = and i64 %4, %19
  br label %$2
$3:
  %21 = phi i64 [%0, %$1] ; # A
  %22 = phi i64 [%1, %$1] ; # B
; # (cnt? B)
  %23 = and i64 %22, 2
  %24 = icmp ne i64 %23, 0
  br i1 %24, label %$9, label %$8
$9:
  %25 = phi i64 [%21, %$3] ; # A
  %26 = phi i64 [%22, %$3] ; # B
; # (dig A)
  %27 = add i64 %25, -4
; # (val (dig A))
  %28 = inttoptr i64 %27 to i64*
  %29 = load i64, i64* %28
; # (cnt (val (dig A)))
  %30 = shl i64 %29, 4
  %31 = or i64 %30, 2
; # (& B (cnt (val (dig A))))
  %32 = and i64 %26, %31
  br label %$2
$8:
  %33 = phi i64 [%21, %$3] ; # A
  %34 = phi i64 [%22, %$3] ; # B
; # (let (P (boxNum (& (val (dig A)) (val (dig B)))) R (save P)) (loo...
; # (dig A)
  %35 = add i64 %33, -4
; # (val (dig A))
  %36 = inttoptr i64 %35 to i64*
  %37 = load i64, i64* %36
; # (dig B)
  %38 = add i64 %34, -4
; # (val (dig B))
  %39 = inttoptr i64 %38 to i64*
  %40 = load i64, i64* %39
; # (& (val (dig A)) (val (dig B)))
  %41 = and i64 %37, %40
; # (boxNum (& (val (dig A)) (val (dig B))))
  %42 = call i64 @boxNum(i64 %41)
; # (save P)
  %43 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %44 = load i64, i64* %43
  %45 = alloca i64, i64 2, align 16
  %46 = ptrtoint i64* %45 to i64
  %47 = inttoptr i64 %46 to i64*
  store i64 %42, i64* %47
  %48 = add i64 %46, 8
  %49 = inttoptr i64 %48 to i64*
  store i64 %44, i64* %49
  %50 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %46, i64* %50
; # (loop (setq A (val (big A)) B (val (big B))) (? (cnt? A) (set (bi...
  br label %$10
$10:
  %51 = phi i64 [%33, %$8], [%101, %$17] ; # A
  %52 = phi i64 [%34, %$8], [%102, %$17] ; # B
  %53 = phi i64 [%42, %$8], [%112, %$17] ; # P
; # (big A)
  %54 = add i64 %51, 4
; # (val (big A))
  %55 = inttoptr i64 %54 to i64*
  %56 = load i64, i64* %55
; # (big B)
  %57 = add i64 %52, 4
; # (val (big B))
  %58 = inttoptr i64 %57 to i64*
  %59 = load i64, i64* %58
; # (? (cnt? A) (set (big P) (& A (if (cnt? B) B (cnt (val (dig B))))...
; # (cnt? A)
  %60 = and i64 %56, 2
  %61 = icmp ne i64 %60, 0
  br i1 %61, label %$13, label %$11
$13:
  %62 = phi i64 [%56, %$10] ; # A
  %63 = phi i64 [%59, %$10] ; # B
  %64 = phi i64 [%53, %$10] ; # P
; # (set (big P) (& A (if (cnt? B) B (cnt (val (dig B))))))
; # (big P)
  %65 = add i64 %64, 4
; # (if (cnt? B) B (cnt (val (dig B))))
; # (cnt? B)
  %66 = and i64 %63, 2
  %67 = icmp ne i64 %66, 0
  br i1 %67, label %$14, label %$15
$14:
  %68 = phi i64 [%62, %$13] ; # A
  %69 = phi i64 [%63, %$13] ; # B
  %70 = phi i64 [%64, %$13] ; # P
  br label %$16
$15:
  %71 = phi i64 [%62, %$13] ; # A
  %72 = phi i64 [%63, %$13] ; # B
  %73 = phi i64 [%64, %$13] ; # P
; # (dig B)
  %74 = add i64 %72, -4
; # (val (dig B))
  %75 = inttoptr i64 %74 to i64*
  %76 = load i64, i64* %75
; # (cnt (val (dig B)))
  %77 = shl i64 %76, 4
  %78 = or i64 %77, 2
  br label %$16
$16:
  %79 = phi i64 [%68, %$14], [%71, %$15] ; # A
  %80 = phi i64 [%69, %$14], [%72, %$15] ; # B
  %81 = phi i64 [%70, %$14], [%73, %$15] ; # P
  %82 = phi i64 [%69, %$14], [%78, %$15] ; # ->
; # (& A (if (cnt? B) B (cnt (val (dig B)))))
  %83 = and i64 %62, %82
  %84 = inttoptr i64 %65 to i64*
  store i64 %83, i64* %84
  br label %$12
$11:
  %85 = phi i64 [%56, %$10] ; # A
  %86 = phi i64 [%59, %$10] ; # B
  %87 = phi i64 [%53, %$10] ; # P
; # (? (cnt? B) (set (big P) (& B (cnt (val (dig A))))))
; # (cnt? B)
  %88 = and i64 %86, 2
  %89 = icmp ne i64 %88, 0
  br i1 %89, label %$18, label %$17
$18:
  %90 = phi i64 [%85, %$11] ; # A
  %91 = phi i64 [%86, %$11] ; # B
  %92 = phi i64 [%87, %$11] ; # P
; # (set (big P) (& B (cnt (val (dig A)))))
; # (big P)
  %93 = add i64 %92, 4
; # (dig A)
  %94 = add i64 %90, -4
; # (val (dig A))
  %95 = inttoptr i64 %94 to i64*
  %96 = load i64, i64* %95
; # (cnt (val (dig A)))
  %97 = shl i64 %96, 4
  %98 = or i64 %97, 2
; # (& B (cnt (val (dig A))))
  %99 = and i64 %91, %98
  %100 = inttoptr i64 %93 to i64*
  store i64 %99, i64* %100
  br label %$12
$17:
  %101 = phi i64 [%85, %$11] ; # A
  %102 = phi i64 [%86, %$11] ; # B
  %103 = phi i64 [%87, %$11] ; # P
; # (set (big P) (boxNum (& (val (dig A)) (val (dig B)))))
; # (big P)
  %104 = add i64 %103, 4
; # (dig A)
  %105 = add i64 %101, -4
; # (val (dig A))
  %106 = inttoptr i64 %105 to i64*
  %107 = load i64, i64* %106
; # (dig B)
  %108 = add i64 %102, -4
; # (val (dig B))
  %109 = inttoptr i64 %108 to i64*
  %110 = load i64, i64* %109
; # (& (val (dig A)) (val (dig B)))
  %111 = and i64 %107, %110
; # (boxNum (& (val (dig A)) (val (dig B))))
  %112 = call i64 @boxNum(i64 %111)
  %113 = inttoptr i64 %104 to i64*
  store i64 %112, i64* %113
  br label %$10
$12:
  %114 = phi i64 [%79, %$16], [%90, %$18] ; # A
  %115 = phi i64 [%80, %$16], [%91, %$18] ; # B
  %116 = phi i64 [%81, %$16], [%92, %$18] ; # P
  %117 = phi i64 [%83, %$16], [%99, %$18] ; # ->
; # (zapZero R)
  %118 = call i64 @zapZero(i64 %42)
; # (drop *Safe)
  %119 = inttoptr i64 %46 to i64*
  %120 = getelementptr i64, i64* %119, i32 1
  %121 = load i64, i64* %120
  %122 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %121, i64* %122
  br label %$2
$2:
  %123 = phi i64 [%17, %$7], [%25, %$9], [%114, %$12] ; # A
  %124 = phi i64 [%18, %$7], [%26, %$9], [%115, %$12] ; # B
  %125 = phi i64 [%20, %$7], [%32, %$9], [%118, %$12] ; # ->
  ret i64 %125
}

define i64 @oru(i64, i64) align 8 {
$1:
; # (cond ((cnt? A) (if (cnt? B) (| A B) (consNum (| (int A) (val (di...
; # (cnt? A)
  %2 = and i64 %0, 2
  %3 = icmp ne i64 %2, 0
  br i1 %3, label %$4, label %$3
$4:
  %4 = phi i64 [%0, %$1] ; # A
  %5 = phi i64 [%1, %$1] ; # B
; # (if (cnt? B) (| A B) (consNum (| (int A) (val (dig B))) (val (big...
; # (cnt? B)
  %6 = and i64 %5, 2
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$5, label %$6
$5:
  %8 = phi i64 [%4, %$4] ; # A
  %9 = phi i64 [%5, %$4] ; # B
; # (| A B)
  %10 = or i64 %8, %9
  br label %$7
$6:
  %11 = phi i64 [%4, %$4] ; # A
  %12 = phi i64 [%5, %$4] ; # B
; # (int A)
  %13 = lshr i64 %11, 4
; # (dig B)
  %14 = add i64 %12, -4
; # (val (dig B))
  %15 = inttoptr i64 %14 to i64*
  %16 = load i64, i64* %15
; # (| (int A) (val (dig B)))
  %17 = or i64 %13, %16
; # (big B)
  %18 = add i64 %12, 4
; # (val (big B))
  %19 = inttoptr i64 %18 to i64*
  %20 = load i64, i64* %19
; # (consNum (| (int A) (val (dig B))) (val (big B)))
  %21 = call i64 @consNum(i64 %17, i64 %20)
  br label %$7
$7:
  %22 = phi i64 [%8, %$5], [%11, %$6] ; # A
  %23 = phi i64 [%9, %$5], [%12, %$6] ; # B
  %24 = phi i64 [%10, %$5], [%21, %$6] ; # ->
  br label %$2
$3:
  %25 = phi i64 [%0, %$1] ; # A
  %26 = phi i64 [%1, %$1] ; # B
; # (cnt? B)
  %27 = and i64 %26, 2
  %28 = icmp ne i64 %27, 0
  br i1 %28, label %$9, label %$8
$9:
  %29 = phi i64 [%25, %$3] ; # A
  %30 = phi i64 [%26, %$3] ; # B
; # (int B)
  %31 = lshr i64 %30, 4
; # (dig A)
  %32 = add i64 %29, -4
; # (val (dig A))
  %33 = inttoptr i64 %32 to i64*
  %34 = load i64, i64* %33
; # (| (int B) (val (dig A)))
  %35 = or i64 %31, %34
; # (big A)
  %36 = add i64 %29, 4
; # (val (big A))
  %37 = inttoptr i64 %36 to i64*
  %38 = load i64, i64* %37
; # (consNum (| (int B) (val (dig A))) (val (big A)))
  %39 = call i64 @consNum(i64 %35, i64 %38)
  br label %$2
$8:
  %40 = phi i64 [%25, %$3] ; # A
  %41 = phi i64 [%26, %$3] ; # B
; # (let (P (boxNum (| (val (dig A)) (val (dig B)))) R (save P)) (loo...
; # (dig A)
  %42 = add i64 %40, -4
; # (val (dig A))
  %43 = inttoptr i64 %42 to i64*
  %44 = load i64, i64* %43
; # (dig B)
  %45 = add i64 %41, -4
; # (val (dig B))
  %46 = inttoptr i64 %45 to i64*
  %47 = load i64, i64* %46
; # (| (val (dig A)) (val (dig B)))
  %48 = or i64 %44, %47
; # (boxNum (| (val (dig A)) (val (dig B))))
  %49 = call i64 @boxNum(i64 %48)
; # (save P)
  %50 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %51 = load i64, i64* %50
  %52 = alloca i64, i64 2, align 16
  %53 = ptrtoint i64* %52 to i64
  %54 = inttoptr i64 %53 to i64*
  store i64 %49, i64* %54
  %55 = add i64 %53, 8
  %56 = inttoptr i64 %55 to i64*
  store i64 %51, i64* %56
  %57 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %53, i64* %57
; # (loop (setq A (val (big A)) B (val (big B))) (? (cnt? A) (set (bi...
  br label %$10
$10:
  %58 = phi i64 [%40, %$8], [%115, %$17] ; # A
  %59 = phi i64 [%41, %$8], [%116, %$17] ; # B
  %60 = phi i64 [%49, %$8], [%126, %$17] ; # P
; # (big A)
  %61 = add i64 %58, 4
; # (val (big A))
  %62 = inttoptr i64 %61 to i64*
  %63 = load i64, i64* %62
; # (big B)
  %64 = add i64 %59, 4
; # (val (big B))
  %65 = inttoptr i64 %64 to i64*
  %66 = load i64, i64* %65
; # (? (cnt? A) (set (big P) (if (cnt? B) (| A B) (consNum (| (int A)...
; # (cnt? A)
  %67 = and i64 %63, 2
  %68 = icmp ne i64 %67, 0
  br i1 %68, label %$13, label %$11
$13:
  %69 = phi i64 [%63, %$10] ; # A
  %70 = phi i64 [%66, %$10] ; # B
  %71 = phi i64 [%60, %$10] ; # P
; # (set (big P) (if (cnt? B) (| A B) (consNum (| (int A) (val (dig B...
; # (big P)
  %72 = add i64 %71, 4
; # (if (cnt? B) (| A B) (consNum (| (int A) (val (dig B))) (val (big...
; # (cnt? B)
  %73 = and i64 %70, 2
  %74 = icmp ne i64 %73, 0
  br i1 %74, label %$14, label %$15
$14:
  %75 = phi i64 [%69, %$13] ; # A
  %76 = phi i64 [%70, %$13] ; # B
  %77 = phi i64 [%71, %$13] ; # P
; # (| A B)
  %78 = or i64 %75, %76
  br label %$16
$15:
  %79 = phi i64 [%69, %$13] ; # A
  %80 = phi i64 [%70, %$13] ; # B
  %81 = phi i64 [%71, %$13] ; # P
; # (int A)
  %82 = lshr i64 %79, 4
; # (dig B)
  %83 = add i64 %80, -4
; # (val (dig B))
  %84 = inttoptr i64 %83 to i64*
  %85 = load i64, i64* %84
; # (| (int A) (val (dig B)))
  %86 = or i64 %82, %85
; # (big B)
  %87 = add i64 %80, 4
; # (val (big B))
  %88 = inttoptr i64 %87 to i64*
  %89 = load i64, i64* %88
; # (consNum (| (int A) (val (dig B))) (val (big B)))
  %90 = call i64 @consNum(i64 %86, i64 %89)
  br label %$16
$16:
  %91 = phi i64 [%75, %$14], [%79, %$15] ; # A
  %92 = phi i64 [%76, %$14], [%80, %$15] ; # B
  %93 = phi i64 [%77, %$14], [%81, %$15] ; # P
  %94 = phi i64 [%78, %$14], [%90, %$15] ; # ->
  %95 = inttoptr i64 %72 to i64*
  store i64 %94, i64* %95
  br label %$12
$11:
  %96 = phi i64 [%63, %$10] ; # A
  %97 = phi i64 [%66, %$10] ; # B
  %98 = phi i64 [%60, %$10] ; # P
; # (? (cnt? B) (set (big P) (consNum (| (int B) (val (dig A))) (val ...
; # (cnt? B)
  %99 = and i64 %97, 2
  %100 = icmp ne i64 %99, 0
  br i1 %100, label %$18, label %$17
$18:
  %101 = phi i64 [%96, %$11] ; # A
  %102 = phi i64 [%97, %$11] ; # B
  %103 = phi i64 [%98, %$11] ; # P
; # (set (big P) (consNum (| (int B) (val (dig A))) (val (big A))))
; # (big P)
  %104 = add i64 %103, 4
; # (int B)
  %105 = lshr i64 %102, 4
; # (dig A)
  %106 = add i64 %101, -4
; # (val (dig A))
  %107 = inttoptr i64 %106 to i64*
  %108 = load i64, i64* %107
; # (| (int B) (val (dig A)))
  %109 = or i64 %105, %108
; # (big A)
  %110 = add i64 %101, 4
; # (val (big A))
  %111 = inttoptr i64 %110 to i64*
  %112 = load i64, i64* %111
; # (consNum (| (int B) (val (dig A))) (val (big A)))
  %113 = call i64 @consNum(i64 %109, i64 %112)
  %114 = inttoptr i64 %104 to i64*
  store i64 %113, i64* %114
  br label %$12
$17:
  %115 = phi i64 [%96, %$11] ; # A
  %116 = phi i64 [%97, %$11] ; # B
  %117 = phi i64 [%98, %$11] ; # P
; # (set (big P) (boxNum (| (val (dig A)) (val (dig B)))))
; # (big P)
  %118 = add i64 %117, 4
; # (dig A)
  %119 = add i64 %115, -4
; # (val (dig A))
  %120 = inttoptr i64 %119 to i64*
  %121 = load i64, i64* %120
; # (dig B)
  %122 = add i64 %116, -4
; # (val (dig B))
  %123 = inttoptr i64 %122 to i64*
  %124 = load i64, i64* %123
; # (| (val (dig A)) (val (dig B)))
  %125 = or i64 %121, %124
; # (boxNum (| (val (dig A)) (val (dig B))))
  %126 = call i64 @boxNum(i64 %125)
  %127 = inttoptr i64 %118 to i64*
  store i64 %126, i64* %127
  br label %$10
$12:
  %128 = phi i64 [%91, %$16], [%101, %$18] ; # A
  %129 = phi i64 [%92, %$16], [%102, %$18] ; # B
  %130 = phi i64 [%93, %$16], [%103, %$18] ; # P
  %131 = phi i64 [%94, %$16], [%113, %$18] ; # ->
; # (drop *Safe)
  %132 = inttoptr i64 %53 to i64*
  %133 = getelementptr i64, i64* %132, i32 1
  %134 = load i64, i64* %133
  %135 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %134, i64* %135
  br label %$2
$2:
  %136 = phi i64 [%22, %$7], [%29, %$9], [%128, %$12] ; # A
  %137 = phi i64 [%23, %$7], [%30, %$9], [%129, %$12] ; # B
  %138 = phi i64 [%24, %$7], [%39, %$9], [%49, %$12] ; # ->
  ret i64 %138
}

define i64 @xoru(i64, i64) align 8 {
$1:
; # (cond ((cnt? A) (if (cnt? B) (| (x| A B) 2) (zapZero (consNum (x|...
; # (cnt? A)
  %2 = and i64 %0, 2
  %3 = icmp ne i64 %2, 0
  br i1 %3, label %$4, label %$3
$4:
  %4 = phi i64 [%0, %$1] ; # A
  %5 = phi i64 [%1, %$1] ; # B
; # (if (cnt? B) (| (x| A B) 2) (zapZero (consNum (x| (int A) (val (d...
; # (cnt? B)
  %6 = and i64 %5, 2
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$5, label %$6
$5:
  %8 = phi i64 [%4, %$4] ; # A
  %9 = phi i64 [%5, %$4] ; # B
; # (x| A B)
  %10 = xor i64 %8, %9
; # (| (x| A B) 2)
  %11 = or i64 %10, 2
  br label %$7
$6:
  %12 = phi i64 [%4, %$4] ; # A
  %13 = phi i64 [%5, %$4] ; # B
; # (int A)
  %14 = lshr i64 %12, 4
; # (dig B)
  %15 = add i64 %13, -4
; # (val (dig B))
  %16 = inttoptr i64 %15 to i64*
  %17 = load i64, i64* %16
; # (x| (int A) (val (dig B)))
  %18 = xor i64 %14, %17
; # (big B)
  %19 = add i64 %13, 4
; # (val (big B))
  %20 = inttoptr i64 %19 to i64*
  %21 = load i64, i64* %20
; # (consNum (x| (int A) (val (dig B))) (val (big B)))
  %22 = call i64 @consNum(i64 %18, i64 %21)
; # (zapZero (consNum (x| (int A) (val (dig B))) (val (big B))))
  %23 = call i64 @zapZero(i64 %22)
  br label %$7
$7:
  %24 = phi i64 [%8, %$5], [%12, %$6] ; # A
  %25 = phi i64 [%9, %$5], [%13, %$6] ; # B
  %26 = phi i64 [%11, %$5], [%23, %$6] ; # ->
  br label %$2
$3:
  %27 = phi i64 [%0, %$1] ; # A
  %28 = phi i64 [%1, %$1] ; # B
; # (cnt? B)
  %29 = and i64 %28, 2
  %30 = icmp ne i64 %29, 0
  br i1 %30, label %$9, label %$8
$9:
  %31 = phi i64 [%27, %$3] ; # A
  %32 = phi i64 [%28, %$3] ; # B
; # (int B)
  %33 = lshr i64 %32, 4
; # (dig A)
  %34 = add i64 %31, -4
; # (val (dig A))
  %35 = inttoptr i64 %34 to i64*
  %36 = load i64, i64* %35
; # (x| (int B) (val (dig A)))
  %37 = xor i64 %33, %36
; # (big A)
  %38 = add i64 %31, 4
; # (val (big A))
  %39 = inttoptr i64 %38 to i64*
  %40 = load i64, i64* %39
; # (consNum (x| (int B) (val (dig A))) (val (big A)))
  %41 = call i64 @consNum(i64 %37, i64 %40)
; # (zapZero (consNum (x| (int B) (val (dig A))) (val (big A))))
  %42 = call i64 @zapZero(i64 %41)
  br label %$2
$8:
  %43 = phi i64 [%27, %$3] ; # A
  %44 = phi i64 [%28, %$3] ; # B
; # (let (P (boxNum (x| (val (dig A)) (val (dig B)))) R (save P)) (lo...
; # (dig A)
  %45 = add i64 %43, -4
; # (val (dig A))
  %46 = inttoptr i64 %45 to i64*
  %47 = load i64, i64* %46
; # (dig B)
  %48 = add i64 %44, -4
; # (val (dig B))
  %49 = inttoptr i64 %48 to i64*
  %50 = load i64, i64* %49
; # (x| (val (dig A)) (val (dig B)))
  %51 = xor i64 %47, %50
; # (boxNum (x| (val (dig A)) (val (dig B))))
  %52 = call i64 @boxNum(i64 %51)
; # (save P)
  %53 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %54 = load i64, i64* %53
  %55 = alloca i64, i64 2, align 16
  %56 = ptrtoint i64* %55 to i64
  %57 = inttoptr i64 %56 to i64*
  store i64 %52, i64* %57
  %58 = add i64 %56, 8
  %59 = inttoptr i64 %58 to i64*
  store i64 %54, i64* %59
  %60 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %56, i64* %60
; # (loop (setq A (val (big A)) B (val (big B))) (? (cnt? A) (set (bi...
  br label %$10
$10:
  %61 = phi i64 [%43, %$8], [%119, %$17] ; # A
  %62 = phi i64 [%44, %$8], [%120, %$17] ; # B
  %63 = phi i64 [%52, %$8], [%130, %$17] ; # P
; # (big A)
  %64 = add i64 %61, 4
; # (val (big A))
  %65 = inttoptr i64 %64 to i64*
  %66 = load i64, i64* %65
; # (big B)
  %67 = add i64 %62, 4
; # (val (big B))
  %68 = inttoptr i64 %67 to i64*
  %69 = load i64, i64* %68
; # (? (cnt? A) (set (big P) (if (cnt? B) (| (x| A B) 2) (consNum (x|...
; # (cnt? A)
  %70 = and i64 %66, 2
  %71 = icmp ne i64 %70, 0
  br i1 %71, label %$13, label %$11
$13:
  %72 = phi i64 [%66, %$10] ; # A
  %73 = phi i64 [%69, %$10] ; # B
  %74 = phi i64 [%63, %$10] ; # P
; # (set (big P) (if (cnt? B) (| (x| A B) 2) (consNum (x| (int A) (va...
; # (big P)
  %75 = add i64 %74, 4
; # (if (cnt? B) (| (x| A B) 2) (consNum (x| (int A) (val (dig B))) (...
; # (cnt? B)
  %76 = and i64 %73, 2
  %77 = icmp ne i64 %76, 0
  br i1 %77, label %$14, label %$15
$14:
  %78 = phi i64 [%72, %$13] ; # A
  %79 = phi i64 [%73, %$13] ; # B
  %80 = phi i64 [%74, %$13] ; # P
; # (x| A B)
  %81 = xor i64 %78, %79
; # (| (x| A B) 2)
  %82 = or i64 %81, 2
  br label %$16
$15:
  %83 = phi i64 [%72, %$13] ; # A
  %84 = phi i64 [%73, %$13] ; # B
  %85 = phi i64 [%74, %$13] ; # P
; # (int A)
  %86 = lshr i64 %83, 4
; # (dig B)
  %87 = add i64 %84, -4
; # (val (dig B))
  %88 = inttoptr i64 %87 to i64*
  %89 = load i64, i64* %88
; # (x| (int A) (val (dig B)))
  %90 = xor i64 %86, %89
; # (big B)
  %91 = add i64 %84, 4
; # (val (big B))
  %92 = inttoptr i64 %91 to i64*
  %93 = load i64, i64* %92
; # (consNum (x| (int A) (val (dig B))) (val (big B)))
  %94 = call i64 @consNum(i64 %90, i64 %93)
  br label %$16
$16:
  %95 = phi i64 [%78, %$14], [%83, %$15] ; # A
  %96 = phi i64 [%79, %$14], [%84, %$15] ; # B
  %97 = phi i64 [%80, %$14], [%85, %$15] ; # P
  %98 = phi i64 [%82, %$14], [%94, %$15] ; # ->
  %99 = inttoptr i64 %75 to i64*
  store i64 %98, i64* %99
  br label %$12
$11:
  %100 = phi i64 [%66, %$10] ; # A
  %101 = phi i64 [%69, %$10] ; # B
  %102 = phi i64 [%63, %$10] ; # P
; # (? (cnt? B) (set (big P) (consNum (x| (int B) (val (dig A))) (val...
; # (cnt? B)
  %103 = and i64 %101, 2
  %104 = icmp ne i64 %103, 0
  br i1 %104, label %$18, label %$17
$18:
  %105 = phi i64 [%100, %$11] ; # A
  %106 = phi i64 [%101, %$11] ; # B
  %107 = phi i64 [%102, %$11] ; # P
; # (set (big P) (consNum (x| (int B) (val (dig A))) (val (big A))))
; # (big P)
  %108 = add i64 %107, 4
; # (int B)
  %109 = lshr i64 %106, 4
; # (dig A)
  %110 = add i64 %105, -4
; # (val (dig A))
  %111 = inttoptr i64 %110 to i64*
  %112 = load i64, i64* %111
; # (x| (int B) (val (dig A)))
  %113 = xor i64 %109, %112
; # (big A)
  %114 = add i64 %105, 4
; # (val (big A))
  %115 = inttoptr i64 %114 to i64*
  %116 = load i64, i64* %115
; # (consNum (x| (int B) (val (dig A))) (val (big A)))
  %117 = call i64 @consNum(i64 %113, i64 %116)
  %118 = inttoptr i64 %108 to i64*
  store i64 %117, i64* %118
  br label %$12
$17:
  %119 = phi i64 [%100, %$11] ; # A
  %120 = phi i64 [%101, %$11] ; # B
  %121 = phi i64 [%102, %$11] ; # P
; # (set (big P) (boxNum (x| (val (dig A)) (val (dig B)))))
; # (big P)
  %122 = add i64 %121, 4
; # (dig A)
  %123 = add i64 %119, -4
; # (val (dig A))
  %124 = inttoptr i64 %123 to i64*
  %125 = load i64, i64* %124
; # (dig B)
  %126 = add i64 %120, -4
; # (val (dig B))
  %127 = inttoptr i64 %126 to i64*
  %128 = load i64, i64* %127
; # (x| (val (dig A)) (val (dig B)))
  %129 = xor i64 %125, %128
; # (boxNum (x| (val (dig A)) (val (dig B))))
  %130 = call i64 @boxNum(i64 %129)
  %131 = inttoptr i64 %122 to i64*
  store i64 %130, i64* %131
  br label %$10
$12:
  %132 = phi i64 [%95, %$16], [%105, %$18] ; # A
  %133 = phi i64 [%96, %$16], [%106, %$18] ; # B
  %134 = phi i64 [%97, %$16], [%107, %$18] ; # P
  %135 = phi i64 [%98, %$16], [%117, %$18] ; # ->
; # (zapZero R)
  %136 = call i64 @zapZero(i64 %52)
; # (drop *Safe)
  %137 = inttoptr i64 %56 to i64*
  %138 = getelementptr i64, i64* %137, i32 1
  %139 = load i64, i64* %138
  %140 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %139, i64* %140
  br label %$2
$2:
  %141 = phi i64 [%24, %$7], [%31, %$9], [%132, %$12] ; # A
  %142 = phi i64 [%25, %$7], [%32, %$9], [%133, %$12] ; # B
  %143 = phi i64 [%26, %$7], [%42, %$9], [%136, %$12] ; # ->
  ret i64 %143
}

define i64 @addu(i64, i64) align 8 {
$1:
; # (cond ((cnt? A) (if (cnt? B) (box64 (+ (int A) (int B))) (xchg 'A...
; # (cnt? A)
  %2 = and i64 %0, 2
  %3 = icmp ne i64 %2, 0
  br i1 %3, label %$4, label %$3
$4:
  %4 = phi i64 [%0, %$1] ; # A
  %5 = phi i64 [%1, %$1] ; # B
; # (if (cnt? B) (box64 (+ (int A) (int B))) (xchg 'A 'B) (goto 1))
; # (cnt? B)
  %6 = and i64 %5, 2
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$5, label %$6
$5:
  %8 = phi i64 [%4, %$4] ; # A
  %9 = phi i64 [%5, %$4] ; # B
; # (int A)
  %10 = lshr i64 %8, 4
; # (int B)
  %11 = lshr i64 %9, 4
; # (+ (int A) (int B))
  %12 = add i64 %10, %11
; # (box64 (+ (int A) (int B)))
  %13 = and i64 %12, 17293822569102704640
  %14 = icmp ne i64 %13, 0
  br i1 %14, label %$8, label %$9
$8:
  %15 = call i64 @boxNum(i64 %12)
  br label %$10
$9:
  %16 = shl i64 %12, 4
  %17 = or i64 %16, 2
  br label %$10
$10:
  %18 = phi i64 [%15, %$8], [%17, %$9] ; # ->
  br label %$7
$6:
  %19 = phi i64 [%4, %$4] ; # A
  %20 = phi i64 [%5, %$4] ; # B
; # (xchg 'A 'B)
; # (goto 1)
  br label %$-1
$7:
  %21 = phi i64 [%8, %$10] ; # A
  %22 = phi i64 [%9, %$10] ; # B
  %23 = phi i64 [%18, %$10] ; # ->
  br label %$2
$3:
  %24 = phi i64 [%0, %$1] ; # A
  %25 = phi i64 [%1, %$1] ; # B
; # (cnt? B)
  %26 = and i64 %25, 2
  %27 = icmp ne i64 %26, 0
  br i1 %27, label %$12, label %$11
$12:
  %28 = phi i64 [%24, %$3] ; # A
  %29 = phi i64 [%25, %$3] ; # B
; # (: 1 (let N (val (big A)) (setq B (add (int B) (val (dig A)))) (i...
  br label %$-1
$-1:
  %30 = phi i64 [%20, %$6], [%28, %$12] ; # A
  %31 = phi i64 [%19, %$6], [%29, %$12] ; # B
; # (let N (val (big A)) (setq B (add (int B) (val (dig A)))) (ifn @@...
; # (big A)
  %32 = add i64 %30, 4
; # (val (big A))
  %33 = inttoptr i64 %32 to i64*
  %34 = load i64, i64* %33
; # (int B)
  %35 = lshr i64 %31, 4
; # (dig A)
  %36 = add i64 %30, -4
; # (val (dig A))
  %37 = inttoptr i64 %36 to i64*
  %38 = load i64, i64* %37
; # (add (int B) (val (dig A)))
  %39 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %35, i64 %38)
  %40 = extractvalue {i64, i1} %39, 1
  %41 = extractvalue {i64, i1} %39, 0
; # (ifn @@ (consNum B N) (let R (save (setq B (consNum B N))) (loop ...
  br i1 %40, label %$14, label %$13
$13:
  %42 = phi i64 [%30, %$-1] ; # A
  %43 = phi i64 [%41, %$-1] ; # B
  %44 = phi i64 [%34, %$-1] ; # N
; # (consNum B N)
  %45 = call i64 @consNum(i64 %43, i64 %44)
  br label %$15
$14:
  %46 = phi i64 [%30, %$-1] ; # A
  %47 = phi i64 [%41, %$-1] ; # B
  %48 = phi i64 [%34, %$-1] ; # N
; # (let R (save (setq B (consNum B N))) (loop (? (cnt? N) (setq N (a...
; # (consNum B N)
  %49 = call i64 @consNum(i64 %47, i64 %48)
; # (save (setq B (consNum B N)))
  %50 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %51 = load i64, i64* %50
  %52 = alloca i64, i64 2, align 16
  %53 = ptrtoint i64* %52 to i64
  %54 = inttoptr i64 %53 to i64*
  store i64 %49, i64* %54
  %55 = add i64 %53, 8
  %56 = inttoptr i64 %55 to i64*
  store i64 %51, i64* %56
  %57 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %53, i64* %57
; # (loop (? (cnt? N) (setq N (add N (hex "10"))) (set (big B) (ifn @...
  br label %$16
$16:
  %58 = phi i64 [%46, %$14], [%104, %$23] ; # A
  %59 = phi i64 [%49, %$14], [%109, %$23] ; # B
  %60 = phi i64 [%48, %$14], [%106, %$23] ; # N
; # (? (cnt? N) (setq N (add N (hex "10"))) (set (big B) (ifn @@ N (b...
; # (cnt? N)
  %61 = and i64 %60, 2
  %62 = icmp ne i64 %61, 0
  br i1 %62, label %$19, label %$17
$19:
  %63 = phi i64 [%58, %$16] ; # A
  %64 = phi i64 [%59, %$16] ; # B
  %65 = phi i64 [%60, %$16] ; # N
; # (add N (hex "10"))
  %66 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %65, i64 16)
  %67 = extractvalue {i64, i1} %66, 1
  %68 = extractvalue {i64, i1} %66, 0
; # (set (big B) (ifn @@ N (boxNum (| (int N) (hex "1000000000000000"...
; # (big B)
  %69 = add i64 %64, 4
; # (ifn @@ N (boxNum (| (int N) (hex "1000000000000000"))))
  br i1 %67, label %$21, label %$20
$20:
  %70 = phi i64 [%63, %$19] ; # A
  %71 = phi i64 [%64, %$19] ; # B
  %72 = phi i64 [%68, %$19] ; # N
  br label %$22
$21:
  %73 = phi i64 [%63, %$19] ; # A
  %74 = phi i64 [%64, %$19] ; # B
  %75 = phi i64 [%68, %$19] ; # N
; # (int N)
  %76 = lshr i64 %75, 4
; # (| (int N) (hex "1000000000000000"))
  %77 = or i64 %76, 1152921504606846976
; # (boxNum (| (int N) (hex "1000000000000000")))
  %78 = call i64 @boxNum(i64 %77)
  br label %$22
$22:
  %79 = phi i64 [%70, %$20], [%73, %$21] ; # A
  %80 = phi i64 [%71, %$20], [%74, %$21] ; # B
  %81 = phi i64 [%72, %$20], [%75, %$21] ; # N
  %82 = phi i64 [%72, %$20], [%78, %$21] ; # ->
  %83 = inttoptr i64 %69 to i64*
  store i64 %82, i64* %83
  br label %$18
$17:
  %84 = phi i64 [%58, %$16] ; # A
  %85 = phi i64 [%59, %$16] ; # B
  %86 = phi i64 [%60, %$16] ; # N
; # (let D (val (dig N)) (setq N (val (big N)) D (add D 1)) (? (not @...
; # (dig N)
  %87 = add i64 %86, -4
; # (val (dig N))
  %88 = inttoptr i64 %87 to i64*
  %89 = load i64, i64* %88
; # (big N)
  %90 = add i64 %86, 4
; # (val (big N))
  %91 = inttoptr i64 %90 to i64*
  %92 = load i64, i64* %91
; # (add D 1)
  %93 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %89, i64 1)
  %94 = extractvalue {i64, i1} %93, 1
  %95 = extractvalue {i64, i1} %93, 0
; # (? (not @@) (set (big B) (consNum D N)))
; # (not @@)
  %96 = icmp eq i1 %94, 0
  br i1 %96, label %$24, label %$23
$24:
  %97 = phi i64 [%84, %$17] ; # A
  %98 = phi i64 [%85, %$17] ; # B
  %99 = phi i64 [%92, %$17] ; # N
  %100 = phi i64 [%95, %$17] ; # D
; # (set (big B) (consNum D N))
; # (big B)
  %101 = add i64 %98, 4
; # (consNum D N)
  %102 = call i64 @consNum(i64 %100, i64 %99)
  %103 = inttoptr i64 %101 to i64*
  store i64 %102, i64* %103
  br label %$18
$23:
  %104 = phi i64 [%84, %$17] ; # A
  %105 = phi i64 [%85, %$17] ; # B
  %106 = phi i64 [%92, %$17] ; # N
  %107 = phi i64 [%95, %$17] ; # D
; # (set (big B) (consNum D N))
; # (big B)
  %108 = add i64 %105, 4
; # (consNum D N)
  %109 = call i64 @consNum(i64 %107, i64 %106)
  %110 = inttoptr i64 %108 to i64*
  store i64 %109, i64* %110
  br label %$16
$18:
  %111 = phi i64 [%79, %$22], [%97, %$24] ; # A
  %112 = phi i64 [%80, %$22], [%98, %$24] ; # B
  %113 = phi i64 [%81, %$22], [%99, %$24] ; # N
  %114 = phi i64 [%82, %$22], [%102, %$24] ; # ->
; # (drop *Safe)
  %115 = inttoptr i64 %53 to i64*
  %116 = getelementptr i64, i64* %115, i32 1
  %117 = load i64, i64* %116
  %118 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %117, i64* %118
  br label %$15
$15:
  %119 = phi i64 [%42, %$13], [%111, %$18] ; # A
  %120 = phi i64 [%43, %$13], [%112, %$18] ; # B
  %121 = phi i64 [%44, %$13], [%113, %$18] ; # N
  %122 = phi i64 [%45, %$13], [%49, %$18] ; # ->
  br label %$2
$11:
  %123 = phi i64 [%24, %$3] ; # A
  %124 = phi i64 [%25, %$3] ; # B
; # (let (N (add (val (dig A)) (val (dig B))) C @@ P (boxNum N) R (sa...
; # (dig A)
  %125 = add i64 %123, -4
; # (val (dig A))
  %126 = inttoptr i64 %125 to i64*
  %127 = load i64, i64* %126
; # (dig B)
  %128 = add i64 %124, -4
; # (val (dig B))
  %129 = inttoptr i64 %128 to i64*
  %130 = load i64, i64* %129
; # (add (val (dig A)) (val (dig B)))
  %131 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %127, i64 %130)
  %132 = extractvalue {i64, i1} %131, 1
  %133 = extractvalue {i64, i1} %131, 0
; # (boxNum N)
  %134 = call i64 @boxNum(i64 %133)
; # (save P)
  %135 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %136 = load i64, i64* %135
  %137 = alloca i64, i64 2, align 16
  %138 = ptrtoint i64* %137 to i64
  %139 = inttoptr i64 %138 to i64*
  store i64 %134, i64* %139
  %140 = add i64 %138, 8
  %141 = inttoptr i64 %140 to i64*
  store i64 %136, i64* %141
  %142 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %138, i64* %142
; # (loop (setq A (val (big A)) B (val (big B))) (? (cnt? A) (if (cnt...
  br label %$25
$25:
  %143 = phi i64 [%123, %$11], [%278, %$35] ; # A
  %144 = phi i64 [%124, %$11], [%279, %$35] ; # B
  %145 = phi i64 [%133, %$11], [%296, %$35] ; # N
  %146 = phi i1 [%132, %$11], [%295, %$35] ; # C
  %147 = phi i64 [%134, %$11], [%298, %$35] ; # P
; # (big A)
  %148 = add i64 %143, 4
; # (val (big A))
  %149 = inttoptr i64 %148 to i64*
  %150 = load i64, i64* %149
; # (big B)
  %151 = add i64 %144, 4
; # (val (big B))
  %152 = inttoptr i64 %151 to i64*
  %153 = load i64, i64* %152
; # (? (cnt? A) (if (cnt? B) (set (big P) (box64 (add (int A) (int B)...
; # (cnt? A)
  %154 = and i64 %150, 2
  %155 = icmp ne i64 %154, 0
  br i1 %155, label %$28, label %$26
$28:
  %156 = phi i64 [%150, %$25] ; # A
  %157 = phi i64 [%153, %$25] ; # B
  %158 = phi i64 [%145, %$25] ; # N
  %159 = phi i1 [%146, %$25] ; # C
  %160 = phi i64 [%147, %$25] ; # P
; # (if (cnt? B) (set (big P) (box64 (add (int A) (int B) C))) (xchg ...
; # (cnt? B)
  %161 = and i64 %157, 2
  %162 = icmp ne i64 %161, 0
  br i1 %162, label %$29, label %$30
$29:
  %163 = phi i64 [%156, %$28] ; # A
  %164 = phi i64 [%157, %$28] ; # B
  %165 = phi i64 [%158, %$28] ; # N
  %166 = phi i1 [%159, %$28] ; # C
  %167 = phi i64 [%160, %$28] ; # P
; # (set (big P) (box64 (add (int A) (int B) C)))
; # (big P)
  %168 = add i64 %167, 4
; # (int A)
  %169 = lshr i64 %163, 4
; # (int B)
  %170 = lshr i64 %164, 4
; # (add (int A) (int B) C)
  %171 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %169, i64 %170)
  %172 = extractvalue {i64, i1} %171, 1
  %173 = extractvalue {i64, i1} %171, 0
  %174 = zext i1 %166 to i64
  %175 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %173, i64 %174)
  %176 = extractvalue {i64, i1} %175, 1
  %177 = or i1 %172, %176
  %178 = extractvalue {i64, i1} %175, 0
; # (box64 (add (int A) (int B) C))
  %179 = and i64 %178, 17293822569102704640
  %180 = icmp ne i64 %179, 0
  br i1 %180, label %$32, label %$33
$32:
  %181 = call i64 @boxNum(i64 %178)
  br label %$34
$33:
  %182 = shl i64 %178, 4
  %183 = or i64 %182, 2
  br label %$34
$34:
  %184 = phi i64 [%181, %$32], [%183, %$33] ; # ->
  %185 = inttoptr i64 %168 to i64*
  store i64 %184, i64* %185
  br label %$31
$30:
  %186 = phi i64 [%156, %$28] ; # A
  %187 = phi i64 [%157, %$28] ; # B
  %188 = phi i64 [%158, %$28] ; # N
  %189 = phi i1 [%159, %$28] ; # C
  %190 = phi i64 [%160, %$28] ; # P
; # (xchg 'A 'B)
; # (goto 2)
  br label %$-2
$31:
  %191 = phi i64 [%163, %$34] ; # A
  %192 = phi i64 [%164, %$34] ; # B
  %193 = phi i64 [%165, %$34] ; # N
  %194 = phi i1 [%166, %$34] ; # C
  %195 = phi i64 [%167, %$34] ; # P
  %196 = phi i64 [%184, %$34] ; # ->
  br label %$27
$26:
  %197 = phi i64 [%150, %$25] ; # A
  %198 = phi i64 [%153, %$25] ; # B
  %199 = phi i64 [%145, %$25] ; # N
  %200 = phi i1 [%146, %$25] ; # C
  %201 = phi i64 [%147, %$25] ; # P
; # (? (cnt? B) (: 2 (setq N (add (int B) (val (dig A)) C) C @@) (loo...
; # (cnt? B)
  %202 = and i64 %198, 2
  %203 = icmp ne i64 %202, 0
  br i1 %203, label %$36, label %$35
$36:
  %204 = phi i64 [%197, %$26] ; # A
  %205 = phi i64 [%198, %$26] ; # B
  %206 = phi i64 [%199, %$26] ; # N
  %207 = phi i1 [%200, %$26] ; # C
  %208 = phi i64 [%201, %$26] ; # P
; # (: 2 (setq N (add (int B) (val (dig A)) C) C @@) (loop (setq P (s...
  br label %$-2
$-2:
  %209 = phi i64 [%187, %$30], [%204, %$36] ; # A
  %210 = phi i64 [%186, %$30], [%205, %$36] ; # B
  %211 = phi i64 [%188, %$30], [%206, %$36] ; # N
  %212 = phi i1 [%189, %$30], [%207, %$36] ; # C
  %213 = phi i64 [%190, %$30], [%208, %$36] ; # P
; # (int B)
  %214 = lshr i64 %210, 4
; # (dig A)
  %215 = add i64 %209, -4
; # (val (dig A))
  %216 = inttoptr i64 %215 to i64*
  %217 = load i64, i64* %216
; # (add (int B) (val (dig A)) C)
  %218 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %214, i64 %217)
  %219 = extractvalue {i64, i1} %218, 1
  %220 = extractvalue {i64, i1} %218, 0
  %221 = zext i1 %212 to i64
  %222 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %220, i64 %221)
  %223 = extractvalue {i64, i1} %222, 1
  %224 = or i1 %219, %223
  %225 = extractvalue {i64, i1} %222, 0
; # (loop (setq P (set (big P) (consNum N (setq A (val (big A)))))) (...
  br label %$37
$37:
  %226 = phi i64 [%209, %$-2], [%261, %$40] ; # A
  %227 = phi i64 [%210, %$-2], [%262, %$40] ; # B
  %228 = phi i64 [%225, %$-2], [%271, %$40] ; # N
  %229 = phi i1 [%224, %$-2], [%270, %$40] ; # C
  %230 = phi i64 [%213, %$-2], [%265, %$40] ; # P
; # (set (big P) (consNum N (setq A (val (big A)))))
; # (big P)
  %231 = add i64 %230, 4
; # (big A)
  %232 = add i64 %226, 4
; # (val (big A))
  %233 = inttoptr i64 %232 to i64*
  %234 = load i64, i64* %233
; # (consNum N (setq A (val (big A))))
  %235 = call i64 @consNum(i64 %228, i64 %234)
  %236 = inttoptr i64 %231 to i64*
  store i64 %235, i64* %236
; # (? (not C))
; # (not C)
  %237 = icmp eq i1 %229, 0
  br i1 %237, label %$39, label %$38
$38:
  %238 = phi i64 [%234, %$37] ; # A
  %239 = phi i64 [%227, %$37] ; # B
  %240 = phi i64 [%228, %$37] ; # N
  %241 = phi i1 [%229, %$37] ; # C
  %242 = phi i64 [%235, %$37] ; # P
; # (? (cnt? A) (set (big P) (box64 (+ (int A) C))))
; # (cnt? A)
  %243 = and i64 %238, 2
  %244 = icmp ne i64 %243, 0
  br i1 %244, label %$41, label %$40
$41:
  %245 = phi i64 [%238, %$38] ; # A
  %246 = phi i64 [%239, %$38] ; # B
  %247 = phi i64 [%240, %$38] ; # N
  %248 = phi i1 [%241, %$38] ; # C
  %249 = phi i64 [%242, %$38] ; # P
; # (set (big P) (box64 (+ (int A) C)))
; # (big P)
  %250 = add i64 %249, 4
; # (int A)
  %251 = lshr i64 %245, 4
; # (+ (int A) C)
  %252 = zext i1 %248 to i64
  %253 = add i64 %251, %252
; # (box64 (+ (int A) C))
  %254 = and i64 %253, 17293822569102704640
  %255 = icmp ne i64 %254, 0
  br i1 %255, label %$42, label %$43
$42:
  %256 = call i64 @boxNum(i64 %253)
  br label %$44
$43:
  %257 = shl i64 %253, 4
  %258 = or i64 %257, 2
  br label %$44
$44:
  %259 = phi i64 [%256, %$42], [%258, %$43] ; # ->
  %260 = inttoptr i64 %250 to i64*
  store i64 %259, i64* %260
  br label %$39
$40:
  %261 = phi i64 [%238, %$38] ; # A
  %262 = phi i64 [%239, %$38] ; # B
  %263 = phi i64 [%240, %$38] ; # N
  %264 = phi i1 [%241, %$38] ; # C
  %265 = phi i64 [%242, %$38] ; # P
; # (dig A)
  %266 = add i64 %261, -4
; # (val (dig A))
  %267 = inttoptr i64 %266 to i64*
  %268 = load i64, i64* %267
; # (add (val (dig A)) 1)
  %269 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %268, i64 1)
  %270 = extractvalue {i64, i1} %269, 1
  %271 = extractvalue {i64, i1} %269, 0
  br label %$37
$39:
  %272 = phi i64 [%234, %$37], [%245, %$44] ; # A
  %273 = phi i64 [%227, %$37], [%246, %$44] ; # B
  %274 = phi i64 [%228, %$37], [%247, %$44] ; # N
  %275 = phi i1 [%229, %$37], [%248, %$44] ; # C
  %276 = phi i64 [%235, %$37], [%249, %$44] ; # P
  %277 = phi i64 [0, %$37], [%259, %$44] ; # ->
  br label %$27
$35:
  %278 = phi i64 [%197, %$26] ; # A
  %279 = phi i64 [%198, %$26] ; # B
  %280 = phi i64 [%199, %$26] ; # N
  %281 = phi i1 [%200, %$26] ; # C
  %282 = phi i64 [%201, %$26] ; # P
; # (dig A)
  %283 = add i64 %278, -4
; # (val (dig A))
  %284 = inttoptr i64 %283 to i64*
  %285 = load i64, i64* %284
; # (dig B)
  %286 = add i64 %279, -4
; # (val (dig B))
  %287 = inttoptr i64 %286 to i64*
  %288 = load i64, i64* %287
; # (add (val (dig A)) (val (dig B)) C)
  %289 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %285, i64 %288)
  %290 = extractvalue {i64, i1} %289, 1
  %291 = extractvalue {i64, i1} %289, 0
  %292 = zext i1 %281 to i64
  %293 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %291, i64 %292)
  %294 = extractvalue {i64, i1} %293, 1
  %295 = or i1 %290, %294
  %296 = extractvalue {i64, i1} %293, 0
; # (set (big P) (boxNum N))
; # (big P)
  %297 = add i64 %282, 4
; # (boxNum N)
  %298 = call i64 @boxNum(i64 %296)
  %299 = inttoptr i64 %297 to i64*
  store i64 %298, i64* %299
  br label %$25
$27:
  %300 = phi i64 [%191, %$31], [%272, %$39] ; # A
  %301 = phi i64 [%192, %$31], [%273, %$39] ; # B
  %302 = phi i64 [%193, %$31], [%274, %$39] ; # N
  %303 = phi i1 [%194, %$31], [%275, %$39] ; # C
  %304 = phi i64 [%195, %$31], [%276, %$39] ; # P
  %305 = phi i64 [%196, %$31], [%277, %$39] ; # ->
; # (drop *Safe)
  %306 = inttoptr i64 %138 to i64*
  %307 = getelementptr i64, i64* %306, i32 1
  %308 = load i64, i64* %307
  %309 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %308, i64* %309
  br label %$2
$2:
  %310 = phi i64 [%21, %$7], [%119, %$15], [%300, %$27] ; # A
  %311 = phi i64 [%22, %$7], [%120, %$15], [%301, %$27] ; # B
  %312 = phi i64 [%23, %$7], [%122, %$15], [%134, %$27] ; # ->
  ret i64 %312
}

define i64 @sub1(i64, i64) align 8 {
$1:
; # (dig B)
  %2 = add i64 %0, -4
; # (val (dig B))
  %3 = inttoptr i64 %2 to i64*
  %4 = load i64, i64* %3
; # (int N)
  %5 = lshr i64 %1, 4
; # (sub (val (dig B)) (int N))
  %6 = call {i64, i1} @llvm.usub.with.overflow.i64(i64 %4, i64 %5)
  %7 = extractvalue {i64, i1} %6, 1
  %8 = extractvalue {i64, i1} %6, 0
; # (big B)
  %9 = add i64 %0, 4
; # (val (big B))
  %10 = inttoptr i64 %9 to i64*
  %11 = load i64, i64* %10
; # (nond (@@ (if (== B ZERO) (box64 N) (consNum N B))) ((big? B) (se...
  br i1 %7, label %$3, label %$4
$4:
  %12 = phi i64 [%11, %$1] ; # B
  %13 = phi i64 [%8, %$1] ; # N
; # (if (== B ZERO) (box64 N) (consNum N B))
; # (== B ZERO)
  %14 = icmp eq i64 %12, 2
  br i1 %14, label %$5, label %$6
$5:
  %15 = phi i64 [%12, %$4] ; # B
  %16 = phi i64 [%13, %$4] ; # N
; # (box64 N)
  %17 = and i64 %16, 17293822569102704640
  %18 = icmp ne i64 %17, 0
  br i1 %18, label %$8, label %$9
$8:
  %19 = call i64 @boxNum(i64 %16)
  br label %$10
$9:
  %20 = shl i64 %16, 4
  %21 = or i64 %20, 2
  br label %$10
$10:
  %22 = phi i64 [%19, %$8], [%21, %$9] ; # ->
  br label %$7
$6:
  %23 = phi i64 [%12, %$4] ; # B
  %24 = phi i64 [%13, %$4] ; # N
; # (consNum N B)
  %25 = call i64 @consNum(i64 %24, i64 %23)
  br label %$7
$7:
  %26 = phi i64 [%15, %$10], [%23, %$6] ; # B
  %27 = phi i64 [%16, %$10], [%24, %$6] ; # N
  %28 = phi i64 [%22, %$10], [%25, %$6] ; # ->
  br label %$2
$3:
  %29 = phi i64 [%11, %$1] ; # B
  %30 = phi i64 [%8, %$1] ; # N
; # (big? B)
  %31 = and i64 %29, 4
  %32 = icmp ne i64 %31, 0
  br i1 %32, label %$11, label %$12
$12:
  %33 = phi i64 [%29, %$3] ; # B
  %34 = phi i64 [%30, %$3] ; # N
; # (sub B (hex "10"))
  %35 = call {i64, i1} @llvm.usub.with.overflow.i64(i64 %33, i64 16)
  %36 = extractvalue {i64, i1} %35, 1
  %37 = extractvalue {i64, i1} %35, 0
; # (if @@ (sign (cnt (- N))) (zapZero (consNum N B)))
  br i1 %36, label %$13, label %$14
$13:
  %38 = phi i64 [%37, %$12] ; # B
  %39 = phi i64 [%34, %$12] ; # N
; # (- N)
  %40 = sub i64 0, %39
; # (cnt (- N))
  %41 = shl i64 %40, 4
  %42 = or i64 %41, 2
; # (sign (cnt (- N)))
  %43 = or i64 %42, 8
  br label %$15
$14:
  %44 = phi i64 [%37, %$12] ; # B
  %45 = phi i64 [%34, %$12] ; # N
; # (consNum N B)
  %46 = call i64 @consNum(i64 %45, i64 %44)
; # (zapZero (consNum N B))
  %47 = call i64 @zapZero(i64 %46)
  br label %$15
$15:
  %48 = phi i64 [%38, %$13], [%44, %$14] ; # B
  %49 = phi i64 [%39, %$13], [%45, %$14] ; # N
  %50 = phi i64 [%43, %$13], [%47, %$14] ; # ->
  br label %$2
$11:
  %51 = phi i64 [%29, %$3] ; # B
  %52 = phi i64 [%30, %$3] ; # N
; # (let (P (boxNum N B) R (save P)) (loop (setq N (sub (val (dig B))...
; # (boxNum N B)
  %53 = call i64 @boxNum(i64 %52)
; # (save P)
  %54 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %55 = load i64, i64* %54
  %56 = alloca i64, i64 2, align 16
  %57 = ptrtoint i64* %56 to i64
  %58 = inttoptr i64 %57 to i64*
  store i64 %53, i64* %58
  %59 = add i64 %57, 8
  %60 = inttoptr i64 %59 to i64*
  store i64 %55, i64* %60
  %61 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %57, i64* %61
; # (loop (setq N (sub (val (dig B)) 1) B (val (big B))) (? (not @@) ...
  br label %$16
$16:
  %62 = phi i64 [%51, %$11], [%97, %$20] ; # B
  %63 = phi i64 [%52, %$11], [%98, %$20] ; # N
  %64 = phi i64 [%53, %$11], [%99, %$20] ; # P
; # (dig B)
  %65 = add i64 %62, -4
; # (val (dig B))
  %66 = inttoptr i64 %65 to i64*
  %67 = load i64, i64* %66
; # (sub (val (dig B)) 1)
  %68 = call {i64, i1} @llvm.usub.with.overflow.i64(i64 %67, i64 1)
  %69 = extractvalue {i64, i1} %68, 1
  %70 = extractvalue {i64, i1} %68, 0
; # (big B)
  %71 = add i64 %62, 4
; # (val (big B))
  %72 = inttoptr i64 %71 to i64*
  %73 = load i64, i64* %72
; # (? (not @@) (set (big P) (consNum N B)))
; # (not @@)
  %74 = icmp eq i1 %69, 0
  br i1 %74, label %$19, label %$17
$19:
  %75 = phi i64 [%73, %$16] ; # B
  %76 = phi i64 [%70, %$16] ; # N
  %77 = phi i64 [%64, %$16] ; # P
; # (set (big P) (consNum N B))
; # (big P)
  %78 = add i64 %77, 4
; # (consNum N B)
  %79 = call i64 @consNum(i64 %76, i64 %75)
  %80 = inttoptr i64 %78 to i64*
  store i64 %79, i64* %80
  br label %$18
$17:
  %81 = phi i64 [%73, %$16] ; # B
  %82 = phi i64 [%70, %$16] ; # N
  %83 = phi i64 [%64, %$16] ; # P
; # (set (big P) (consNum N B))
; # (big P)
  %84 = add i64 %83, 4
; # (consNum N B)
  %85 = call i64 @consNum(i64 %82, i64 %81)
  %86 = inttoptr i64 %84 to i64*
  store i64 %85, i64* %86
; # (? (cnt? B) (set (big P) (sub B (hex "10"))))
; # (cnt? B)
  %87 = and i64 %81, 2
  %88 = icmp ne i64 %87, 0
  br i1 %88, label %$21, label %$20
$21:
  %89 = phi i64 [%81, %$17] ; # B
  %90 = phi i64 [%82, %$17] ; # N
  %91 = phi i64 [%85, %$17] ; # P
; # (set (big P) (sub B (hex "10")))
; # (big P)
  %92 = add i64 %91, 4
; # (sub B (hex "10"))
  %93 = call {i64, i1} @llvm.usub.with.overflow.i64(i64 %89, i64 16)
  %94 = extractvalue {i64, i1} %93, 1
  %95 = extractvalue {i64, i1} %93, 0
  %96 = inttoptr i64 %92 to i64*
  store i64 %95, i64* %96
  br label %$18
$20:
  %97 = phi i64 [%81, %$17] ; # B
  %98 = phi i64 [%82, %$17] ; # N
  %99 = phi i64 [%85, %$17] ; # P
  br label %$16
$18:
  %100 = phi i64 [%75, %$19], [%89, %$21] ; # B
  %101 = phi i64 [%76, %$19], [%90, %$21] ; # N
  %102 = phi i64 [%77, %$19], [%91, %$21] ; # P
  %103 = phi i64 [%79, %$19], [%95, %$21] ; # ->
; # (zapZero R)
  %104 = call i64 @zapZero(i64 %53)
; # (drop *Safe)
  %105 = inttoptr i64 %57 to i64*
  %106 = getelementptr i64, i64* %105, i32 1
  %107 = load i64, i64* %106
  %108 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %107, i64* %108
  br label %$2
$2:
  %109 = phi i64 [%26, %$7], [%48, %$15], [%100, %$18] ; # B
  %110 = phi i64 [%27, %$7], [%49, %$15], [%101, %$18] ; # N
  %111 = phi i64 [%28, %$7], [%50, %$15], [%104, %$18] ; # ->
  ret i64 %111
}

define i64 @subu(i64, i64) align 8 {
$1:
; # (cond ((cnt? A) (if (cnt? B) (let N (sub A (& B -3)) (if @@ (+ (x...
; # (cnt? A)
  %2 = and i64 %0, 2
  %3 = icmp ne i64 %2, 0
  br i1 %3, label %$4, label %$3
$4:
  %4 = phi i64 [%0, %$1] ; # A
  %5 = phi i64 [%1, %$1] ; # B
; # (if (cnt? B) (let N (sub A (& B -3)) (if @@ (+ (x| N -16) (hex "1...
; # (cnt? B)
  %6 = and i64 %5, 2
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$5, label %$6
$5:
  %8 = phi i64 [%4, %$4] ; # A
  %9 = phi i64 [%5, %$4] ; # B
; # (let N (sub A (& B -3)) (if @@ (+ (x| N -16) (hex "18")) N))
; # (& B -3)
  %10 = and i64 %9, -3
; # (sub A (& B -3))
  %11 = call {i64, i1} @llvm.usub.with.overflow.i64(i64 %8, i64 %10)
  %12 = extractvalue {i64, i1} %11, 1
  %13 = extractvalue {i64, i1} %11, 0
; # (if @@ (+ (x| N -16) (hex "18")) N)
  br i1 %12, label %$8, label %$9
$8:
  %14 = phi i64 [%8, %$5] ; # A
  %15 = phi i64 [%9, %$5] ; # B
; # (x| N -16)
  %16 = xor i64 %13, -16
; # (+ (x| N -16) (hex "18"))
  %17 = add i64 %16, 24
  br label %$10
$9:
  %18 = phi i64 [%8, %$5] ; # A
  %19 = phi i64 [%9, %$5] ; # B
  br label %$10
$10:
  %20 = phi i64 [%14, %$8], [%18, %$9] ; # A
  %21 = phi i64 [%15, %$8], [%19, %$9] ; # B
  %22 = phi i64 [%17, %$8], [%13, %$9] ; # ->
  br label %$7
$6:
  %23 = phi i64 [%4, %$4] ; # A
  %24 = phi i64 [%5, %$4] ; # B
; # (sub1 B A)
  %25 = call i64 @sub1(i64 %24, i64 %23)
; # (neg (sub1 B A))
  %26 = icmp eq i64 %25, 2
  br i1 %26, label %$11, label %$12
$11:
  br label %$13
$12:
  %27 = xor i64 %25, 8
  br label %$13
$13:
  %28 = phi i64 [%25, %$11], [%27, %$12] ; # ->
  br label %$7
$7:
  %29 = phi i64 [%20, %$10], [%23, %$13] ; # A
  %30 = phi i64 [%21, %$10], [%24, %$13] ; # B
  %31 = phi i64 [%22, %$10], [%28, %$13] ; # ->
  br label %$2
$3:
  %32 = phi i64 [%0, %$1] ; # A
  %33 = phi i64 [%1, %$1] ; # B
; # (cnt? B)
  %34 = and i64 %33, 2
  %35 = icmp ne i64 %34, 0
  br i1 %35, label %$15, label %$14
$15:
  %36 = phi i64 [%32, %$3] ; # A
  %37 = phi i64 [%33, %$3] ; # B
; # (sub1 A B)
  %38 = call i64 @sub1(i64 %36, i64 %37)
  br label %$2
$14:
  %39 = phi i64 [%32, %$3] ; # A
  %40 = phi i64 [%33, %$3] ; # B
; # (let (N (sub (val (dig A)) (val (dig B))) C @@ P (boxNum N) R (sa...
; # (dig A)
  %41 = add i64 %39, -4
; # (val (dig A))
  %42 = inttoptr i64 %41 to i64*
  %43 = load i64, i64* %42
; # (dig B)
  %44 = add i64 %40, -4
; # (val (dig B))
  %45 = inttoptr i64 %44 to i64*
  %46 = load i64, i64* %45
; # (sub (val (dig A)) (val (dig B)))
  %47 = call {i64, i1} @llvm.usub.with.overflow.i64(i64 %43, i64 %46)
  %48 = extractvalue {i64, i1} %47, 1
  %49 = extractvalue {i64, i1} %47, 0
; # (boxNum N)
  %50 = call i64 @boxNum(i64 %49)
; # (save P)
  %51 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %52 = load i64, i64* %51
  %53 = alloca i64, i64 2, align 16
  %54 = ptrtoint i64* %53 to i64
  %55 = inttoptr i64 %54 to i64*
  store i64 %50, i64* %55
  %56 = add i64 %54, 8
  %57 = inttoptr i64 %56 to i64*
  store i64 %52, i64* %57
  %58 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %54, i64* %58
; # (loop (setq A (val (big A)) B (val (big B))) (? (cnt? B) (setq B ...
  br label %$16
$16:
  %59 = phi i64 [%39, %$14], [%177, %$25] ; # A
  %60 = phi i64 [%40, %$14], [%178, %$25] ; # B
  %61 = phi i64 [%49, %$14], [%195, %$25] ; # N
  %62 = phi i1 [%48, %$14], [%194, %$25] ; # C
  %63 = phi i64 [%50, %$14], [%197, %$25] ; # P
; # (big A)
  %64 = add i64 %59, 4
; # (val (big A))
  %65 = inttoptr i64 %64 to i64*
  %66 = load i64, i64* %65
; # (big B)
  %67 = add i64 %60, 4
; # (val (big B))
  %68 = inttoptr i64 %67 to i64*
  %69 = load i64, i64* %68
; # (? (cnt? B) (setq B (int B)) (until (cnt? A) (setq N (sub (val (d...
; # (cnt? B)
  %70 = and i64 %69, 2
  %71 = icmp ne i64 %70, 0
  br i1 %71, label %$19, label %$17
$19:
  %72 = phi i64 [%66, %$16] ; # A
  %73 = phi i64 [%69, %$16] ; # B
  %74 = phi i64 [%61, %$16] ; # N
  %75 = phi i1 [%62, %$16] ; # C
  %76 = phi i64 [%63, %$16] ; # P
; # (int B)
  %77 = lshr i64 %73, 4
; # (until (cnt? A) (setq N (sub (val (dig A)) B C) C @@ A (val (big ...
  br label %$20
$20:
  %78 = phi i64 [%72, %$19], [%117, %$24] ; # A
  %79 = phi i64 [%77, %$19], [0, %$24] ; # B
  %80 = phi i64 [%74, %$19], [%119, %$24] ; # N
  %81 = phi i1 [%75, %$19], [%120, %$24] ; # C
  %82 = phi i64 [%76, %$19], [%121, %$24] ; # P
; # (cnt? A)
  %83 = and i64 %78, 2
  %84 = icmp ne i64 %83, 0
  br i1 %84, label %$22, label %$21
$21:
  %85 = phi i64 [%78, %$20] ; # A
  %86 = phi i64 [%79, %$20] ; # B
  %87 = phi i64 [%80, %$20] ; # N
  %88 = phi i1 [%81, %$20] ; # C
  %89 = phi i64 [%82, %$20] ; # P
; # (dig A)
  %90 = add i64 %85, -4
; # (val (dig A))
  %91 = inttoptr i64 %90 to i64*
  %92 = load i64, i64* %91
; # (sub (val (dig A)) B C)
  %93 = call {i64, i1} @llvm.usub.with.overflow.i64(i64 %92, i64 %86)
  %94 = extractvalue {i64, i1} %93, 1
  %95 = extractvalue {i64, i1} %93, 0
  %96 = zext i1 %88 to i64
  %97 = call {i64, i1} @llvm.usub.with.overflow.i64(i64 %95, i64 %96)
  %98 = extractvalue {i64, i1} %97, 1
  %99 = or i1 %94, %98
  %100 = extractvalue {i64, i1} %97, 0
; # (big A)
  %101 = add i64 %85, 4
; # (val (big A))
  %102 = inttoptr i64 %101 to i64*
  %103 = load i64, i64* %102
; # (set (big P) (consNum N A))
; # (big P)
  %104 = add i64 %89, 4
; # (consNum N A)
  %105 = call i64 @consNum(i64 %100, i64 %103)
  %106 = inttoptr i64 %104 to i64*
  store i64 %105, i64* %106
; # (unless C (ret (zapZero R)))
  br i1 %99, label %$24, label %$23
$23:
  %107 = phi i64 [%103, %$21] ; # A
  %108 = phi i64 [%86, %$21] ; # B
  %109 = phi i64 [%100, %$21] ; # N
  %110 = phi i1 [%99, %$21] ; # C
  %111 = phi i64 [%105, %$21] ; # P
; # (zapZero R)
  %112 = call i64 @zapZero(i64 %50)
; # (ret (zapZero R))
; # (drop *Safe)
  %113 = inttoptr i64 %54 to i64*
  %114 = getelementptr i64, i64* %113, i32 1
  %115 = load i64, i64* %114
  %116 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %115, i64* %116
  ret i64 %112
$24:
  %117 = phi i64 [%103, %$21] ; # A
  %118 = phi i64 [%86, %$21] ; # B
  %119 = phi i64 [%100, %$21] ; # N
  %120 = phi i1 [%99, %$21] ; # C
  %121 = phi i64 [%105, %$21] ; # P
  br label %$20
$22:
  %122 = phi i64 [%78, %$20] ; # A
  %123 = phi i64 [%79, %$20] ; # B
  %124 = phi i64 [%80, %$20] ; # N
  %125 = phi i1 [%81, %$20] ; # C
  %126 = phi i64 [%82, %$20] ; # P
; # (int A)
  %127 = lshr i64 %122, 4
  br label %$18
$17:
  %128 = phi i64 [%66, %$16] ; # A
  %129 = phi i64 [%69, %$16] ; # B
  %130 = phi i64 [%61, %$16] ; # N
  %131 = phi i1 [%62, %$16] ; # C
  %132 = phi i64 [%63, %$16] ; # P
; # (? (cnt? A) (setq A (int A)) (loop (setq N (sub A (val (dig B)) C...
; # (cnt? A)
  %133 = and i64 %128, 2
  %134 = icmp ne i64 %133, 0
  br i1 %134, label %$26, label %$25
$26:
  %135 = phi i64 [%128, %$17] ; # A
  %136 = phi i64 [%129, %$17] ; # B
  %137 = phi i64 [%130, %$17] ; # N
  %138 = phi i1 [%131, %$17] ; # C
  %139 = phi i64 [%132, %$17] ; # P
; # (int A)
  %140 = lshr i64 %135, 4
; # (loop (setq N (sub A (val (dig B)) C) C @@ P (set (big P) (boxNum...
  br label %$27
$27:
  %141 = phi i64 [%140, %$26], [%165, %$28] ; # A
  %142 = phi i64 [%136, %$26], [%166, %$28] ; # B
  %143 = phi i64 [%137, %$26], [%167, %$28] ; # N
  %144 = phi i1 [%138, %$26], [%168, %$28] ; # C
  %145 = phi i64 [%139, %$26], [%169, %$28] ; # P
; # (dig B)
  %146 = add i64 %142, -4
; # (val (dig B))
  %147 = inttoptr i64 %146 to i64*
  %148 = load i64, i64* %147
; # (sub A (val (dig B)) C)
  %149 = call {i64, i1} @llvm.usub.with.overflow.i64(i64 %141, i64 %148)
  %150 = extractvalue {i64, i1} %149, 1
  %151 = extractvalue {i64, i1} %149, 0
  %152 = zext i1 %144 to i64
  %153 = call {i64, i1} @llvm.usub.with.overflow.i64(i64 %151, i64 %152)
  %154 = extractvalue {i64, i1} %153, 1
  %155 = or i1 %150, %154
  %156 = extractvalue {i64, i1} %153, 0
; # (set (big P) (boxNum N))
; # (big P)
  %157 = add i64 %145, 4
; # (boxNum N)
  %158 = call i64 @boxNum(i64 %156)
  %159 = inttoptr i64 %157 to i64*
  store i64 %158, i64* %159
; # (? (cnt? (setq B (val (big B)))))
; # (big B)
  %160 = add i64 %142, 4
; # (val (big B))
  %161 = inttoptr i64 %160 to i64*
  %162 = load i64, i64* %161
; # (cnt? (setq B (val (big B))))
  %163 = and i64 %162, 2
  %164 = icmp ne i64 %163, 0
  br i1 %164, label %$29, label %$28
$28:
  %165 = phi i64 [0, %$27] ; # A
  %166 = phi i64 [%162, %$27] ; # B
  %167 = phi i64 [%156, %$27] ; # N
  %168 = phi i1 [%155, %$27] ; # C
  %169 = phi i64 [%158, %$27] ; # P
  br label %$27
$29:
  %170 = phi i64 [0, %$27] ; # A
  %171 = phi i64 [%162, %$27] ; # B
  %172 = phi i64 [%156, %$27] ; # N
  %173 = phi i1 [%155, %$27] ; # C
  %174 = phi i64 [%158, %$27] ; # P
  %175 = phi i64 [0, %$27] ; # ->
; # (int B)
  %176 = lshr i64 %171, 4
  br label %$18
$25:
  %177 = phi i64 [%128, %$17] ; # A
  %178 = phi i64 [%129, %$17] ; # B
  %179 = phi i64 [%130, %$17] ; # N
  %180 = phi i1 [%131, %$17] ; # C
  %181 = phi i64 [%132, %$17] ; # P
; # (dig A)
  %182 = add i64 %177, -4
; # (val (dig A))
  %183 = inttoptr i64 %182 to i64*
  %184 = load i64, i64* %183
; # (dig B)
  %185 = add i64 %178, -4
; # (val (dig B))
  %186 = inttoptr i64 %185 to i64*
  %187 = load i64, i64* %186
; # (sub (val (dig A)) (val (dig B)) C)
  %188 = call {i64, i1} @llvm.usub.with.overflow.i64(i64 %184, i64 %187)
  %189 = extractvalue {i64, i1} %188, 1
  %190 = extractvalue {i64, i1} %188, 0
  %191 = zext i1 %180 to i64
  %192 = call {i64, i1} @llvm.usub.with.overflow.i64(i64 %190, i64 %191)
  %193 = extractvalue {i64, i1} %192, 1
  %194 = or i1 %189, %193
  %195 = extractvalue {i64, i1} %192, 0
; # (set (big P) (boxNum N))
; # (big P)
  %196 = add i64 %181, 4
; # (boxNum N)
  %197 = call i64 @boxNum(i64 %195)
  %198 = inttoptr i64 %196 to i64*
  store i64 %197, i64* %198
  br label %$16
$18:
  %199 = phi i64 [%127, %$22], [%170, %$29] ; # A
  %200 = phi i64 [%123, %$22], [%176, %$29] ; # B
  %201 = phi i64 [%124, %$22], [%172, %$29] ; # N
  %202 = phi i1 [%125, %$22], [%173, %$29] ; # C
  %203 = phi i64 [%126, %$22], [%174, %$29] ; # P
  %204 = phi i64 [%127, %$22], [%176, %$29] ; # ->
; # (set (big P) (cnt (sub A B C)))
; # (big P)
  %205 = add i64 %203, 4
; # (sub A B C)
  %206 = call {i64, i1} @llvm.usub.with.overflow.i64(i64 %199, i64 %200)
  %207 = extractvalue {i64, i1} %206, 1
  %208 = extractvalue {i64, i1} %206, 0
  %209 = zext i1 %202 to i64
  %210 = call {i64, i1} @llvm.usub.with.overflow.i64(i64 %208, i64 %209)
  %211 = extractvalue {i64, i1} %210, 1
  %212 = or i1 %207, %211
  %213 = extractvalue {i64, i1} %210, 0
; # (cnt (sub A B C))
  %214 = shl i64 %213, 4
  %215 = or i64 %214, 2
  %216 = inttoptr i64 %205 to i64*
  store i64 %215, i64* %216
; # (ifn @@ (zapZero R) (let Q R (loop (set (dig Q) (x| (val (dig Q))...
  br i1 %212, label %$31, label %$30
$30:
  %217 = phi i64 [%199, %$18] ; # A
  %218 = phi i64 [%200, %$18] ; # B
  %219 = phi i64 [%201, %$18] ; # N
  %220 = phi i1 [%202, %$18] ; # C
  %221 = phi i64 [%203, %$18] ; # P
; # (zapZero R)
  %222 = call i64 @zapZero(i64 %50)
  br label %$32
$31:
  %223 = phi i64 [%199, %$18] ; # A
  %224 = phi i64 [%200, %$18] ; # B
  %225 = phi i64 [%201, %$18] ; # N
  %226 = phi i1 [%202, %$18] ; # C
  %227 = phi i64 [%203, %$18] ; # P
; # (let Q R (loop (set (dig Q) (x| (val (dig Q)) -1)) (? (cnt? (setq...
; # (loop (set (dig Q) (x| (val (dig Q)) -1)) (? (cnt? (setq N (val (...
  br label %$33
$33:
  %228 = phi i64 [%223, %$31], [%245, %$34] ; # A
  %229 = phi i64 [%224, %$31], [%246, %$34] ; # B
  %230 = phi i64 [%225, %$31], [%247, %$34] ; # N
  %231 = phi i1 [%226, %$31], [%248, %$34] ; # C
  %232 = phi i64 [%227, %$31], [%249, %$34] ; # P
  %233 = phi i64 [%50, %$31], [%247, %$34] ; # Q
; # (set (dig Q) (x| (val (dig Q)) -1))
; # (dig Q)
  %234 = add i64 %233, -4
; # (dig Q)
  %235 = add i64 %233, -4
; # (val (dig Q))
  %236 = inttoptr i64 %235 to i64*
  %237 = load i64, i64* %236
; # (x| (val (dig Q)) -1)
  %238 = xor i64 %237, -1
  %239 = inttoptr i64 %234 to i64*
  store i64 %238, i64* %239
; # (? (cnt? (setq N (val (big Q)))))
; # (big Q)
  %240 = add i64 %233, 4
; # (val (big Q))
  %241 = inttoptr i64 %240 to i64*
  %242 = load i64, i64* %241
; # (cnt? (setq N (val (big Q))))
  %243 = and i64 %242, 2
  %244 = icmp ne i64 %243, 0
  br i1 %244, label %$35, label %$34
$34:
  %245 = phi i64 [%228, %$33] ; # A
  %246 = phi i64 [%229, %$33] ; # B
  %247 = phi i64 [%242, %$33] ; # N
  %248 = phi i1 [%231, %$33] ; # C
  %249 = phi i64 [%232, %$33] ; # P
  %250 = phi i64 [%233, %$33] ; # Q
  br label %$33
$35:
  %251 = phi i64 [%228, %$33] ; # A
  %252 = phi i64 [%229, %$33] ; # B
  %253 = phi i64 [%242, %$33] ; # N
  %254 = phi i1 [%231, %$33] ; # C
  %255 = phi i64 [%232, %$33] ; # P
  %256 = phi i64 [%233, %$33] ; # Q
  %257 = phi i64 [0, %$33] ; # ->
; # (set (big Q) (x| N -16))
; # (big Q)
  %258 = add i64 %256, 4
; # (x| N -16)
  %259 = xor i64 %253, -16
  %260 = inttoptr i64 %258 to i64*
  store i64 %259, i64* %260
; # (let Q R (loop (set (dig Q) (add (val (dig Q)) 1)) (unless @@ (go...
; # (loop (set (dig Q) (add (val (dig Q)) 1)) (unless @@ (goto 9)) (?...
  br label %$36
$36:
  %261 = phi i64 [%251, %$35], [%292, %$39] ; # A
  %262 = phi i64 [%252, %$35], [%293, %$39] ; # B
  %263 = phi i64 [%253, %$35], [%294, %$39] ; # N
  %264 = phi i1 [%254, %$35], [%295, %$39] ; # C
  %265 = phi i64 [%255, %$35], [%296, %$39] ; # P
  %266 = phi i64 [%50, %$35], [%294, %$39] ; # Q
; # (set (dig Q) (add (val (dig Q)) 1))
; # (dig Q)
  %267 = add i64 %266, -4
; # (dig Q)
  %268 = add i64 %266, -4
; # (val (dig Q))
  %269 = inttoptr i64 %268 to i64*
  %270 = load i64, i64* %269
; # (add (val (dig Q)) 1)
  %271 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %270, i64 1)
  %272 = extractvalue {i64, i1} %271, 1
  %273 = extractvalue {i64, i1} %271, 0
  %274 = inttoptr i64 %267 to i64*
  store i64 %273, i64* %274
; # (unless @@ (goto 9))
  br i1 %272, label %$38, label %$37
$37:
  %275 = phi i64 [%261, %$36] ; # A
  %276 = phi i64 [%262, %$36] ; # B
  %277 = phi i64 [%263, %$36] ; # N
  %278 = phi i1 [%264, %$36] ; # C
  %279 = phi i64 [%265, %$36] ; # P
  %280 = phi i64 [%266, %$36] ; # Q
; # (goto 9)
  br label %$-9
$38:
  %281 = phi i64 [%261, %$36] ; # A
  %282 = phi i64 [%262, %$36] ; # B
  %283 = phi i64 [%263, %$36] ; # N
  %284 = phi i1 [%264, %$36] ; # C
  %285 = phi i64 [%265, %$36] ; # P
  %286 = phi i64 [%266, %$36] ; # Q
; # (? (cnt? (setq N (val (big Q)))))
; # (big Q)
  %287 = add i64 %286, 4
; # (val (big Q))
  %288 = inttoptr i64 %287 to i64*
  %289 = load i64, i64* %288
; # (cnt? (setq N (val (big Q))))
  %290 = and i64 %289, 2
  %291 = icmp ne i64 %290, 0
  br i1 %291, label %$40, label %$39
$39:
  %292 = phi i64 [%281, %$38] ; # A
  %293 = phi i64 [%282, %$38] ; # B
  %294 = phi i64 [%289, %$38] ; # N
  %295 = phi i1 [%284, %$38] ; # C
  %296 = phi i64 [%285, %$38] ; # P
  %297 = phi i64 [%286, %$38] ; # Q
  br label %$36
$40:
  %298 = phi i64 [%281, %$38] ; # A
  %299 = phi i64 [%282, %$38] ; # B
  %300 = phi i64 [%289, %$38] ; # N
  %301 = phi i1 [%284, %$38] ; # C
  %302 = phi i64 [%285, %$38] ; # P
  %303 = phi i64 [%286, %$38] ; # Q
  %304 = phi i64 [0, %$38] ; # ->
; # (set (big Q) (+ N (hex "10")))
; # (big Q)
  %305 = add i64 %303, 4
; # (+ N (hex "10"))
  %306 = add i64 %300, 16
  %307 = inttoptr i64 %305 to i64*
  store i64 %306, i64* %307
; # (: 9 (sign (zapZero R)))
  br label %$-9
$-9:
  %308 = phi i64 [%275, %$37], [%298, %$40] ; # A
  %309 = phi i64 [%276, %$37], [%299, %$40] ; # B
  %310 = phi i64 [%277, %$37], [%300, %$40] ; # N
  %311 = phi i1 [%278, %$37], [%301, %$40] ; # C
  %312 = phi i64 [%279, %$37], [%302, %$40] ; # P
; # (zapZero R)
  %313 = call i64 @zapZero(i64 %50)
; # (sign (zapZero R))
  %314 = or i64 %313, 8
  br label %$32
$32:
  %315 = phi i64 [%217, %$30], [%308, %$-9] ; # A
  %316 = phi i64 [%218, %$30], [%309, %$-9] ; # B
  %317 = phi i64 [%219, %$30], [%310, %$-9] ; # N
  %318 = phi i1 [%220, %$30], [%311, %$-9] ; # C
  %319 = phi i64 [%221, %$30], [%312, %$-9] ; # P
  %320 = phi i64 [%222, %$30], [%314, %$-9] ; # ->
; # (drop *Safe)
  %321 = inttoptr i64 %54 to i64*
  %322 = getelementptr i64, i64* %321, i32 1
  %323 = load i64, i64* %322
  %324 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %323, i64* %324
  br label %$2
$2:
  %325 = phi i64 [%29, %$7], [%36, %$15], [%315, %$32] ; # A
  %326 = phi i64 [%30, %$7], [%37, %$15], [%316, %$32] ; # B
  %327 = phi i64 [%31, %$7], [%38, %$15], [%320, %$32] ; # ->
  ret i64 %327
}

define i64 @mulu(i64, i64) align 8 {
$1:
; # (cond ((== A ZERO) A) ((cnt? A) (setq A (int A)) (if (cnt? B) (le...
; # (== A ZERO)
  %2 = icmp eq i64 %0, 2
  br i1 %2, label %$4, label %$3
$4:
  %3 = phi i64 [%0, %$1] ; # A
  %4 = phi i64 [%1, %$1] ; # B
  br label %$2
$3:
  %5 = phi i64 [%0, %$1] ; # A
  %6 = phi i64 [%1, %$1] ; # B
; # (cnt? A)
  %7 = and i64 %5, 2
  %8 = icmp ne i64 %7, 0
  br i1 %8, label %$6, label %$5
$6:
  %9 = phi i64 [%5, %$3] ; # A
  %10 = phi i64 [%6, %$3] ; # B
; # (int A)
  %11 = lshr i64 %9, 4
; # (if (cnt? B) (let N (mul A (int B)) (if (or @@@ (& N (hex "F00000...
; # (cnt? B)
  %12 = and i64 %10, 2
  %13 = icmp ne i64 %12, 0
  br i1 %13, label %$7, label %$8
$7:
  %14 = phi i64 [%11, %$6] ; # A
  %15 = phi i64 [%10, %$6] ; # B
; # (let N (mul A (int B)) (if (or @@@ (& N (hex "F000000000000000"))...
; # (int B)
  %16 = lshr i64 %15, 4
; # (mul A (int B))
  %17 = zext i64 %14 to i128
  %18 = zext i64 %16 to i128
  %19 = mul i128 %17, %18
  %20 = lshr i128 %19, 64
  %21 = trunc i128 %20 to i64
  %22 = trunc i128 %19 to i64
; # (if (or @@@ (& N (hex "F000000000000000"))) (consNum N (cnt @@@))...
; # (or @@@ (& N (hex "F000000000000000")))
  %23 = icmp ne i64 %21, 0
  br i1 %23, label %$10, label %$11
$11:
  %24 = phi i64 [%14, %$7] ; # A
  %25 = phi i64 [%15, %$7] ; # B
; # (& N (hex "F000000000000000"))
  %26 = and i64 %22, 17293822569102704640
  %27 = icmp ne i64 %26, 0
  br label %$10
$10:
  %28 = phi i64 [%14, %$7], [%24, %$11] ; # A
  %29 = phi i64 [%15, %$7], [%25, %$11] ; # B
  %30 = phi i1 [1, %$7], [%27, %$11] ; # ->
  br i1 %30, label %$12, label %$13
$12:
  %31 = phi i64 [%28, %$10] ; # A
  %32 = phi i64 [%29, %$10] ; # B
; # (cnt @@@)
  %33 = shl i64 %21, 4
  %34 = or i64 %33, 2
; # (consNum N (cnt @@@))
  %35 = call i64 @consNum(i64 %22, i64 %34)
  br label %$14
$13:
  %36 = phi i64 [%28, %$10] ; # A
  %37 = phi i64 [%29, %$10] ; # B
; # (cnt N)
  %38 = shl i64 %22, 4
  %39 = or i64 %38, 2
  br label %$14
$14:
  %40 = phi i64 [%31, %$12], [%36, %$13] ; # A
  %41 = phi i64 [%32, %$12], [%37, %$13] ; # B
  %42 = phi i64 [%35, %$12], [%39, %$13] ; # ->
  br label %$9
$8:
  %43 = phi i64 [%11, %$6] ; # A
  %44 = phi i64 [%10, %$6] ; # B
; # (: 1 (let (Lo (mul A (val (dig B))) Hi @@@ P (boxNum Lo) R (save ...
  br label %$-1
$-1:
  %45 = phi i64 [%43, %$8], [%169, %$26] ; # A
  %46 = phi i64 [%44, %$8], [%167, %$26] ; # B
; # (let (Lo (mul A (val (dig B))) Hi @@@ P (boxNum Lo) R (save P)) (...
; # (dig B)
  %47 = add i64 %46, -4
; # (val (dig B))
  %48 = inttoptr i64 %47 to i64*
  %49 = load i64, i64* %48
; # (mul A (val (dig B)))
  %50 = zext i64 %45 to i128
  %51 = zext i64 %49 to i128
  %52 = mul i128 %50, %51
  %53 = lshr i128 %52, 64
  %54 = trunc i128 %53 to i64
  %55 = trunc i128 %52 to i64
; # (boxNum Lo)
  %56 = call i64 @boxNum(i64 %55)
; # (save P)
  %57 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %58 = load i64, i64* %57
  %59 = alloca i64, i64 2, align 16
  %60 = ptrtoint i64* %59 to i64
  %61 = inttoptr i64 %60 to i64*
  store i64 %56, i64* %61
  %62 = add i64 %60, 8
  %63 = inttoptr i64 %62 to i64*
  store i64 %58, i64* %63
  %64 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %60, i64* %64
; # (while (big? (setq B (val (big B)))) (setq Lo (add (mul A (val (d...
  br label %$15
$15:
  %65 = phi i64 [%45, %$-1], [%75, %$16] ; # A
  %66 = phi i64 [%46, %$-1], [%76, %$16] ; # B
  %67 = phi i64 [%55, %$-1], [%91, %$16] ; # Lo
  %68 = phi i64 [%54, %$-1], [%93, %$16] ; # Hi
  %69 = phi i64 [%56, %$-1], [%95, %$16] ; # P
; # (big B)
  %70 = add i64 %66, 4
; # (val (big B))
  %71 = inttoptr i64 %70 to i64*
  %72 = load i64, i64* %71
; # (big? (setq B (val (big B))))
  %73 = and i64 %72, 4
  %74 = icmp ne i64 %73, 0
  br i1 %74, label %$16, label %$17
$16:
  %75 = phi i64 [%65, %$15] ; # A
  %76 = phi i64 [%72, %$15] ; # B
  %77 = phi i64 [%67, %$15] ; # Lo
  %78 = phi i64 [%68, %$15] ; # Hi
  %79 = phi i64 [%69, %$15] ; # P
; # (dig B)
  %80 = add i64 %76, -4
; # (val (dig B))
  %81 = inttoptr i64 %80 to i64*
  %82 = load i64, i64* %81
; # (mul A (val (dig B)))
  %83 = zext i64 %75 to i128
  %84 = zext i64 %82 to i128
  %85 = mul i128 %83, %84
  %86 = lshr i128 %85, 64
  %87 = trunc i128 %86 to i64
  %88 = trunc i128 %85 to i64
; # (add (mul A (val (dig B))) Hi)
  %89 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %88, i64 %78)
  %90 = extractvalue {i64, i1} %89, 1
  %91 = extractvalue {i64, i1} %89, 0
; # (+ @@@ @@)
  %92 = zext i1 %90 to i64
  %93 = add i64 %87, %92
; # (set (big P) (boxNum Lo))
; # (big P)
  %94 = add i64 %79, 4
; # (boxNum Lo)
  %95 = call i64 @boxNum(i64 %91)
  %96 = inttoptr i64 %94 to i64*
  store i64 %95, i64* %96
  br label %$15
$17:
  %97 = phi i64 [%65, %$15] ; # A
  %98 = phi i64 [%72, %$15] ; # B
  %99 = phi i64 [%67, %$15] ; # Lo
  %100 = phi i64 [%68, %$15] ; # Hi
  %101 = phi i64 [%69, %$15] ; # P
; # (int B)
  %102 = lshr i64 %98, 4
; # (mul A (int B))
  %103 = zext i64 %97 to i128
  %104 = zext i64 %102 to i128
  %105 = mul i128 %103, %104
  %106 = lshr i128 %105, 64
  %107 = trunc i128 %106 to i64
  %108 = trunc i128 %105 to i64
; # (add (mul A (int B)) Hi)
  %109 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %108, i64 %100)
  %110 = extractvalue {i64, i1} %109, 1
  %111 = extractvalue {i64, i1} %109, 0
; # (+ @@@ @@)
  %112 = zext i1 %110 to i64
  %113 = add i64 %107, %112
; # (set (big P) (if (or Hi (& Lo (hex "F000000000000000"))) (consNum...
; # (big P)
  %114 = add i64 %101, 4
; # (if (or Hi (& Lo (hex "F000000000000000"))) (consNum Lo (cnt Hi))...
; # (or Hi (& Lo (hex "F000000000000000")))
  %115 = icmp ne i64 %113, 0
  br i1 %115, label %$18, label %$19
$19:
  %116 = phi i64 [%97, %$17] ; # A
  %117 = phi i64 [%98, %$17] ; # B
  %118 = phi i64 [%111, %$17] ; # Lo
  %119 = phi i64 [%113, %$17] ; # Hi
  %120 = phi i64 [%101, %$17] ; # P
; # (& Lo (hex "F000000000000000"))
  %121 = and i64 %118, 17293822569102704640
  %122 = icmp ne i64 %121, 0
  br label %$18
$18:
  %123 = phi i64 [%97, %$17], [%116, %$19] ; # A
  %124 = phi i64 [%98, %$17], [%117, %$19] ; # B
  %125 = phi i64 [%111, %$17], [%118, %$19] ; # Lo
  %126 = phi i64 [%113, %$17], [%119, %$19] ; # Hi
  %127 = phi i64 [%101, %$17], [%120, %$19] ; # P
  %128 = phi i1 [1, %$17], [%122, %$19] ; # ->
  br i1 %128, label %$20, label %$21
$20:
  %129 = phi i64 [%123, %$18] ; # A
  %130 = phi i64 [%124, %$18] ; # B
  %131 = phi i64 [%125, %$18] ; # Lo
  %132 = phi i64 [%126, %$18] ; # Hi
  %133 = phi i64 [%127, %$18] ; # P
; # (cnt Hi)
  %134 = shl i64 %132, 4
  %135 = or i64 %134, 2
; # (consNum Lo (cnt Hi))
  %136 = call i64 @consNum(i64 %131, i64 %135)
  br label %$22
$21:
  %137 = phi i64 [%123, %$18] ; # A
  %138 = phi i64 [%124, %$18] ; # B
  %139 = phi i64 [%125, %$18] ; # Lo
  %140 = phi i64 [%126, %$18] ; # Hi
  %141 = phi i64 [%127, %$18] ; # P
; # (cnt Lo)
  %142 = shl i64 %139, 4
  %143 = or i64 %142, 2
  br label %$22
$22:
  %144 = phi i64 [%129, %$20], [%137, %$21] ; # A
  %145 = phi i64 [%130, %$20], [%138, %$21] ; # B
  %146 = phi i64 [%131, %$20], [%139, %$21] ; # Lo
  %147 = phi i64 [%132, %$20], [%140, %$21] ; # Hi
  %148 = phi i64 [%133, %$20], [%141, %$21] ; # P
  %149 = phi i64 [%136, %$20], [%143, %$21] ; # ->
  %150 = inttoptr i64 %114 to i64*
  store i64 %149, i64* %150
; # (drop *Safe)
  %151 = inttoptr i64 %60 to i64*
  %152 = getelementptr i64, i64* %151, i32 1
  %153 = load i64, i64* %152
  %154 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %153, i64* %154
  br label %$9
$9:
  %155 = phi i64 [%40, %$14], [%144, %$22] ; # A
  %156 = phi i64 [%41, %$14], [%145, %$22] ; # B
  %157 = phi i64 [%42, %$14], [%56, %$22] ; # ->
  br label %$2
$5:
  %158 = phi i64 [%5, %$3] ; # A
  %159 = phi i64 [%6, %$3] ; # B
; # (== B ZERO)
  %160 = icmp eq i64 %159, 2
  br i1 %160, label %$24, label %$23
$24:
  %161 = phi i64 [%158, %$5] ; # A
  %162 = phi i64 [%159, %$5] ; # B
  br label %$2
$23:
  %163 = phi i64 [%158, %$5] ; # A
  %164 = phi i64 [%159, %$5] ; # B
; # (cnt? B)
  %165 = and i64 %164, 2
  %166 = icmp ne i64 %165, 0
  br i1 %166, label %$26, label %$25
$26:
  %167 = phi i64 [%163, %$23] ; # A
  %168 = phi i64 [%164, %$23] ; # B
; # (int B)
  %169 = lshr i64 %168, 4
; # (xchg 'A 'B)
; # (goto 1)
  br label %$-1
$25:
  %170 = phi i64 [%163, %$23] ; # A
  %171 = phi i64 [%164, %$23] ; # B
; # (let (P (boxNum 0) R (save P)) (loop (let (X A Q P Lo (add (mul (...
; # (boxNum 0)
  %172 = call i64 @boxNum(i64 0)
; # (save P)
  %173 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %174 = load i64, i64* %173
  %175 = alloca i64, i64 2, align 16
  %176 = ptrtoint i64* %175 to i64
  %177 = inttoptr i64 %176 to i64*
  store i64 %172, i64* %177
  %178 = add i64 %176, 8
  %179 = inttoptr i64 %178 to i64*
  store i64 %174, i64* %179
  %180 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %176, i64* %180
; # (loop (let (X A Q P Lo (add (mul (val (dig X)) (val (dig B))) (va...
  br label %$27
$27:
  %181 = phi i64 [%170, %$25], [%368, %$39] ; # A
  %182 = phi i64 [%171, %$25], [%369, %$39] ; # B
  %183 = phi i64 [%172, %$25], [%370, %$39] ; # P
; # (let (X A Q P Lo (add (mul (val (dig X)) (val (dig B))) (val (dig...
; # (dig X)
  %184 = add i64 %181, -4
; # (val (dig X))
  %185 = inttoptr i64 %184 to i64*
  %186 = load i64, i64* %185
; # (dig B)
  %187 = add i64 %182, -4
; # (val (dig B))
  %188 = inttoptr i64 %187 to i64*
  %189 = load i64, i64* %188
; # (mul (val (dig X)) (val (dig B)))
  %190 = zext i64 %186 to i128
  %191 = zext i64 %189 to i128
  %192 = mul i128 %190, %191
  %193 = lshr i128 %192, 64
  %194 = trunc i128 %193 to i64
  %195 = trunc i128 %192 to i64
; # (dig Q)
  %196 = add i64 %183, -4
; # (val (dig Q))
  %197 = inttoptr i64 %196 to i64*
  %198 = load i64, i64* %197
; # (add (mul (val (dig X)) (val (dig B))) (val (dig Q)))
  %199 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %195, i64 %198)
  %200 = extractvalue {i64, i1} %199, 1
  %201 = extractvalue {i64, i1} %199, 0
; # (+ @@@ @@)
  %202 = zext i1 %200 to i64
  %203 = add i64 %194, %202
; # (loop (set (dig Q) Lo) (setq Q (if (cnt? (val (big Q))) (set (big...
  br label %$28
$28:
  %204 = phi i64 [%181, %$27], [%248, %$32] ; # A
  %205 = phi i64 [%182, %$27], [%249, %$32] ; # B
  %206 = phi i64 [%183, %$27], [%250, %$32] ; # P
  %207 = phi i64 [%181, %$27], [%251, %$32] ; # X
  %208 = phi i64 [%183, %$27], [%252, %$32] ; # Q
  %209 = phi i64 [%201, %$27], [%277, %$32] ; # Lo
  %210 = phi i64 [%203, %$27], [%279, %$32] ; # Hi
; # (set (dig Q) Lo)
; # (dig Q)
  %211 = add i64 %208, -4
  %212 = inttoptr i64 %211 to i64*
  store i64 %209, i64* %212
; # (if (cnt? (val (big Q))) (set (big Q) (boxNum 0)) @)
; # (big Q)
  %213 = add i64 %208, 4
; # (val (big Q))
  %214 = inttoptr i64 %213 to i64*
  %215 = load i64, i64* %214
; # (cnt? (val (big Q)))
  %216 = and i64 %215, 2
  %217 = icmp ne i64 %216, 0
  br i1 %217, label %$29, label %$30
$29:
  %218 = phi i64 [%204, %$28] ; # A
  %219 = phi i64 [%205, %$28] ; # B
  %220 = phi i64 [%206, %$28] ; # P
  %221 = phi i64 [%207, %$28] ; # X
  %222 = phi i64 [%208, %$28] ; # Q
  %223 = phi i64 [%209, %$28] ; # Lo
  %224 = phi i64 [%210, %$28] ; # Hi
; # (set (big Q) (boxNum 0))
; # (big Q)
  %225 = add i64 %222, 4
; # (boxNum 0)
  %226 = call i64 @boxNum(i64 0)
  %227 = inttoptr i64 %225 to i64*
  store i64 %226, i64* %227
  br label %$31
$30:
  %228 = phi i64 [%204, %$28] ; # A
  %229 = phi i64 [%205, %$28] ; # B
  %230 = phi i64 [%206, %$28] ; # P
  %231 = phi i64 [%207, %$28] ; # X
  %232 = phi i64 [%208, %$28] ; # Q
  %233 = phi i64 [%209, %$28] ; # Lo
  %234 = phi i64 [%210, %$28] ; # Hi
  br label %$31
$31:
  %235 = phi i64 [%218, %$29], [%228, %$30] ; # A
  %236 = phi i64 [%219, %$29], [%229, %$30] ; # B
  %237 = phi i64 [%220, %$29], [%230, %$30] ; # P
  %238 = phi i64 [%221, %$29], [%231, %$30] ; # X
  %239 = phi i64 [%222, %$29], [%232, %$30] ; # Q
  %240 = phi i64 [%223, %$29], [%233, %$30] ; # Lo
  %241 = phi i64 [%224, %$29], [%234, %$30] ; # Hi
  %242 = phi i64 [%226, %$29], [%215, %$30] ; # ->
; # (? (cnt? (setq X (val (big X)))))
; # (big X)
  %243 = add i64 %238, 4
; # (val (big X))
  %244 = inttoptr i64 %243 to i64*
  %245 = load i64, i64* %244
; # (cnt? (setq X (val (big X))))
  %246 = and i64 %245, 2
  %247 = icmp ne i64 %246, 0
  br i1 %247, label %$33, label %$32
$32:
  %248 = phi i64 [%235, %$31] ; # A
  %249 = phi i64 [%236, %$31] ; # B
  %250 = phi i64 [%237, %$31] ; # P
  %251 = phi i64 [%245, %$31] ; # X
  %252 = phi i64 [%242, %$31] ; # Q
  %253 = phi i64 [%240, %$31] ; # Lo
  %254 = phi i64 [%241, %$31] ; # Hi
; # (dig X)
  %255 = add i64 %251, -4
; # (val (dig X))
  %256 = inttoptr i64 %255 to i64*
  %257 = load i64, i64* %256
; # (dig B)
  %258 = add i64 %249, -4
; # (val (dig B))
  %259 = inttoptr i64 %258 to i64*
  %260 = load i64, i64* %259
; # (mulAddHiLo (val (dig X)) (val (dig B)) Q)
  %261 = zext i64 %257 to i128
  %262 = zext i64 %260 to i128
  %263 = mul i128 %261, %262
  %264 = lshr i128 %263, 64
  %265 = trunc i128 %264 to i64
  %266 = trunc i128 %263 to i64
  %267 = add i64 %252, -4
  %268 = inttoptr i64 %267 to i64*
  %269 = load i64, i64* %268
  %270 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %266, i64 %269)
  %271 = extractvalue {i64, i1} %270, 1
  %272 = extractvalue {i64, i1} %270, 0
  %273 = zext i1 %271 to i64
  %274 = add i64 %265, %273
  %275 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %272, i64 %254)
  %276 = extractvalue {i64, i1} %275, 1
  %277 = extractvalue {i64, i1} %275, 0
  %278 = zext i1 %276 to i64
  %279 = add i64 %274, %278
  br label %$28
$33:
  %280 = phi i64 [%235, %$31] ; # A
  %281 = phi i64 [%236, %$31] ; # B
  %282 = phi i64 [%237, %$31] ; # P
  %283 = phi i64 [%245, %$31] ; # X
  %284 = phi i64 [%242, %$31] ; # Q
  %285 = phi i64 [%240, %$31] ; # Lo
  %286 = phi i64 [%241, %$31] ; # Hi
  %287 = phi i64 [0, %$31] ; # ->
; # (int X)
  %288 = lshr i64 %283, 4
; # (dig B)
  %289 = add i64 %281, -4
; # (val (dig B))
  %290 = inttoptr i64 %289 to i64*
  %291 = load i64, i64* %290
; # (mulAddHiLo (int X) (val (dig B)) Q)
  %292 = zext i64 %288 to i128
  %293 = zext i64 %291 to i128
  %294 = mul i128 %292, %293
  %295 = lshr i128 %294, 64
  %296 = trunc i128 %295 to i64
  %297 = trunc i128 %294 to i64
  %298 = add i64 %284, -4
  %299 = inttoptr i64 %298 to i64*
  %300 = load i64, i64* %299
  %301 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %297, i64 %300)
  %302 = extractvalue {i64, i1} %301, 1
  %303 = extractvalue {i64, i1} %301, 0
  %304 = zext i1 %302 to i64
  %305 = add i64 %296, %304
  %306 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %303, i64 %286)
  %307 = extractvalue {i64, i1} %306, 1
  %308 = extractvalue {i64, i1} %306, 0
  %309 = zext i1 %307 to i64
  %310 = add i64 %305, %309
; # (set (dig Q) Lo)
; # (dig Q)
  %311 = add i64 %284, -4
  %312 = inttoptr i64 %311 to i64*
  store i64 %308, i64* %312
; # (when Hi (if (cnt? (val (big Q))) (set (big Q) (boxNum Hi)) (set ...
  %313 = icmp ne i64 %310, 0
  br i1 %313, label %$34, label %$35
$34:
  %314 = phi i64 [%280, %$33] ; # A
  %315 = phi i64 [%281, %$33] ; # B
  %316 = phi i64 [%282, %$33] ; # P
  %317 = phi i64 [%283, %$33] ; # X
  %318 = phi i64 [%284, %$33] ; # Q
  %319 = phi i64 [%308, %$33] ; # Lo
  %320 = phi i64 [%310, %$33] ; # Hi
; # (if (cnt? (val (big Q))) (set (big Q) (boxNum Hi)) (set (big @) H...
; # (big Q)
  %321 = add i64 %318, 4
; # (val (big Q))
  %322 = inttoptr i64 %321 to i64*
  %323 = load i64, i64* %322
; # (cnt? (val (big Q)))
  %324 = and i64 %323, 2
  %325 = icmp ne i64 %324, 0
  br i1 %325, label %$36, label %$37
$36:
  %326 = phi i64 [%314, %$34] ; # A
  %327 = phi i64 [%315, %$34] ; # B
  %328 = phi i64 [%316, %$34] ; # P
  %329 = phi i64 [%317, %$34] ; # X
  %330 = phi i64 [%318, %$34] ; # Q
  %331 = phi i64 [%319, %$34] ; # Lo
  %332 = phi i64 [%320, %$34] ; # Hi
; # (set (big Q) (boxNum Hi))
; # (big Q)
  %333 = add i64 %330, 4
; # (boxNum Hi)
  %334 = call i64 @boxNum(i64 %332)
  %335 = inttoptr i64 %333 to i64*
  store i64 %334, i64* %335
  br label %$38
$37:
  %336 = phi i64 [%314, %$34] ; # A
  %337 = phi i64 [%315, %$34] ; # B
  %338 = phi i64 [%316, %$34] ; # P
  %339 = phi i64 [%317, %$34] ; # X
  %340 = phi i64 [%318, %$34] ; # Q
  %341 = phi i64 [%319, %$34] ; # Lo
  %342 = phi i64 [%320, %$34] ; # Hi
; # (set (big @) Hi)
; # (big @)
  %343 = add i64 %323, 4
  %344 = inttoptr i64 %343 to i64*
  store i64 %342, i64* %344
  br label %$38
$38:
  %345 = phi i64 [%326, %$36], [%336, %$37] ; # A
  %346 = phi i64 [%327, %$36], [%337, %$37] ; # B
  %347 = phi i64 [%328, %$36], [%338, %$37] ; # P
  %348 = phi i64 [%329, %$36], [%339, %$37] ; # X
  %349 = phi i64 [%330, %$36], [%340, %$37] ; # Q
  %350 = phi i64 [%331, %$36], [%341, %$37] ; # Lo
  %351 = phi i64 [%332, %$36], [%342, %$37] ; # Hi
  %352 = phi i64 [%334, %$36], [%342, %$37] ; # ->
  br label %$35
$35:
  %353 = phi i64 [%280, %$33], [%345, %$38] ; # A
  %354 = phi i64 [%281, %$33], [%346, %$38] ; # B
  %355 = phi i64 [%282, %$33], [%347, %$38] ; # P
  %356 = phi i64 [%283, %$33], [%348, %$38] ; # X
  %357 = phi i64 [%284, %$33], [%349, %$38] ; # Q
  %358 = phi i64 [%308, %$33], [%350, %$38] ; # Lo
  %359 = phi i64 [%310, %$33], [%351, %$38] ; # Hi
; # (big P)
  %360 = add i64 %355, 4
; # (val (big P))
  %361 = inttoptr i64 %360 to i64*
  %362 = load i64, i64* %361
; # (? (cnt? (setq B (val (big B)))))
; # (big B)
  %363 = add i64 %354, 4
; # (val (big B))
  %364 = inttoptr i64 %363 to i64*
  %365 = load i64, i64* %364
; # (cnt? (setq B (val (big B))))
  %366 = and i64 %365, 2
  %367 = icmp ne i64 %366, 0
  br i1 %367, label %$40, label %$39
$39:
  %368 = phi i64 [%353, %$35] ; # A
  %369 = phi i64 [%365, %$35] ; # B
  %370 = phi i64 [%362, %$35] ; # P
  br label %$27
$40:
  %371 = phi i64 [%353, %$35] ; # A
  %372 = phi i64 [%365, %$35] ; # B
  %373 = phi i64 [%362, %$35] ; # P
  %374 = phi i64 [0, %$35] ; # ->
; # (int B)
  %375 = lshr i64 %372, 4
; # (let (Lo (add (mul (val (dig A)) B) (val (dig P))) Hi (+ @@@ @@))...
; # (dig A)
  %376 = add i64 %371, -4
; # (val (dig A))
  %377 = inttoptr i64 %376 to i64*
  %378 = load i64, i64* %377
; # (mul (val (dig A)) B)
  %379 = zext i64 %378 to i128
  %380 = zext i64 %375 to i128
  %381 = mul i128 %379, %380
  %382 = lshr i128 %381, 64
  %383 = trunc i128 %382 to i64
  %384 = trunc i128 %381 to i64
; # (dig P)
  %385 = add i64 %373, -4
; # (val (dig P))
  %386 = inttoptr i64 %385 to i64*
  %387 = load i64, i64* %386
; # (add (mul (val (dig A)) B) (val (dig P)))
  %388 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %384, i64 %387)
  %389 = extractvalue {i64, i1} %388, 1
  %390 = extractvalue {i64, i1} %388, 0
; # (+ @@@ @@)
  %391 = zext i1 %389 to i64
  %392 = add i64 %383, %391
; # (loop (set (dig P) Lo) (setq P (if (cnt? (val (big P))) (set (big...
  br label %$41
$41:
  %393 = phi i64 [%371, %$40], [%429, %$45] ; # A
  %394 = phi i64 [%375, %$40], [%430, %$45] ; # B
  %395 = phi i64 [%373, %$40], [%431, %$45] ; # P
  %396 = phi i64 [%390, %$40], [%453, %$45] ; # Lo
  %397 = phi i64 [%392, %$40], [%455, %$45] ; # Hi
; # (set (dig P) Lo)
; # (dig P)
  %398 = add i64 %395, -4
  %399 = inttoptr i64 %398 to i64*
  store i64 %396, i64* %399
; # (if (cnt? (val (big P))) (set (big P) (boxNum 0)) @)
; # (big P)
  %400 = add i64 %395, 4
; # (val (big P))
  %401 = inttoptr i64 %400 to i64*
  %402 = load i64, i64* %401
; # (cnt? (val (big P)))
  %403 = and i64 %402, 2
  %404 = icmp ne i64 %403, 0
  br i1 %404, label %$42, label %$43
$42:
  %405 = phi i64 [%393, %$41] ; # A
  %406 = phi i64 [%394, %$41] ; # B
  %407 = phi i64 [%395, %$41] ; # P
  %408 = phi i64 [%396, %$41] ; # Lo
  %409 = phi i64 [%397, %$41] ; # Hi
; # (set (big P) (boxNum 0))
; # (big P)
  %410 = add i64 %407, 4
; # (boxNum 0)
  %411 = call i64 @boxNum(i64 0)
  %412 = inttoptr i64 %410 to i64*
  store i64 %411, i64* %412
  br label %$44
$43:
  %413 = phi i64 [%393, %$41] ; # A
  %414 = phi i64 [%394, %$41] ; # B
  %415 = phi i64 [%395, %$41] ; # P
  %416 = phi i64 [%396, %$41] ; # Lo
  %417 = phi i64 [%397, %$41] ; # Hi
  br label %$44
$44:
  %418 = phi i64 [%405, %$42], [%413, %$43] ; # A
  %419 = phi i64 [%406, %$42], [%414, %$43] ; # B
  %420 = phi i64 [%407, %$42], [%415, %$43] ; # P
  %421 = phi i64 [%408, %$42], [%416, %$43] ; # Lo
  %422 = phi i64 [%409, %$42], [%417, %$43] ; # Hi
  %423 = phi i64 [%411, %$42], [%402, %$43] ; # ->
; # (? (cnt? (setq A (val (big A)))))
; # (big A)
  %424 = add i64 %418, 4
; # (val (big A))
  %425 = inttoptr i64 %424 to i64*
  %426 = load i64, i64* %425
; # (cnt? (setq A (val (big A))))
  %427 = and i64 %426, 2
  %428 = icmp ne i64 %427, 0
  br i1 %428, label %$46, label %$45
$45:
  %429 = phi i64 [%426, %$44] ; # A
  %430 = phi i64 [%419, %$44] ; # B
  %431 = phi i64 [%423, %$44] ; # P
  %432 = phi i64 [%421, %$44] ; # Lo
  %433 = phi i64 [%422, %$44] ; # Hi
; # (dig A)
  %434 = add i64 %429, -4
; # (val (dig A))
  %435 = inttoptr i64 %434 to i64*
  %436 = load i64, i64* %435
; # (mulAddHiLo (val (dig A)) B P)
  %437 = zext i64 %436 to i128
  %438 = zext i64 %430 to i128
  %439 = mul i128 %437, %438
  %440 = lshr i128 %439, 64
  %441 = trunc i128 %440 to i64
  %442 = trunc i128 %439 to i64
  %443 = add i64 %431, -4
  %444 = inttoptr i64 %443 to i64*
  %445 = load i64, i64* %444
  %446 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %442, i64 %445)
  %447 = extractvalue {i64, i1} %446, 1
  %448 = extractvalue {i64, i1} %446, 0
  %449 = zext i1 %447 to i64
  %450 = add i64 %441, %449
  %451 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %448, i64 %433)
  %452 = extractvalue {i64, i1} %451, 1
  %453 = extractvalue {i64, i1} %451, 0
  %454 = zext i1 %452 to i64
  %455 = add i64 %450, %454
  br label %$41
$46:
  %456 = phi i64 [%426, %$44] ; # A
  %457 = phi i64 [%419, %$44] ; # B
  %458 = phi i64 [%423, %$44] ; # P
  %459 = phi i64 [%421, %$44] ; # Lo
  %460 = phi i64 [%422, %$44] ; # Hi
  %461 = phi i64 [0, %$44] ; # ->
; # (int A)
  %462 = lshr i64 %456, 4
; # (mulAddHiLo (int A) B P)
  %463 = zext i64 %462 to i128
  %464 = zext i64 %457 to i128
  %465 = mul i128 %463, %464
  %466 = lshr i128 %465, 64
  %467 = trunc i128 %466 to i64
  %468 = trunc i128 %465 to i64
  %469 = add i64 %458, -4
  %470 = inttoptr i64 %469 to i64*
  %471 = load i64, i64* %470
  %472 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %468, i64 %471)
  %473 = extractvalue {i64, i1} %472, 1
  %474 = extractvalue {i64, i1} %472, 0
  %475 = zext i1 %473 to i64
  %476 = add i64 %467, %475
  %477 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %474, i64 %460)
  %478 = extractvalue {i64, i1} %477, 1
  %479 = extractvalue {i64, i1} %477, 0
  %480 = zext i1 %478 to i64
  %481 = add i64 %476, %480
; # (set (dig P) Lo)
; # (dig P)
  %482 = add i64 %458, -4
  %483 = inttoptr i64 %482 to i64*
  store i64 %479, i64* %483
; # (when Hi (if (cnt? (val (big P))) (set (big P) (boxNum Hi)) (set ...
  %484 = icmp ne i64 %481, 0
  br i1 %484, label %$47, label %$48
$47:
  %485 = phi i64 [%456, %$46] ; # A
  %486 = phi i64 [%457, %$46] ; # B
  %487 = phi i64 [%458, %$46] ; # P
  %488 = phi i64 [%479, %$46] ; # Lo
  %489 = phi i64 [%481, %$46] ; # Hi
; # (if (cnt? (val (big P))) (set (big P) (boxNum Hi)) (set (big @) H...
; # (big P)
  %490 = add i64 %487, 4
; # (val (big P))
  %491 = inttoptr i64 %490 to i64*
  %492 = load i64, i64* %491
; # (cnt? (val (big P)))
  %493 = and i64 %492, 2
  %494 = icmp ne i64 %493, 0
  br i1 %494, label %$49, label %$50
$49:
  %495 = phi i64 [%485, %$47] ; # A
  %496 = phi i64 [%486, %$47] ; # B
  %497 = phi i64 [%487, %$47] ; # P
  %498 = phi i64 [%488, %$47] ; # Lo
  %499 = phi i64 [%489, %$47] ; # Hi
; # (set (big P) (boxNum Hi))
; # (big P)
  %500 = add i64 %497, 4
; # (boxNum Hi)
  %501 = call i64 @boxNum(i64 %499)
  %502 = inttoptr i64 %500 to i64*
  store i64 %501, i64* %502
  br label %$51
$50:
  %503 = phi i64 [%485, %$47] ; # A
  %504 = phi i64 [%486, %$47] ; # B
  %505 = phi i64 [%487, %$47] ; # P
  %506 = phi i64 [%488, %$47] ; # Lo
  %507 = phi i64 [%489, %$47] ; # Hi
; # (set (big @) Hi)
; # (big @)
  %508 = add i64 %492, 4
  %509 = inttoptr i64 %508 to i64*
  store i64 %507, i64* %509
  br label %$51
$51:
  %510 = phi i64 [%495, %$49], [%503, %$50] ; # A
  %511 = phi i64 [%496, %$49], [%504, %$50] ; # B
  %512 = phi i64 [%497, %$49], [%505, %$50] ; # P
  %513 = phi i64 [%498, %$49], [%506, %$50] ; # Lo
  %514 = phi i64 [%499, %$49], [%507, %$50] ; # Hi
  %515 = phi i64 [%501, %$49], [%507, %$50] ; # ->
  br label %$48
$48:
  %516 = phi i64 [%456, %$46], [%510, %$51] ; # A
  %517 = phi i64 [%457, %$46], [%511, %$51] ; # B
  %518 = phi i64 [%458, %$46], [%512, %$51] ; # P
  %519 = phi i64 [%479, %$46], [%513, %$51] ; # Lo
  %520 = phi i64 [%481, %$46], [%514, %$51] ; # Hi
; # (zapZero R)
  %521 = call i64 @zapZero(i64 %172)
; # (drop *Safe)
  %522 = inttoptr i64 %176 to i64*
  %523 = getelementptr i64, i64* %522, i32 1
  %524 = load i64, i64* %523
  %525 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %524, i64* %525
  br label %$2
$2:
  %526 = phi i64 [%3, %$4], [%155, %$9], [%161, %$24], [%516, %$48] ; # A
  %527 = phi i64 [%4, %$4], [%156, %$9], [%162, %$24], [%517, %$48] ; # B
  %528 = phi i64 [%3, %$4], [%157, %$9], [%162, %$24], [%521, %$48] ; # ->
  ret i64 %528
}

define i64 @div1(i64, i64, i1) align 8 {
$1:
; # (let (R (save ZERO) P (boxNum (val (dig A))) U (link (push P NIL)...
; # (save ZERO)
  %3 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %4 = load i64, i64* %3
  %5 = alloca i64, i64 2, align 16
  %6 = ptrtoint i64* %5 to i64
  %7 = inttoptr i64 %6 to i64*
  store i64 2, i64* %7
  %8 = add i64 %6, 8
  %9 = inttoptr i64 %8 to i64*
  store i64 %4, i64* %9
  %10 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %6, i64* %10
; # (dig A)
  %11 = add i64 %0, -4
; # (val (dig A))
  %12 = inttoptr i64 %11 to i64*
  %13 = load i64, i64* %12
; # (boxNum (val (dig A)))
  %14 = call i64 @boxNum(i64 %13)
; # (push P NIL)
  %15 = alloca i64, i64 2, align 16
  %16 = ptrtoint i64* %15 to i64
  %17 = inttoptr i64 %16 to i64*
  store i64 %14, i64* %17
; # (link (push P NIL))
  %18 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %19 = load i64, i64* %18
  %20 = inttoptr i64 %16 to i64*
  %21 = getelementptr i64, i64* %20, i32 1
  store i64 %19, i64* %21
  %22 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %16, i64* %22
; # (push B NIL)
  %23 = alloca i64, i64 2, align 16
  %24 = ptrtoint i64* %23 to i64
  %25 = inttoptr i64 %24 to i64*
  store i64 %1, i64* %25
; # (link (push B NIL))
  %26 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %27 = load i64, i64* %26
  %28 = inttoptr i64 %24 to i64*
  %29 = getelementptr i64, i64* %28, i32 1
  store i64 %27, i64* %29
  %30 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %24, i64* %30
; # (while (big? (setq A (val (big A)))) (setq P (set (big P) (boxNum...
  br label %$2
$2:
  %31 = phi i64 [%0, %$1], [%44, %$3] ; # A
  %32 = phi i64 [%1, %$1], [%45, %$3] ; # B
  %33 = phi i64 [2, %$1], [%46, %$3] ; # R
  %34 = phi i64 [%14, %$1], [%56, %$3] ; # P
  %35 = phi i64 [0, %$1], [%48, %$3] ; # V2
  %36 = phi i64 [0, %$1], [%58, %$3] ; # M
  %37 = phi i64 [1, %$1], [%50, %$3] ; # N
  %38 = phi i64 [0, %$1], [%51, %$3] ; # D
; # (big A)
  %39 = add i64 %31, 4
; # (val (big A))
  %40 = inttoptr i64 %39 to i64*
  %41 = load i64, i64* %40
; # (big? (setq A (val (big A))))
  %42 = and i64 %41, 4
  %43 = icmp ne i64 %42, 0
  br i1 %43, label %$3, label %$4
$3:
  %44 = phi i64 [%41, %$2] ; # A
  %45 = phi i64 [%32, %$2] ; # B
  %46 = phi i64 [%33, %$2] ; # R
  %47 = phi i64 [%34, %$2] ; # P
  %48 = phi i64 [%35, %$2] ; # V2
  %49 = phi i64 [%36, %$2] ; # M
  %50 = phi i64 [%37, %$2] ; # N
  %51 = phi i64 [%38, %$2] ; # D
; # (set (big P) (boxNum (val (dig A))))
; # (big P)
  %52 = add i64 %47, 4
; # (dig A)
  %53 = add i64 %44, -4
; # (val (dig A))
  %54 = inttoptr i64 %53 to i64*
  %55 = load i64, i64* %54
; # (boxNum (val (dig A)))
  %56 = call i64 @boxNum(i64 %55)
  %57 = inttoptr i64 %52 to i64*
  store i64 %56, i64* %57
; # (inc 'M)
  %58 = add i64 %49, 1
  br label %$2
$4:
  %59 = phi i64 [%41, %$2] ; # A
  %60 = phi i64 [%32, %$2] ; # B
  %61 = phi i64 [%33, %$2] ; # R
  %62 = phi i64 [%34, %$2] ; # P
  %63 = phi i64 [%35, %$2] ; # V2
  %64 = phi i64 [%36, %$2] ; # M
  %65 = phi i64 [%37, %$2] ; # N
  %66 = phi i64 [%38, %$2] ; # D
; # (unless (== A ZERO) (setq P (set (big P) (boxNum (int A)))) (inc ...
; # (== A ZERO)
  %67 = icmp eq i64 %59, 2
  br i1 %67, label %$6, label %$5
$5:
  %68 = phi i64 [%59, %$4] ; # A
  %69 = phi i64 [%60, %$4] ; # B
  %70 = phi i64 [%61, %$4] ; # R
  %71 = phi i64 [%62, %$4] ; # P
  %72 = phi i64 [%63, %$4] ; # V2
  %73 = phi i64 [%64, %$4] ; # M
  %74 = phi i64 [%65, %$4] ; # N
  %75 = phi i64 [%66, %$4] ; # D
; # (set (big P) (boxNum (int A)))
; # (big P)
  %76 = add i64 %71, 4
; # (int A)
  %77 = lshr i64 %68, 4
; # (boxNum (int A))
  %78 = call i64 @boxNum(i64 %77)
  %79 = inttoptr i64 %76 to i64*
  store i64 %78, i64* %79
; # (inc 'M)
  %80 = add i64 %73, 1
  br label %$6
$6:
  %81 = phi i64 [%59, %$4], [%68, %$5] ; # A
  %82 = phi i64 [%60, %$4], [%69, %$5] ; # B
  %83 = phi i64 [%61, %$4], [%70, %$5] ; # R
  %84 = phi i64 [%62, %$4], [%78, %$5] ; # P
  %85 = phi i64 [%63, %$4], [%72, %$5] ; # V2
  %86 = phi i64 [%64, %$4], [%80, %$5] ; # M
  %87 = phi i64 [%65, %$4], [%74, %$5] ; # N
  %88 = phi i64 [%66, %$4], [%75, %$5] ; # D
; # (if (cnt? B) (setq Q (set V (boxNum (int B)))) (setq Q (set V (bo...
; # (cnt? B)
  %89 = and i64 %82, 2
  %90 = icmp ne i64 %89, 0
  br i1 %90, label %$7, label %$8
$7:
  %91 = phi i64 [%81, %$6] ; # A
  %92 = phi i64 [%82, %$6] ; # B
  %93 = phi i64 [%83, %$6] ; # R
  %94 = phi i64 [%84, %$6] ; # P
  %95 = phi i64 [%85, %$6] ; # V2
  %96 = phi i64 [%86, %$6] ; # M
  %97 = phi i64 [%87, %$6] ; # N
  %98 = phi i64 [%88, %$6] ; # D
; # (set V (boxNum (int B)))
; # (int B)
  %99 = lshr i64 %92, 4
; # (boxNum (int B))
  %100 = call i64 @boxNum(i64 %99)
  %101 = inttoptr i64 %24 to i64*
  store i64 %100, i64* %101
  br label %$9
$8:
  %102 = phi i64 [%81, %$6] ; # A
  %103 = phi i64 [%82, %$6] ; # B
  %104 = phi i64 [%83, %$6] ; # R
  %105 = phi i64 [%84, %$6] ; # P
  %106 = phi i64 [%85, %$6] ; # V2
  %107 = phi i64 [%86, %$6] ; # M
  %108 = phi i64 [%87, %$6] ; # N
  %109 = phi i64 [%88, %$6] ; # D
; # (set V (boxNum (val (dig B))))
; # (dig B)
  %110 = add i64 %103, -4
; # (val (dig B))
  %111 = inttoptr i64 %110 to i64*
  %112 = load i64, i64* %111
; # (boxNum (val (dig B)))
  %113 = call i64 @boxNum(i64 %112)
  %114 = inttoptr i64 %24 to i64*
  store i64 %113, i64* %114
; # (while (big? (setq B (val (big B)))) (setq V2 Q Q (set (big Q) (b...
  br label %$10
$10:
  %115 = phi i64 [%102, %$8], [%129, %$11] ; # A
  %116 = phi i64 [%103, %$8], [%130, %$11] ; # B
  %117 = phi i64 [%104, %$8], [%131, %$11] ; # R
  %118 = phi i64 [%105, %$8], [%132, %$11] ; # P
  %119 = phi i64 [%106, %$8], [%137, %$11] ; # V2
  %120 = phi i64 [%107, %$8], [%144, %$11] ; # M
  %121 = phi i64 [%108, %$8], [%145, %$11] ; # N
  %122 = phi i64 [%109, %$8], [%136, %$11] ; # D
  %123 = phi i64 [%113, %$8], [%142, %$11] ; # Q
; # (big B)
  %124 = add i64 %116, 4
; # (val (big B))
  %125 = inttoptr i64 %124 to i64*
  %126 = load i64, i64* %125
; # (big? (setq B (val (big B))))
  %127 = and i64 %126, 4
  %128 = icmp ne i64 %127, 0
  br i1 %128, label %$11, label %$12
$11:
  %129 = phi i64 [%115, %$10] ; # A
  %130 = phi i64 [%126, %$10] ; # B
  %131 = phi i64 [%117, %$10] ; # R
  %132 = phi i64 [%118, %$10] ; # P
  %133 = phi i64 [%119, %$10] ; # V2
  %134 = phi i64 [%120, %$10] ; # M
  %135 = phi i64 [%121, %$10] ; # N
  %136 = phi i64 [%122, %$10] ; # D
  %137 = phi i64 [%123, %$10] ; # Q
; # (set (big Q) (boxNum (val (dig B))))
; # (big Q)
  %138 = add i64 %137, 4
; # (dig B)
  %139 = add i64 %130, -4
; # (val (dig B))
  %140 = inttoptr i64 %139 to i64*
  %141 = load i64, i64* %140
; # (boxNum (val (dig B)))
  %142 = call i64 @boxNum(i64 %141)
  %143 = inttoptr i64 %138 to i64*
  store i64 %142, i64* %143
; # (dec 'M)
  %144 = sub i64 %134, 1
; # (inc 'N)
  %145 = add i64 %135, 1
  br label %$10
$12:
  %146 = phi i64 [%115, %$10] ; # A
  %147 = phi i64 [%126, %$10] ; # B
  %148 = phi i64 [%117, %$10] ; # R
  %149 = phi i64 [%118, %$10] ; # P
  %150 = phi i64 [%119, %$10] ; # V2
  %151 = phi i64 [%120, %$10] ; # M
  %152 = phi i64 [%121, %$10] ; # N
  %153 = phi i64 [%122, %$10] ; # D
  %154 = phi i64 [%123, %$10] ; # Q
; # (unless (== B ZERO) (setq V2 Q Q (set (big Q) (boxNum (int B)))) ...
; # (== B ZERO)
  %155 = icmp eq i64 %147, 2
  br i1 %155, label %$14, label %$13
$13:
  %156 = phi i64 [%146, %$12] ; # A
  %157 = phi i64 [%147, %$12] ; # B
  %158 = phi i64 [%148, %$12] ; # R
  %159 = phi i64 [%149, %$12] ; # P
  %160 = phi i64 [%150, %$12] ; # V2
  %161 = phi i64 [%151, %$12] ; # M
  %162 = phi i64 [%152, %$12] ; # N
  %163 = phi i64 [%153, %$12] ; # D
  %164 = phi i64 [%154, %$12] ; # Q
; # (set (big Q) (boxNum (int B)))
; # (big Q)
  %165 = add i64 %164, 4
; # (int B)
  %166 = lshr i64 %157, 4
; # (boxNum (int B))
  %167 = call i64 @boxNum(i64 %166)
  %168 = inttoptr i64 %165 to i64*
  store i64 %167, i64* %168
; # (dec 'M)
  %169 = sub i64 %161, 1
; # (inc 'N)
  %170 = add i64 %162, 1
  br label %$14
$14:
  %171 = phi i64 [%146, %$12], [%156, %$13] ; # A
  %172 = phi i64 [%147, %$12], [%157, %$13] ; # B
  %173 = phi i64 [%148, %$12], [%158, %$13] ; # R
  %174 = phi i64 [%149, %$12], [%159, %$13] ; # P
  %175 = phi i64 [%150, %$12], [%164, %$13] ; # V2
  %176 = phi i64 [%151, %$12], [%169, %$13] ; # M
  %177 = phi i64 [%152, %$12], [%170, %$13] ; # N
  %178 = phi i64 [%153, %$12], [%163, %$13] ; # D
  %179 = phi i64 [%154, %$12], [%167, %$13] ; # Q
; # (when (lt0 M) (ret (if Rem (zapZero (val U)) ZERO)))
; # (lt0 M)
  %180 = icmp slt i64 %176, 0
  br i1 %180, label %$15, label %$16
$15:
  %181 = phi i64 [%171, %$14] ; # A
  %182 = phi i64 [%172, %$14] ; # B
  %183 = phi i64 [%173, %$14] ; # R
  %184 = phi i64 [%174, %$14] ; # P
  %185 = phi i64 [%175, %$14] ; # V2
  %186 = phi i64 [%176, %$14] ; # M
  %187 = phi i64 [%177, %$14] ; # N
  %188 = phi i64 [%178, %$14] ; # D
  %189 = phi i64 [%179, %$14] ; # Q
; # (if Rem (zapZero (val U)) ZERO)
  br i1 %2, label %$17, label %$18
$17:
  %190 = phi i64 [%181, %$15] ; # A
  %191 = phi i64 [%182, %$15] ; # B
  %192 = phi i64 [%183, %$15] ; # R
  %193 = phi i64 [%184, %$15] ; # P
  %194 = phi i64 [%185, %$15] ; # V2
  %195 = phi i64 [%186, %$15] ; # M
  %196 = phi i64 [%187, %$15] ; # N
  %197 = phi i64 [%188, %$15] ; # D
  %198 = phi i64 [%189, %$15] ; # Q
; # (val U)
  %199 = inttoptr i64 %16 to i64*
  %200 = load i64, i64* %199
; # (zapZero (val U))
  %201 = call i64 @zapZero(i64 %200)
  br label %$19
$18:
  %202 = phi i64 [%181, %$15] ; # A
  %203 = phi i64 [%182, %$15] ; # B
  %204 = phi i64 [%183, %$15] ; # R
  %205 = phi i64 [%184, %$15] ; # P
  %206 = phi i64 [%185, %$15] ; # V2
  %207 = phi i64 [%186, %$15] ; # M
  %208 = phi i64 [%187, %$15] ; # N
  %209 = phi i64 [%188, %$15] ; # D
  %210 = phi i64 [%189, %$15] ; # Q
  br label %$19
$19:
  %211 = phi i64 [%190, %$17], [%202, %$18] ; # A
  %212 = phi i64 [%191, %$17], [%203, %$18] ; # B
  %213 = phi i64 [%192, %$17], [%204, %$18] ; # R
  %214 = phi i64 [%193, %$17], [%205, %$18] ; # P
  %215 = phi i64 [%194, %$17], [%206, %$18] ; # V2
  %216 = phi i64 [%195, %$17], [%207, %$18] ; # M
  %217 = phi i64 [%196, %$17], [%208, %$18] ; # N
  %218 = phi i64 [%197, %$17], [%209, %$18] ; # D
  %219 = phi i64 [%198, %$17], [%210, %$18] ; # Q
  %220 = phi i64 [%201, %$17], [2, %$18] ; # ->
; # (ret (if Rem (zapZero (val U)) ZERO))
; # (drop *Safe)
  %221 = inttoptr i64 %6 to i64*
  %222 = getelementptr i64, i64* %221, i32 1
  %223 = load i64, i64* %222
  %224 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %223, i64* %224
  ret i64 %220
$16:
  %225 = phi i64 [%171, %$14] ; # A
  %226 = phi i64 [%172, %$14] ; # B
  %227 = phi i64 [%173, %$14] ; # R
  %228 = phi i64 [%174, %$14] ; # P
  %229 = phi i64 [%175, %$14] ; # V2
  %230 = phi i64 [%176, %$14] ; # M
  %231 = phi i64 [%177, %$14] ; # N
  %232 = phi i64 [%178, %$14] ; # D
  %233 = phi i64 [%179, %$14] ; # Q
  br label %$9
$9:
  %234 = phi i64 [%91, %$7], [%225, %$16] ; # A
  %235 = phi i64 [%92, %$7], [%226, %$16] ; # B
  %236 = phi i64 [%93, %$7], [%227, %$16] ; # R
  %237 = phi i64 [%94, %$7], [%228, %$16] ; # P
  %238 = phi i64 [%95, %$7], [%229, %$16] ; # V2
  %239 = phi i64 [%96, %$7], [%230, %$16] ; # M
  %240 = phi i64 [%97, %$7], [%231, %$16] ; # N
  %241 = phi i64 [%98, %$7], [%232, %$16] ; # D
  %242 = phi i64 [%100, %$7], [%233, %$16] ; # Q
; # (set (big P) (boxNum 0))
; # (big P)
  %243 = add i64 %237, 4
; # (boxNum 0)
  %244 = call i64 @boxNum(i64 0)
  %245 = inttoptr i64 %243 to i64*
  store i64 %244, i64* %245
; # (while (ge0 (val (dig Q))) (twiceBig (val U)) (twiceBig (val V)) ...
  br label %$20
$20:
  %246 = phi i64 [%234, %$9], [%259, %$21] ; # A
  %247 = phi i64 [%235, %$9], [%260, %$21] ; # B
  %248 = phi i64 [%236, %$9], [%261, %$21] ; # R
  %249 = phi i64 [%237, %$9], [%262, %$21] ; # P
  %250 = phi i64 [%238, %$9], [%263, %$21] ; # V2
  %251 = phi i64 [%239, %$9], [%264, %$21] ; # M
  %252 = phi i64 [%240, %$9], [%265, %$21] ; # N
  %253 = phi i64 [%241, %$9], [%274, %$21] ; # D
  %254 = phi i64 [%242, %$9], [%267, %$21] ; # Q
; # (dig Q)
  %255 = add i64 %254, -4
; # (val (dig Q))
  %256 = inttoptr i64 %255 to i64*
  %257 = load i64, i64* %256
; # (ge0 (val (dig Q)))
  %258 = icmp sge i64 %257, 0
  br i1 %258, label %$21, label %$22
$21:
  %259 = phi i64 [%246, %$20] ; # A
  %260 = phi i64 [%247, %$20] ; # B
  %261 = phi i64 [%248, %$20] ; # R
  %262 = phi i64 [%249, %$20] ; # P
  %263 = phi i64 [%250, %$20] ; # V2
  %264 = phi i64 [%251, %$20] ; # M
  %265 = phi i64 [%252, %$20] ; # N
  %266 = phi i64 [%253, %$20] ; # D
  %267 = phi i64 [%254, %$20] ; # Q
; # (val U)
  %268 = inttoptr i64 %16 to i64*
  %269 = load i64, i64* %268
; # (twiceBig (val U))
  %270 = call i64 @twiceBig(i64 %269)
; # (val V)
  %271 = inttoptr i64 %24 to i64*
  %272 = load i64, i64* %271
; # (twiceBig (val V))
  %273 = call i64 @twiceBig(i64 %272)
; # (inc 'D)
  %274 = add i64 %266, 1
  br label %$20
$22:
  %275 = phi i64 [%246, %$20] ; # A
  %276 = phi i64 [%247, %$20] ; # B
  %277 = phi i64 [%248, %$20] ; # R
  %278 = phi i64 [%249, %$20] ; # P
  %279 = phi i64 [%250, %$20] ; # V2
  %280 = phi i64 [%251, %$20] ; # M
  %281 = phi i64 [%252, %$20] ; # N
  %282 = phi i64 [%253, %$20] ; # D
  %283 = phi i64 [%254, %$20] ; # Q
; # (dig Q)
  %284 = add i64 %283, -4
; # (val (dig Q))
  %285 = inttoptr i64 %284 to i64*
  %286 = load i64, i64* %285
; # (when V2 (setq V2 (val (dig V2))))
  %287 = icmp ne i64 %279, 0
  br i1 %287, label %$23, label %$24
$23:
  %288 = phi i64 [%275, %$22] ; # A
  %289 = phi i64 [%276, %$22] ; # B
  %290 = phi i64 [%277, %$22] ; # R
  %291 = phi i64 [%278, %$22] ; # P
  %292 = phi i64 [%286, %$22] ; # V1
  %293 = phi i64 [%279, %$22] ; # V2
  %294 = phi i64 [%280, %$22] ; # M
  %295 = phi i64 [%281, %$22] ; # N
  %296 = phi i64 [%282, %$22] ; # D
  %297 = phi i64 [%283, %$22] ; # Q
; # (dig V2)
  %298 = add i64 %293, -4
; # (val (dig V2))
  %299 = inttoptr i64 %298 to i64*
  %300 = load i64, i64* %299
  br label %$24
$24:
  %301 = phi i64 [%275, %$22], [%288, %$23] ; # A
  %302 = phi i64 [%276, %$22], [%289, %$23] ; # B
  %303 = phi i64 [%277, %$22], [%290, %$23] ; # R
  %304 = phi i64 [%278, %$22], [%291, %$23] ; # P
  %305 = phi i64 [%286, %$22], [%292, %$23] ; # V1
  %306 = phi i64 [%279, %$22], [%300, %$23] ; # V2
  %307 = phi i64 [%280, %$22], [%294, %$23] ; # M
  %308 = phi i64 [%281, %$22], [%295, %$23] ; # N
  %309 = phi i64 [%282, %$22], [%296, %$23] ; # D
  %310 = phi i64 [%283, %$22], [%297, %$23] ; # Q
; # (loop (let (X (val U) U1 0 U2 0 U3 T) (let I M (while (ge0 (dec '...
  br label %$25
$25:
  %311 = phi i64 [%301, %$24], [%1016, %$56] ; # A
  %312 = phi i64 [%302, %$24], [%1017, %$56] ; # B
  %313 = phi i64 [%303, %$24], [%1018, %$56] ; # R
  %314 = phi i64 [%304, %$24], [%1019, %$56] ; # P
  %315 = phi i64 [%305, %$24], [%1020, %$56] ; # V1
  %316 = phi i64 [%306, %$24], [%1021, %$56] ; # V2
  %317 = phi i64 [%307, %$24], [%1022, %$56] ; # M
  %318 = phi i64 [%308, %$24], [%1023, %$56] ; # N
  %319 = phi i64 [%309, %$24], [%1024, %$56] ; # D
  %320 = phi i64 [%310, %$24], [%1025, %$56] ; # Q
; # (let (X (val U) U1 0 U2 0 U3 T) (let I M (while (ge0 (dec 'I)) (s...
; # (val U)
  %321 = inttoptr i64 %16 to i64*
  %322 = load i64, i64* %321
; # (let I M (while (ge0 (dec 'I)) (setq X (val (big X)))))
; # (while (ge0 (dec 'I)) (setq X (val (big X))))
  br label %$26
$26:
  %323 = phi i64 [%311, %$25], [%339, %$27] ; # A
  %324 = phi i64 [%312, %$25], [%340, %$27] ; # B
  %325 = phi i64 [%313, %$25], [%341, %$27] ; # R
  %326 = phi i64 [%314, %$25], [%342, %$27] ; # P
  %327 = phi i64 [%315, %$25], [%343, %$27] ; # V1
  %328 = phi i64 [%316, %$25], [%344, %$27] ; # V2
  %329 = phi i64 [%317, %$25], [%345, %$27] ; # M
  %330 = phi i64 [%318, %$25], [%346, %$27] ; # N
  %331 = phi i64 [%319, %$25], [%347, %$27] ; # D
  %332 = phi i64 [%320, %$25], [%348, %$27] ; # Q
  %333 = phi i64 [%322, %$25], [%355, %$27] ; # X
  %334 = phi i64 [0, %$25], [%350, %$27] ; # U1
  %335 = phi i64 [0, %$25], [%351, %$27] ; # U2
  %336 = phi i64 [%317, %$25], [%352, %$27] ; # I
; # (dec 'I)
  %337 = sub i64 %336, 1
; # (ge0 (dec 'I))
  %338 = icmp sge i64 %337, 0
  br i1 %338, label %$27, label %$28
$27:
  %339 = phi i64 [%323, %$26] ; # A
  %340 = phi i64 [%324, %$26] ; # B
  %341 = phi i64 [%325, %$26] ; # R
  %342 = phi i64 [%326, %$26] ; # P
  %343 = phi i64 [%327, %$26] ; # V1
  %344 = phi i64 [%328, %$26] ; # V2
  %345 = phi i64 [%329, %$26] ; # M
  %346 = phi i64 [%330, %$26] ; # N
  %347 = phi i64 [%331, %$26] ; # D
  %348 = phi i64 [%332, %$26] ; # Q
  %349 = phi i64 [%333, %$26] ; # X
  %350 = phi i64 [%334, %$26] ; # U1
  %351 = phi i64 [%335, %$26] ; # U2
  %352 = phi i64 [%337, %$26] ; # I
; # (big X)
  %353 = add i64 %349, 4
; # (val (big X))
  %354 = inttoptr i64 %353 to i64*
  %355 = load i64, i64* %354
  br label %$26
$28:
  %356 = phi i64 [%323, %$26] ; # A
  %357 = phi i64 [%324, %$26] ; # B
  %358 = phi i64 [%325, %$26] ; # R
  %359 = phi i64 [%326, %$26] ; # P
  %360 = phi i64 [%327, %$26] ; # V1
  %361 = phi i64 [%328, %$26] ; # V2
  %362 = phi i64 [%329, %$26] ; # M
  %363 = phi i64 [%330, %$26] ; # N
  %364 = phi i64 [%331, %$26] ; # D
  %365 = phi i64 [%332, %$26] ; # Q
  %366 = phi i64 [%333, %$26] ; # X
  %367 = phi i64 [%334, %$26] ; # U1
  %368 = phi i64 [%335, %$26] ; # U2
  %369 = phi i64 [%337, %$26] ; # I
; # (let (I N Y X) (loop (setq U3 U2 U2 U1 U1 (val (dig Y)) Y (val (b...
; # (loop (setq U3 U2 U2 U1 U1 (val (dig Y)) Y (val (big Y))) (? (lt0...
  br label %$29
$29:
  %370 = phi i64 [%356, %$28], [%393, %$30] ; # A
  %371 = phi i64 [%357, %$28], [%394, %$30] ; # B
  %372 = phi i64 [%358, %$28], [%395, %$30] ; # R
  %373 = phi i64 [%359, %$28], [%396, %$30] ; # P
  %374 = phi i64 [%360, %$28], [%397, %$30] ; # V1
  %375 = phi i64 [%361, %$28], [%398, %$30] ; # V2
  %376 = phi i64 [%362, %$28], [%399, %$30] ; # M
  %377 = phi i64 [%363, %$28], [%400, %$30] ; # N
  %378 = phi i64 [%364, %$28], [%401, %$30] ; # D
  %379 = phi i64 [%365, %$28], [%402, %$30] ; # Q
  %380 = phi i64 [%366, %$28], [%403, %$30] ; # X
  %381 = phi i64 [%367, %$28], [%404, %$30] ; # U1
  %382 = phi i64 [%368, %$28], [%405, %$30] ; # U2
  %383 = phi i64 [%363, %$28], [%407, %$30] ; # I
  %384 = phi i64 [%366, %$28], [%408, %$30] ; # Y
; # (dig Y)
  %385 = add i64 %384, -4
; # (val (dig Y))
  %386 = inttoptr i64 %385 to i64*
  %387 = load i64, i64* %386
; # (big Y)
  %388 = add i64 %384, 4
; # (val (big Y))
  %389 = inttoptr i64 %388 to i64*
  %390 = load i64, i64* %389
; # (? (lt0 (dec 'I)))
; # (dec 'I)
  %391 = sub i64 %383, 1
; # (lt0 (dec 'I))
  %392 = icmp slt i64 %391, 0
  br i1 %392, label %$31, label %$30
$30:
  %393 = phi i64 [%370, %$29] ; # A
  %394 = phi i64 [%371, %$29] ; # B
  %395 = phi i64 [%372, %$29] ; # R
  %396 = phi i64 [%373, %$29] ; # P
  %397 = phi i64 [%374, %$29] ; # V1
  %398 = phi i64 [%375, %$29] ; # V2
  %399 = phi i64 [%376, %$29] ; # M
  %400 = phi i64 [%377, %$29] ; # N
  %401 = phi i64 [%378, %$29] ; # D
  %402 = phi i64 [%379, %$29] ; # Q
  %403 = phi i64 [%380, %$29] ; # X
  %404 = phi i64 [%387, %$29] ; # U1
  %405 = phi i64 [%381, %$29] ; # U2
  %406 = phi i64 [%382, %$29] ; # U3
  %407 = phi i64 [%391, %$29] ; # I
  %408 = phi i64 [%390, %$29] ; # Y
  br label %$29
$31:
  %409 = phi i64 [%370, %$29] ; # A
  %410 = phi i64 [%371, %$29] ; # B
  %411 = phi i64 [%372, %$29] ; # R
  %412 = phi i64 [%373, %$29] ; # P
  %413 = phi i64 [%374, %$29] ; # V1
  %414 = phi i64 [%375, %$29] ; # V2
  %415 = phi i64 [%376, %$29] ; # M
  %416 = phi i64 [%377, %$29] ; # N
  %417 = phi i64 [%378, %$29] ; # D
  %418 = phi i64 [%379, %$29] ; # Q
  %419 = phi i64 [%380, %$29] ; # X
  %420 = phi i64 [%387, %$29] ; # U1
  %421 = phi i64 [%381, %$29] ; # U2
  %422 = phi i64 [%382, %$29] ; # U3
  %423 = phi i64 [%391, %$29] ; # I
  %424 = phi i64 [%390, %$29] ; # Y
  %425 = phi i64 [0, %$29] ; # ->
; # (let (Hi U1 Lo U2) (setq Q (if (== U1 V1) -1 (div Hi Lo V1))) (se...
; # (if (== U1 V1) -1 (div Hi Lo V1))
; # (== U1 V1)
  %426 = icmp eq i64 %420, %413
  br i1 %426, label %$32, label %$33
$32:
  %427 = phi i64 [%409, %$31] ; # A
  %428 = phi i64 [%410, %$31] ; # B
  %429 = phi i64 [%411, %$31] ; # R
  %430 = phi i64 [%412, %$31] ; # P
  %431 = phi i64 [%413, %$31] ; # V1
  %432 = phi i64 [%414, %$31] ; # V2
  %433 = phi i64 [%415, %$31] ; # M
  %434 = phi i64 [%416, %$31] ; # N
  %435 = phi i64 [%417, %$31] ; # D
  %436 = phi i64 [%418, %$31] ; # Q
  %437 = phi i64 [%419, %$31] ; # X
  %438 = phi i64 [%420, %$31] ; # U1
  %439 = phi i64 [%421, %$31] ; # U2
  %440 = phi i64 [%422, %$31] ; # U3
  %441 = phi i64 [%420, %$31] ; # Hi
  %442 = phi i64 [%421, %$31] ; # Lo
  br label %$34
$33:
  %443 = phi i64 [%409, %$31] ; # A
  %444 = phi i64 [%410, %$31] ; # B
  %445 = phi i64 [%411, %$31] ; # R
  %446 = phi i64 [%412, %$31] ; # P
  %447 = phi i64 [%413, %$31] ; # V1
  %448 = phi i64 [%414, %$31] ; # V2
  %449 = phi i64 [%415, %$31] ; # M
  %450 = phi i64 [%416, %$31] ; # N
  %451 = phi i64 [%417, %$31] ; # D
  %452 = phi i64 [%418, %$31] ; # Q
  %453 = phi i64 [%419, %$31] ; # X
  %454 = phi i64 [%420, %$31] ; # U1
  %455 = phi i64 [%421, %$31] ; # U2
  %456 = phi i64 [%422, %$31] ; # U3
  %457 = phi i64 [%420, %$31] ; # Hi
  %458 = phi i64 [%421, %$31] ; # Lo
; # (div Hi Lo V1)
  %459 = zext i64 %457 to i128
  %460 = shl i128 %459, 64
  %461 = zext i64 %458 to i128
  %462 = or i128 %460, %461
  %463 = zext i64 %447 to i128
  %464 = urem i128 %462, %463
  %465 = trunc i128 %464 to i64
  %466 = udiv i128 %462, %463
  %467 = trunc i128 %466 to i64
  br label %$34
$34:
  %468 = phi i64 [%427, %$32], [%443, %$33] ; # A
  %469 = phi i64 [%428, %$32], [%444, %$33] ; # B
  %470 = phi i64 [%429, %$32], [%445, %$33] ; # R
  %471 = phi i64 [%430, %$32], [%446, %$33] ; # P
  %472 = phi i64 [%431, %$32], [%447, %$33] ; # V1
  %473 = phi i64 [%432, %$32], [%448, %$33] ; # V2
  %474 = phi i64 [%433, %$32], [%449, %$33] ; # M
  %475 = phi i64 [%434, %$32], [%450, %$33] ; # N
  %476 = phi i64 [%435, %$32], [%451, %$33] ; # D
  %477 = phi i64 [%436, %$32], [%452, %$33] ; # Q
  %478 = phi i64 [%437, %$32], [%453, %$33] ; # X
  %479 = phi i64 [%438, %$32], [%454, %$33] ; # U1
  %480 = phi i64 [%439, %$32], [%455, %$33] ; # U2
  %481 = phi i64 [%440, %$32], [%456, %$33] ; # U3
  %482 = phi i64 [%441, %$32], [%457, %$33] ; # Hi
  %483 = phi i64 [%442, %$32], [%458, %$33] ; # Lo
  %484 = phi i64 [-1, %$32], [%467, %$33] ; # ->
; # (mul Q V1)
  %485 = zext i64 %484 to i128
  %486 = zext i64 %472 to i128
  %487 = mul i128 %485, %486
  %488 = lshr i128 %487, 64
  %489 = trunc i128 %488 to i64
  %490 = trunc i128 %487 to i64
; # (sub Lo (mul Q V1))
  %491 = call {i64, i1} @llvm.usub.with.overflow.i64(i64 %483, i64 %490)
  %492 = extractvalue {i64, i1} %491, 1
  %493 = extractvalue {i64, i1} %491, 0
; # (sub Hi @@@ @@)
  %494 = call {i64, i1} @llvm.usub.with.overflow.i64(i64 %482, i64 %489)
  %495 = extractvalue {i64, i1} %494, 1
  %496 = extractvalue {i64, i1} %494, 0
  %497 = zext i1 %492 to i64
  %498 = call {i64, i1} @llvm.usub.with.overflow.i64(i64 %496, i64 %497)
  %499 = extractvalue {i64, i1} %498, 1
  %500 = or i1 %495, %499
  %501 = extractvalue {i64, i1} %498, 0
; # (until Hi (let L (mul Q V2) (? (> Lo @@@)) (? (and (== Lo @@@) (>...
  br label %$35
$35:
  %502 = phi i64 [%468, %$34], [%593, %$41] ; # A
  %503 = phi i64 [%469, %$34], [%594, %$41] ; # B
  %504 = phi i64 [%470, %$34], [%595, %$41] ; # R
  %505 = phi i64 [%471, %$34], [%596, %$41] ; # P
  %506 = phi i64 [%472, %$34], [%597, %$41] ; # V1
  %507 = phi i64 [%473, %$34], [%598, %$41] ; # V2
  %508 = phi i64 [%474, %$34], [%599, %$41] ; # M
  %509 = phi i64 [%475, %$34], [%600, %$41] ; # N
  %510 = phi i64 [%476, %$34], [%601, %$41] ; # D
  %511 = phi i64 [%484, %$34], [%609, %$41] ; # Q
  %512 = phi i64 [%478, %$34], [%603, %$41] ; # X
  %513 = phi i64 [%479, %$34], [%604, %$41] ; # U1
  %514 = phi i64 [%480, %$34], [%605, %$41] ; # U2
  %515 = phi i64 [%481, %$34], [%606, %$41] ; # U3
  %516 = phi i64 [%501, %$34], [%614, %$41] ; # Hi
  %517 = phi i64 [%493, %$34], [%612, %$41] ; # Lo
  %518 = icmp ne i64 %516, 0
  br i1 %518, label %$37, label %$36
$36:
  %519 = phi i64 [%502, %$35] ; # A
  %520 = phi i64 [%503, %$35] ; # B
  %521 = phi i64 [%504, %$35] ; # R
  %522 = phi i64 [%505, %$35] ; # P
  %523 = phi i64 [%506, %$35] ; # V1
  %524 = phi i64 [%507, %$35] ; # V2
  %525 = phi i64 [%508, %$35] ; # M
  %526 = phi i64 [%509, %$35] ; # N
  %527 = phi i64 [%510, %$35] ; # D
  %528 = phi i64 [%511, %$35] ; # Q
  %529 = phi i64 [%512, %$35] ; # X
  %530 = phi i64 [%513, %$35] ; # U1
  %531 = phi i64 [%514, %$35] ; # U2
  %532 = phi i64 [%515, %$35] ; # U3
  %533 = phi i64 [%516, %$35] ; # Hi
  %534 = phi i64 [%517, %$35] ; # Lo
; # (let L (mul Q V2) (? (> Lo @@@)) (? (and (== Lo @@@) (>= U3 L))))...
; # (mul Q V2)
  %535 = zext i64 %528 to i128
  %536 = zext i64 %524 to i128
  %537 = mul i128 %535, %536
  %538 = lshr i128 %537, 64
  %539 = trunc i128 %538 to i64
  %540 = trunc i128 %537 to i64
; # (? (> Lo @@@))
; # (> Lo @@@)
  %541 = icmp ugt i64 %534, %539
  br i1 %541, label %$37, label %$38
$38:
  %542 = phi i64 [%519, %$36] ; # A
  %543 = phi i64 [%520, %$36] ; # B
  %544 = phi i64 [%521, %$36] ; # R
  %545 = phi i64 [%522, %$36] ; # P
  %546 = phi i64 [%523, %$36] ; # V1
  %547 = phi i64 [%524, %$36] ; # V2
  %548 = phi i64 [%525, %$36] ; # M
  %549 = phi i64 [%526, %$36] ; # N
  %550 = phi i64 [%527, %$36] ; # D
  %551 = phi i64 [%528, %$36] ; # Q
  %552 = phi i64 [%529, %$36] ; # X
  %553 = phi i64 [%530, %$36] ; # U1
  %554 = phi i64 [%531, %$36] ; # U2
  %555 = phi i64 [%532, %$36] ; # U3
  %556 = phi i64 [%533, %$36] ; # Hi
  %557 = phi i64 [%534, %$36] ; # Lo
; # (? (and (== Lo @@@) (>= U3 L)))
; # (and (== Lo @@@) (>= U3 L))
; # (== Lo @@@)
  %558 = icmp eq i64 %557, %539
  br i1 %558, label %$40, label %$39
$40:
  %559 = phi i64 [%542, %$38] ; # A
  %560 = phi i64 [%543, %$38] ; # B
  %561 = phi i64 [%544, %$38] ; # R
  %562 = phi i64 [%545, %$38] ; # P
  %563 = phi i64 [%546, %$38] ; # V1
  %564 = phi i64 [%547, %$38] ; # V2
  %565 = phi i64 [%548, %$38] ; # M
  %566 = phi i64 [%549, %$38] ; # N
  %567 = phi i64 [%550, %$38] ; # D
  %568 = phi i64 [%551, %$38] ; # Q
  %569 = phi i64 [%552, %$38] ; # X
  %570 = phi i64 [%553, %$38] ; # U1
  %571 = phi i64 [%554, %$38] ; # U2
  %572 = phi i64 [%555, %$38] ; # U3
  %573 = phi i64 [%556, %$38] ; # Hi
  %574 = phi i64 [%557, %$38] ; # Lo
; # (>= U3 L)
  %575 = icmp uge i64 %572, %540
  br label %$39
$39:
  %576 = phi i64 [%542, %$38], [%559, %$40] ; # A
  %577 = phi i64 [%543, %$38], [%560, %$40] ; # B
  %578 = phi i64 [%544, %$38], [%561, %$40] ; # R
  %579 = phi i64 [%545, %$38], [%562, %$40] ; # P
  %580 = phi i64 [%546, %$38], [%563, %$40] ; # V1
  %581 = phi i64 [%547, %$38], [%564, %$40] ; # V2
  %582 = phi i64 [%548, %$38], [%565, %$40] ; # M
  %583 = phi i64 [%549, %$38], [%566, %$40] ; # N
  %584 = phi i64 [%550, %$38], [%567, %$40] ; # D
  %585 = phi i64 [%551, %$38], [%568, %$40] ; # Q
  %586 = phi i64 [%552, %$38], [%569, %$40] ; # X
  %587 = phi i64 [%553, %$38], [%570, %$40] ; # U1
  %588 = phi i64 [%554, %$38], [%571, %$40] ; # U2
  %589 = phi i64 [%555, %$38], [%572, %$40] ; # U3
  %590 = phi i64 [%556, %$38], [%573, %$40] ; # Hi
  %591 = phi i64 [%557, %$38], [%574, %$40] ; # Lo
  %592 = phi i1 [0, %$38], [%575, %$40] ; # ->
  br i1 %592, label %$37, label %$41
$41:
  %593 = phi i64 [%576, %$39] ; # A
  %594 = phi i64 [%577, %$39] ; # B
  %595 = phi i64 [%578, %$39] ; # R
  %596 = phi i64 [%579, %$39] ; # P
  %597 = phi i64 [%580, %$39] ; # V1
  %598 = phi i64 [%581, %$39] ; # V2
  %599 = phi i64 [%582, %$39] ; # M
  %600 = phi i64 [%583, %$39] ; # N
  %601 = phi i64 [%584, %$39] ; # D
  %602 = phi i64 [%585, %$39] ; # Q
  %603 = phi i64 [%586, %$39] ; # X
  %604 = phi i64 [%587, %$39] ; # U1
  %605 = phi i64 [%588, %$39] ; # U2
  %606 = phi i64 [%589, %$39] ; # U3
  %607 = phi i64 [%590, %$39] ; # Hi
  %608 = phi i64 [%591, %$39] ; # Lo
; # (dec 'Q)
  %609 = sub i64 %602, 1
; # (add Lo V1)
  %610 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %608, i64 %597)
  %611 = extractvalue {i64, i1} %610, 1
  %612 = extractvalue {i64, i1} %610, 0
; # (+ Hi @@)
  %613 = zext i1 %611 to i64
  %614 = add i64 %607, %613
  br label %$35
$37:
  %615 = phi i64 [%502, %$35], [%519, %$36], [%576, %$39] ; # A
  %616 = phi i64 [%503, %$35], [%520, %$36], [%577, %$39] ; # B
  %617 = phi i64 [%504, %$35], [%521, %$36], [%578, %$39] ; # R
  %618 = phi i64 [%505, %$35], [%522, %$36], [%579, %$39] ; # P
  %619 = phi i64 [%506, %$35], [%523, %$36], [%580, %$39] ; # V1
  %620 = phi i64 [%507, %$35], [%524, %$36], [%581, %$39] ; # V2
  %621 = phi i64 [%508, %$35], [%525, %$36], [%582, %$39] ; # M
  %622 = phi i64 [%509, %$35], [%526, %$36], [%583, %$39] ; # N
  %623 = phi i64 [%510, %$35], [%527, %$36], [%584, %$39] ; # D
  %624 = phi i64 [%511, %$35], [%528, %$36], [%585, %$39] ; # Q
  %625 = phi i64 [%512, %$35], [%529, %$36], [%586, %$39] ; # X
  %626 = phi i64 [%513, %$35], [%530, %$36], [%587, %$39] ; # U1
  %627 = phi i64 [%514, %$35], [%531, %$36], [%588, %$39] ; # U2
  %628 = phi i64 [%515, %$35], [%532, %$36], [%589, %$39] ; # U3
  %629 = phi i64 [%516, %$35], [%533, %$36], [%590, %$39] ; # Hi
  %630 = phi i64 [%517, %$35], [%534, %$36], [%591, %$39] ; # Lo
; # (let (Z X Y (val V)) (set (dig Z) (sub (val (dig Z)) (mul Q (val ...
; # (val V)
  %631 = inttoptr i64 %24 to i64*
  %632 = load i64, i64* %631
; # (set (dig Z) (sub (val (dig Z)) (mul Q (val (dig Y)))))
; # (dig Z)
  %633 = add i64 %625, -4
; # (dig Z)
  %634 = add i64 %625, -4
; # (val (dig Z))
  %635 = inttoptr i64 %634 to i64*
  %636 = load i64, i64* %635
; # (dig Y)
  %637 = add i64 %632, -4
; # (val (dig Y))
  %638 = inttoptr i64 %637 to i64*
  %639 = load i64, i64* %638
; # (mul Q (val (dig Y)))
  %640 = zext i64 %624 to i128
  %641 = zext i64 %639 to i128
  %642 = mul i128 %640, %641
  %643 = lshr i128 %642, 64
  %644 = trunc i128 %643 to i64
  %645 = trunc i128 %642 to i64
; # (sub (val (dig Z)) (mul Q (val (dig Y))))
  %646 = call {i64, i1} @llvm.usub.with.overflow.i64(i64 %636, i64 %645)
  %647 = extractvalue {i64, i1} %646, 1
  %648 = extractvalue {i64, i1} %646, 0
  %649 = inttoptr i64 %633 to i64*
  store i64 %648, i64* %649
; # (+ @@@ @@)
  %650 = zext i1 %647 to i64
  %651 = add i64 %644, %650
; # (while (big? (setq Y (val (big Y)))) (setq Z (val (big Z))) (set ...
  br label %$42
$42:
  %652 = phi i64 [%615, %$37], [%675, %$43] ; # A
  %653 = phi i64 [%616, %$37], [%676, %$43] ; # B
  %654 = phi i64 [%617, %$37], [%677, %$43] ; # R
  %655 = phi i64 [%618, %$37], [%678, %$43] ; # P
  %656 = phi i64 [%619, %$37], [%679, %$43] ; # V1
  %657 = phi i64 [%620, %$37], [%680, %$43] ; # V2
  %658 = phi i64 [%621, %$37], [%681, %$43] ; # M
  %659 = phi i64 [%622, %$37], [%682, %$43] ; # N
  %660 = phi i64 [%623, %$37], [%683, %$43] ; # D
  %661 = phi i64 [%624, %$37], [%684, %$43] ; # Q
  %662 = phi i64 [%625, %$37], [%685, %$43] ; # X
  %663 = phi i64 [%626, %$37], [%686, %$43] ; # U1
  %664 = phi i64 [%627, %$37], [%687, %$43] ; # U2
  %665 = phi i64 [%628, %$37], [%688, %$43] ; # U3
  %666 = phi i64 [%651, %$37], [%732, %$43] ; # Hi
  %667 = phi i64 [%630, %$37], [%690, %$43] ; # Lo
  %668 = phi i64 [%625, %$37], [%695, %$43] ; # Z
  %669 = phi i64 [%632, %$37], [%692, %$43] ; # Y
; # (big Y)
  %670 = add i64 %669, 4
; # (val (big Y))
  %671 = inttoptr i64 %670 to i64*
  %672 = load i64, i64* %671
; # (big? (setq Y (val (big Y))))
  %673 = and i64 %672, 4
  %674 = icmp ne i64 %673, 0
  br i1 %674, label %$43, label %$44
$43:
  %675 = phi i64 [%652, %$42] ; # A
  %676 = phi i64 [%653, %$42] ; # B
  %677 = phi i64 [%654, %$42] ; # R
  %678 = phi i64 [%655, %$42] ; # P
  %679 = phi i64 [%656, %$42] ; # V1
  %680 = phi i64 [%657, %$42] ; # V2
  %681 = phi i64 [%658, %$42] ; # M
  %682 = phi i64 [%659, %$42] ; # N
  %683 = phi i64 [%660, %$42] ; # D
  %684 = phi i64 [%661, %$42] ; # Q
  %685 = phi i64 [%662, %$42] ; # X
  %686 = phi i64 [%663, %$42] ; # U1
  %687 = phi i64 [%664, %$42] ; # U2
  %688 = phi i64 [%665, %$42] ; # U3
  %689 = phi i64 [%666, %$42] ; # Hi
  %690 = phi i64 [%667, %$42] ; # Lo
  %691 = phi i64 [%668, %$42] ; # Z
  %692 = phi i64 [%672, %$42] ; # Y
; # (big Z)
  %693 = add i64 %691, 4
; # (val (big Z))
  %694 = inttoptr i64 %693 to i64*
  %695 = load i64, i64* %694
; # (set (dig Z) (sub (val (dig Z)) Hi))
; # (dig Z)
  %696 = add i64 %695, -4
; # (dig Z)
  %697 = add i64 %695, -4
; # (val (dig Z))
  %698 = inttoptr i64 %697 to i64*
  %699 = load i64, i64* %698
; # (sub (val (dig Z)) Hi)
  %700 = call {i64, i1} @llvm.usub.with.overflow.i64(i64 %699, i64 %689)
  %701 = extractvalue {i64, i1} %700, 1
  %702 = extractvalue {i64, i1} %700, 0
  %703 = inttoptr i64 %696 to i64*
  store i64 %702, i64* %703
; # (- Hi Hi @@)
  %704 = sub i64 %689, %689
  %705 = zext i1 %701 to i64
  %706 = sub i64 %704, %705
; # (set (dig Z) (sub (val (dig Z)) (mul Q (val (dig Y)))))
; # (dig Z)
  %707 = add i64 %695, -4
; # (dig Z)
  %708 = add i64 %695, -4
; # (val (dig Z))
  %709 = inttoptr i64 %708 to i64*
  %710 = load i64, i64* %709
; # (dig Y)
  %711 = add i64 %692, -4
; # (val (dig Y))
  %712 = inttoptr i64 %711 to i64*
  %713 = load i64, i64* %712
; # (mul Q (val (dig Y)))
  %714 = zext i64 %684 to i128
  %715 = zext i64 %713 to i128
  %716 = mul i128 %714, %715
  %717 = lshr i128 %716, 64
  %718 = trunc i128 %717 to i64
  %719 = trunc i128 %716 to i64
; # (sub (val (dig Z)) (mul Q (val (dig Y))))
  %720 = call {i64, i1} @llvm.usub.with.overflow.i64(i64 %710, i64 %719)
  %721 = extractvalue {i64, i1} %720, 1
  %722 = extractvalue {i64, i1} %720, 0
  %723 = inttoptr i64 %707 to i64*
  store i64 %722, i64* %723
; # (sub Hi @@@ @@)
  %724 = call {i64, i1} @llvm.usub.with.overflow.i64(i64 %706, i64 %718)
  %725 = extractvalue {i64, i1} %724, 1
  %726 = extractvalue {i64, i1} %724, 0
  %727 = zext i1 %721 to i64
  %728 = call {i64, i1} @llvm.usub.with.overflow.i64(i64 %726, i64 %727)
  %729 = extractvalue {i64, i1} %728, 1
  %730 = or i1 %725, %729
  %731 = extractvalue {i64, i1} %728, 0
; # (- (sub Hi @@@ @@))
  %732 = sub i64 0, %731
  br label %$42
$44:
  %733 = phi i64 [%652, %$42] ; # A
  %734 = phi i64 [%653, %$42] ; # B
  %735 = phi i64 [%654, %$42] ; # R
  %736 = phi i64 [%655, %$42] ; # P
  %737 = phi i64 [%656, %$42] ; # V1
  %738 = phi i64 [%657, %$42] ; # V2
  %739 = phi i64 [%658, %$42] ; # M
  %740 = phi i64 [%659, %$42] ; # N
  %741 = phi i64 [%660, %$42] ; # D
  %742 = phi i64 [%661, %$42] ; # Q
  %743 = phi i64 [%662, %$42] ; # X
  %744 = phi i64 [%663, %$42] ; # U1
  %745 = phi i64 [%664, %$42] ; # U2
  %746 = phi i64 [%665, %$42] ; # U3
  %747 = phi i64 [%666, %$42] ; # Hi
  %748 = phi i64 [%667, %$42] ; # Lo
  %749 = phi i64 [%668, %$42] ; # Z
  %750 = phi i64 [%672, %$42] ; # Y
; # (when Hi (setq Z (val (big Z))) (set (dig Z) (sub (val (dig Z)) H...
  %751 = icmp ne i64 %747, 0
  br i1 %751, label %$45, label %$46
$45:
  %752 = phi i64 [%733, %$44] ; # A
  %753 = phi i64 [%734, %$44] ; # B
  %754 = phi i64 [%735, %$44] ; # R
  %755 = phi i64 [%736, %$44] ; # P
  %756 = phi i64 [%737, %$44] ; # V1
  %757 = phi i64 [%738, %$44] ; # V2
  %758 = phi i64 [%739, %$44] ; # M
  %759 = phi i64 [%740, %$44] ; # N
  %760 = phi i64 [%741, %$44] ; # D
  %761 = phi i64 [%742, %$44] ; # Q
  %762 = phi i64 [%743, %$44] ; # X
  %763 = phi i64 [%744, %$44] ; # U1
  %764 = phi i64 [%745, %$44] ; # U2
  %765 = phi i64 [%746, %$44] ; # U3
  %766 = phi i64 [%747, %$44] ; # Hi
  %767 = phi i64 [%748, %$44] ; # Lo
  %768 = phi i64 [%749, %$44] ; # Z
  %769 = phi i64 [%750, %$44] ; # Y
; # (big Z)
  %770 = add i64 %768, 4
; # (val (big Z))
  %771 = inttoptr i64 %770 to i64*
  %772 = load i64, i64* %771
; # (set (dig Z) (sub (val (dig Z)) Hi))
; # (dig Z)
  %773 = add i64 %772, -4
; # (dig Z)
  %774 = add i64 %772, -4
; # (val (dig Z))
  %775 = inttoptr i64 %774 to i64*
  %776 = load i64, i64* %775
; # (sub (val (dig Z)) Hi)
  %777 = call {i64, i1} @llvm.usub.with.overflow.i64(i64 %776, i64 %766)
  %778 = extractvalue {i64, i1} %777, 1
  %779 = extractvalue {i64, i1} %777, 0
  %780 = inttoptr i64 %773 to i64*
  store i64 %779, i64* %780
; # (when @@ (dec 'Q) (when (or Rem M) (setq Y (val V)) (set (dig X) ...
  br i1 %778, label %$47, label %$48
$47:
  %781 = phi i64 [%752, %$45] ; # A
  %782 = phi i64 [%753, %$45] ; # B
  %783 = phi i64 [%754, %$45] ; # R
  %784 = phi i64 [%755, %$45] ; # P
  %785 = phi i64 [%756, %$45] ; # V1
  %786 = phi i64 [%757, %$45] ; # V2
  %787 = phi i64 [%758, %$45] ; # M
  %788 = phi i64 [%759, %$45] ; # N
  %789 = phi i64 [%760, %$45] ; # D
  %790 = phi i64 [%761, %$45] ; # Q
  %791 = phi i64 [%762, %$45] ; # X
  %792 = phi i64 [%763, %$45] ; # U1
  %793 = phi i64 [%764, %$45] ; # U2
  %794 = phi i64 [%765, %$45] ; # U3
  %795 = phi i64 [%766, %$45] ; # Hi
  %796 = phi i64 [%767, %$45] ; # Lo
  %797 = phi i64 [%772, %$45] ; # Z
  %798 = phi i64 [%769, %$45] ; # Y
; # (dec 'Q)
  %799 = sub i64 %790, 1
; # (when (or Rem M) (setq Y (val V)) (set (dig X) (add (val (dig X))...
; # (or Rem M)
  br i1 %2, label %$49, label %$50
$50:
  %800 = phi i64 [%781, %$47] ; # A
  %801 = phi i64 [%782, %$47] ; # B
  %802 = phi i64 [%783, %$47] ; # R
  %803 = phi i64 [%784, %$47] ; # P
  %804 = phi i64 [%785, %$47] ; # V1
  %805 = phi i64 [%786, %$47] ; # V2
  %806 = phi i64 [%787, %$47] ; # M
  %807 = phi i64 [%788, %$47] ; # N
  %808 = phi i64 [%789, %$47] ; # D
  %809 = phi i64 [%799, %$47] ; # Q
  %810 = phi i64 [%791, %$47] ; # X
  %811 = phi i64 [%792, %$47] ; # U1
  %812 = phi i64 [%793, %$47] ; # U2
  %813 = phi i64 [%794, %$47] ; # U3
  %814 = phi i64 [%795, %$47] ; # Hi
  %815 = phi i64 [%796, %$47] ; # Lo
  %816 = phi i64 [%797, %$47] ; # Z
  %817 = phi i64 [%798, %$47] ; # Y
  %818 = icmp ne i64 %806, 0
  br label %$49
$49:
  %819 = phi i64 [%781, %$47], [%800, %$50] ; # A
  %820 = phi i64 [%782, %$47], [%801, %$50] ; # B
  %821 = phi i64 [%783, %$47], [%802, %$50] ; # R
  %822 = phi i64 [%784, %$47], [%803, %$50] ; # P
  %823 = phi i64 [%785, %$47], [%804, %$50] ; # V1
  %824 = phi i64 [%786, %$47], [%805, %$50] ; # V2
  %825 = phi i64 [%787, %$47], [%806, %$50] ; # M
  %826 = phi i64 [%788, %$47], [%807, %$50] ; # N
  %827 = phi i64 [%789, %$47], [%808, %$50] ; # D
  %828 = phi i64 [%799, %$47], [%809, %$50] ; # Q
  %829 = phi i64 [%791, %$47], [%810, %$50] ; # X
  %830 = phi i64 [%792, %$47], [%811, %$50] ; # U1
  %831 = phi i64 [%793, %$47], [%812, %$50] ; # U2
  %832 = phi i64 [%794, %$47], [%813, %$50] ; # U3
  %833 = phi i64 [%795, %$47], [%814, %$50] ; # Hi
  %834 = phi i64 [%796, %$47], [%815, %$50] ; # Lo
  %835 = phi i64 [%797, %$47], [%816, %$50] ; # Z
  %836 = phi i64 [%798, %$47], [%817, %$50] ; # Y
  %837 = phi i1 [1, %$47], [%818, %$50] ; # ->
  br i1 %837, label %$51, label %$52
$51:
  %838 = phi i64 [%819, %$49] ; # A
  %839 = phi i64 [%820, %$49] ; # B
  %840 = phi i64 [%821, %$49] ; # R
  %841 = phi i64 [%822, %$49] ; # P
  %842 = phi i64 [%823, %$49] ; # V1
  %843 = phi i64 [%824, %$49] ; # V2
  %844 = phi i64 [%825, %$49] ; # M
  %845 = phi i64 [%826, %$49] ; # N
  %846 = phi i64 [%827, %$49] ; # D
  %847 = phi i64 [%828, %$49] ; # Q
  %848 = phi i64 [%829, %$49] ; # X
  %849 = phi i64 [%830, %$49] ; # U1
  %850 = phi i64 [%831, %$49] ; # U2
  %851 = phi i64 [%832, %$49] ; # U3
  %852 = phi i64 [%833, %$49] ; # Hi
  %853 = phi i64 [%834, %$49] ; # Lo
  %854 = phi i64 [%835, %$49] ; # Z
  %855 = phi i64 [%836, %$49] ; # Y
; # (val V)
  %856 = inttoptr i64 %24 to i64*
  %857 = load i64, i64* %856
; # (set (dig X) (add (val (dig X)) (val (dig Y))))
; # (dig X)
  %858 = add i64 %848, -4
; # (dig X)
  %859 = add i64 %848, -4
; # (val (dig X))
  %860 = inttoptr i64 %859 to i64*
  %861 = load i64, i64* %860
; # (dig Y)
  %862 = add i64 %857, -4
; # (val (dig Y))
  %863 = inttoptr i64 %862 to i64*
  %864 = load i64, i64* %863
; # (add (val (dig X)) (val (dig Y)))
  %865 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %861, i64 %864)
  %866 = extractvalue {i64, i1} %865, 1
  %867 = extractvalue {i64, i1} %865, 0
  %868 = inttoptr i64 %858 to i64*
  store i64 %867, i64* %868
; # (let C @@ (loop (setq X (val (big X))) (? (cnt? (setq Y (val (big...
; # (loop (setq X (val (big X))) (? (cnt? (setq Y (val (big Y))))) (s...
  br label %$53
$53:
  %869 = phi i64 [%838, %$51], [%896, %$54] ; # A
  %870 = phi i64 [%839, %$51], [%897, %$54] ; # B
  %871 = phi i64 [%840, %$51], [%898, %$54] ; # R
  %872 = phi i64 [%841, %$51], [%899, %$54] ; # P
  %873 = phi i64 [%842, %$51], [%900, %$54] ; # V1
  %874 = phi i64 [%843, %$51], [%901, %$54] ; # V2
  %875 = phi i64 [%844, %$51], [%902, %$54] ; # M
  %876 = phi i64 [%845, %$51], [%903, %$54] ; # N
  %877 = phi i64 [%846, %$51], [%904, %$54] ; # D
  %878 = phi i64 [%847, %$51], [%905, %$54] ; # Q
  %879 = phi i64 [%848, %$51], [%906, %$54] ; # X
  %880 = phi i64 [%849, %$51], [%907, %$54] ; # U1
  %881 = phi i64 [%850, %$51], [%908, %$54] ; # U2
  %882 = phi i64 [%851, %$51], [%909, %$54] ; # U3
  %883 = phi i64 [%852, %$51], [%910, %$54] ; # Hi
  %884 = phi i64 [%853, %$51], [%911, %$54] ; # Lo
  %885 = phi i64 [%854, %$51], [%912, %$54] ; # Z
  %886 = phi i64 [%857, %$51], [%913, %$54] ; # Y
  %887 = phi i1 [%866, %$51], [%928, %$54] ; # C
; # (big X)
  %888 = add i64 %879, 4
; # (val (big X))
  %889 = inttoptr i64 %888 to i64*
  %890 = load i64, i64* %889
; # (? (cnt? (setq Y (val (big Y)))))
; # (big Y)
  %891 = add i64 %886, 4
; # (val (big Y))
  %892 = inttoptr i64 %891 to i64*
  %893 = load i64, i64* %892
; # (cnt? (setq Y (val (big Y))))
  %894 = and i64 %893, 2
  %895 = icmp ne i64 %894, 0
  br i1 %895, label %$55, label %$54
$54:
  %896 = phi i64 [%869, %$53] ; # A
  %897 = phi i64 [%870, %$53] ; # B
  %898 = phi i64 [%871, %$53] ; # R
  %899 = phi i64 [%872, %$53] ; # P
  %900 = phi i64 [%873, %$53] ; # V1
  %901 = phi i64 [%874, %$53] ; # V2
  %902 = phi i64 [%875, %$53] ; # M
  %903 = phi i64 [%876, %$53] ; # N
  %904 = phi i64 [%877, %$53] ; # D
  %905 = phi i64 [%878, %$53] ; # Q
  %906 = phi i64 [%890, %$53] ; # X
  %907 = phi i64 [%880, %$53] ; # U1
  %908 = phi i64 [%881, %$53] ; # U2
  %909 = phi i64 [%882, %$53] ; # U3
  %910 = phi i64 [%883, %$53] ; # Hi
  %911 = phi i64 [%884, %$53] ; # Lo
  %912 = phi i64 [%885, %$53] ; # Z
  %913 = phi i64 [%893, %$53] ; # Y
  %914 = phi i1 [%887, %$53] ; # C
; # (set (dig X) (add (val (dig X)) (val (dig Y)) C))
; # (dig X)
  %915 = add i64 %906, -4
; # (dig X)
  %916 = add i64 %906, -4
; # (val (dig X))
  %917 = inttoptr i64 %916 to i64*
  %918 = load i64, i64* %917
; # (dig Y)
  %919 = add i64 %913, -4
; # (val (dig Y))
  %920 = inttoptr i64 %919 to i64*
  %921 = load i64, i64* %920
; # (add (val (dig X)) (val (dig Y)) C)
  %922 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %918, i64 %921)
  %923 = extractvalue {i64, i1} %922, 1
  %924 = extractvalue {i64, i1} %922, 0
  %925 = zext i1 %914 to i64
  %926 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %924, i64 %925)
  %927 = extractvalue {i64, i1} %926, 1
  %928 = or i1 %923, %927
  %929 = extractvalue {i64, i1} %926, 0
  %930 = inttoptr i64 %915 to i64*
  store i64 %929, i64* %930
  br label %$53
$55:
  %931 = phi i64 [%869, %$53] ; # A
  %932 = phi i64 [%870, %$53] ; # B
  %933 = phi i64 [%871, %$53] ; # R
  %934 = phi i64 [%872, %$53] ; # P
  %935 = phi i64 [%873, %$53] ; # V1
  %936 = phi i64 [%874, %$53] ; # V2
  %937 = phi i64 [%875, %$53] ; # M
  %938 = phi i64 [%876, %$53] ; # N
  %939 = phi i64 [%877, %$53] ; # D
  %940 = phi i64 [%878, %$53] ; # Q
  %941 = phi i64 [%890, %$53] ; # X
  %942 = phi i64 [%880, %$53] ; # U1
  %943 = phi i64 [%881, %$53] ; # U2
  %944 = phi i64 [%882, %$53] ; # U3
  %945 = phi i64 [%883, %$53] ; # Hi
  %946 = phi i64 [%884, %$53] ; # Lo
  %947 = phi i64 [%885, %$53] ; # Z
  %948 = phi i64 [%893, %$53] ; # Y
  %949 = phi i1 [%887, %$53] ; # C
  %950 = phi i64 [0, %$53] ; # ->
; # (set (dig X) (+ (val (dig X)) C))
; # (dig X)
  %951 = add i64 %941, -4
; # (dig X)
  %952 = add i64 %941, -4
; # (val (dig X))
  %953 = inttoptr i64 %952 to i64*
  %954 = load i64, i64* %953
; # (+ (val (dig X)) C)
  %955 = zext i1 %949 to i64
  %956 = add i64 %954, %955
  %957 = inttoptr i64 %951 to i64*
  store i64 %956, i64* %957
  br label %$52
$52:
  %958 = phi i64 [%819, %$49], [%931, %$55] ; # A
  %959 = phi i64 [%820, %$49], [%932, %$55] ; # B
  %960 = phi i64 [%821, %$49], [%933, %$55] ; # R
  %961 = phi i64 [%822, %$49], [%934, %$55] ; # P
  %962 = phi i64 [%823, %$49], [%935, %$55] ; # V1
  %963 = phi i64 [%824, %$49], [%936, %$55] ; # V2
  %964 = phi i64 [%825, %$49], [%937, %$55] ; # M
  %965 = phi i64 [%826, %$49], [%938, %$55] ; # N
  %966 = phi i64 [%827, %$49], [%939, %$55] ; # D
  %967 = phi i64 [%828, %$49], [%940, %$55] ; # Q
  %968 = phi i64 [%829, %$49], [%941, %$55] ; # X
  %969 = phi i64 [%830, %$49], [%942, %$55] ; # U1
  %970 = phi i64 [%831, %$49], [%943, %$55] ; # U2
  %971 = phi i64 [%832, %$49], [%944, %$55] ; # U3
  %972 = phi i64 [%833, %$49], [%945, %$55] ; # Hi
  %973 = phi i64 [%834, %$49], [%946, %$55] ; # Lo
  %974 = phi i64 [%835, %$49], [%947, %$55] ; # Z
  %975 = phi i64 [%836, %$49], [%948, %$55] ; # Y
  br label %$48
$48:
  %976 = phi i64 [%752, %$45], [%958, %$52] ; # A
  %977 = phi i64 [%753, %$45], [%959, %$52] ; # B
  %978 = phi i64 [%754, %$45], [%960, %$52] ; # R
  %979 = phi i64 [%755, %$45], [%961, %$52] ; # P
  %980 = phi i64 [%756, %$45], [%962, %$52] ; # V1
  %981 = phi i64 [%757, %$45], [%963, %$52] ; # V2
  %982 = phi i64 [%758, %$45], [%964, %$52] ; # M
  %983 = phi i64 [%759, %$45], [%965, %$52] ; # N
  %984 = phi i64 [%760, %$45], [%966, %$52] ; # D
  %985 = phi i64 [%761, %$45], [%967, %$52] ; # Q
  %986 = phi i64 [%762, %$45], [%968, %$52] ; # X
  %987 = phi i64 [%763, %$45], [%969, %$52] ; # U1
  %988 = phi i64 [%764, %$45], [%970, %$52] ; # U2
  %989 = phi i64 [%765, %$45], [%971, %$52] ; # U3
  %990 = phi i64 [%766, %$45], [%972, %$52] ; # Hi
  %991 = phi i64 [%767, %$45], [%973, %$52] ; # Lo
  %992 = phi i64 [%772, %$45], [%974, %$52] ; # Z
  %993 = phi i64 [%769, %$45], [%975, %$52] ; # Y
  br label %$46
$46:
  %994 = phi i64 [%733, %$44], [%976, %$48] ; # A
  %995 = phi i64 [%734, %$44], [%977, %$48] ; # B
  %996 = phi i64 [%735, %$44], [%978, %$48] ; # R
  %997 = phi i64 [%736, %$44], [%979, %$48] ; # P
  %998 = phi i64 [%737, %$44], [%980, %$48] ; # V1
  %999 = phi i64 [%738, %$44], [%981, %$48] ; # V2
  %1000 = phi i64 [%739, %$44], [%982, %$48] ; # M
  %1001 = phi i64 [%740, %$44], [%983, %$48] ; # N
  %1002 = phi i64 [%741, %$44], [%984, %$48] ; # D
  %1003 = phi i64 [%742, %$44], [%985, %$48] ; # Q
  %1004 = phi i64 [%743, %$44], [%986, %$48] ; # X
  %1005 = phi i64 [%744, %$44], [%987, %$48] ; # U1
  %1006 = phi i64 [%745, %$44], [%988, %$48] ; # U2
  %1007 = phi i64 [%746, %$44], [%989, %$48] ; # U3
  %1008 = phi i64 [%747, %$44], [%990, %$48] ; # Hi
  %1009 = phi i64 [%748, %$44], [%991, %$48] ; # Lo
  %1010 = phi i64 [%749, %$44], [%992, %$48] ; # Z
  %1011 = phi i64 [%750, %$44], [%993, %$48] ; # Y
; # (consNum Q R)
  %1012 = call i64 @consNum(i64 %1003, i64 %996)
; # (safe (consNum Q R))
  %1013 = inttoptr i64 %6 to i64*
  store i64 %1012, i64* %1013
; # (? (lt0 (dec 'M)))
; # (dec 'M)
  %1014 = sub i64 %1000, 1
; # (lt0 (dec 'M))
  %1015 = icmp slt i64 %1014, 0
  br i1 %1015, label %$57, label %$56
$56:
  %1016 = phi i64 [%994, %$46] ; # A
  %1017 = phi i64 [%995, %$46] ; # B
  %1018 = phi i64 [%1012, %$46] ; # R
  %1019 = phi i64 [%997, %$46] ; # P
  %1020 = phi i64 [%998, %$46] ; # V1
  %1021 = phi i64 [%999, %$46] ; # V2
  %1022 = phi i64 [%1014, %$46] ; # M
  %1023 = phi i64 [%1001, %$46] ; # N
  %1024 = phi i64 [%1002, %$46] ; # D
  %1025 = phi i64 [%1003, %$46] ; # Q
  br label %$25
$57:
  %1026 = phi i64 [%994, %$46] ; # A
  %1027 = phi i64 [%995, %$46] ; # B
  %1028 = phi i64 [%1012, %$46] ; # R
  %1029 = phi i64 [%997, %$46] ; # P
  %1030 = phi i64 [%998, %$46] ; # V1
  %1031 = phi i64 [%999, %$46] ; # V2
  %1032 = phi i64 [%1014, %$46] ; # M
  %1033 = phi i64 [%1001, %$46] ; # N
  %1034 = phi i64 [%1002, %$46] ; # D
  %1035 = phi i64 [%1003, %$46] ; # Q
  %1036 = phi i64 [0, %$46] ; # ->
; # (ifn Rem (zapZero R) (setq A (zapZero (val U))) (while D (setq A ...
  br i1 %2, label %$59, label %$58
$58:
  %1037 = phi i64 [%1026, %$57] ; # A
  %1038 = phi i64 [%1027, %$57] ; # B
  %1039 = phi i64 [%1028, %$57] ; # R
  %1040 = phi i64 [%1029, %$57] ; # P
  %1041 = phi i64 [%1030, %$57] ; # V1
  %1042 = phi i64 [%1031, %$57] ; # V2
  %1043 = phi i64 [%1032, %$57] ; # M
  %1044 = phi i64 [%1033, %$57] ; # N
  %1045 = phi i64 [%1034, %$57] ; # D
  %1046 = phi i64 [%1035, %$57] ; # Q
; # (zapZero R)
  %1047 = call i64 @zapZero(i64 %1039)
  br label %$60
$59:
  %1048 = phi i64 [%1026, %$57] ; # A
  %1049 = phi i64 [%1027, %$57] ; # B
  %1050 = phi i64 [%1028, %$57] ; # R
  %1051 = phi i64 [%1029, %$57] ; # P
  %1052 = phi i64 [%1030, %$57] ; # V1
  %1053 = phi i64 [%1031, %$57] ; # V2
  %1054 = phi i64 [%1032, %$57] ; # M
  %1055 = phi i64 [%1033, %$57] ; # N
  %1056 = phi i64 [%1034, %$57] ; # D
  %1057 = phi i64 [%1035, %$57] ; # Q
; # (val U)
  %1058 = inttoptr i64 %16 to i64*
  %1059 = load i64, i64* %1058
; # (zapZero (val U))
  %1060 = call i64 @zapZero(i64 %1059)
; # (while D (setq A (half A)) (dec 'D))
  br label %$61
$61:
  %1061 = phi i64 [%1060, %$59], [%1082, %$62] ; # A
  %1062 = phi i64 [%1049, %$59], [%1073, %$62] ; # B
  %1063 = phi i64 [%1050, %$59], [%1074, %$62] ; # R
  %1064 = phi i64 [%1051, %$59], [%1075, %$62] ; # P
  %1065 = phi i64 [%1052, %$59], [%1076, %$62] ; # V1
  %1066 = phi i64 [%1053, %$59], [%1077, %$62] ; # V2
  %1067 = phi i64 [%1054, %$59], [%1078, %$62] ; # M
  %1068 = phi i64 [%1055, %$59], [%1079, %$62] ; # N
  %1069 = phi i64 [%1056, %$59], [%1083, %$62] ; # D
  %1070 = phi i64 [%1057, %$59], [%1081, %$62] ; # Q
  %1071 = icmp ne i64 %1069, 0
  br i1 %1071, label %$62, label %$63
$62:
  %1072 = phi i64 [%1061, %$61] ; # A
  %1073 = phi i64 [%1062, %$61] ; # B
  %1074 = phi i64 [%1063, %$61] ; # R
  %1075 = phi i64 [%1064, %$61] ; # P
  %1076 = phi i64 [%1065, %$61] ; # V1
  %1077 = phi i64 [%1066, %$61] ; # V2
  %1078 = phi i64 [%1067, %$61] ; # M
  %1079 = phi i64 [%1068, %$61] ; # N
  %1080 = phi i64 [%1069, %$61] ; # D
  %1081 = phi i64 [%1070, %$61] ; # Q
; # (half A)
  %1082 = call i64 @half(i64 %1072)
; # (dec 'D)
  %1083 = sub i64 %1080, 1
  br label %$61
$63:
  %1084 = phi i64 [%1061, %$61] ; # A
  %1085 = phi i64 [%1062, %$61] ; # B
  %1086 = phi i64 [%1063, %$61] ; # R
  %1087 = phi i64 [%1064, %$61] ; # P
  %1088 = phi i64 [%1065, %$61] ; # V1
  %1089 = phi i64 [%1066, %$61] ; # V2
  %1090 = phi i64 [%1067, %$61] ; # M
  %1091 = phi i64 [%1068, %$61] ; # N
  %1092 = phi i64 [%1069, %$61] ; # D
  %1093 = phi i64 [%1070, %$61] ; # Q
  br label %$60
$60:
  %1094 = phi i64 [%1037, %$58], [%1084, %$63] ; # A
  %1095 = phi i64 [%1038, %$58], [%1085, %$63] ; # B
  %1096 = phi i64 [%1039, %$58], [%1086, %$63] ; # R
  %1097 = phi i64 [%1040, %$58], [%1087, %$63] ; # P
  %1098 = phi i64 [%1041, %$58], [%1088, %$63] ; # V1
  %1099 = phi i64 [%1042, %$58], [%1089, %$63] ; # V2
  %1100 = phi i64 [%1043, %$58], [%1090, %$63] ; # M
  %1101 = phi i64 [%1044, %$58], [%1091, %$63] ; # N
  %1102 = phi i64 [%1045, %$58], [%1092, %$63] ; # D
  %1103 = phi i64 [%1046, %$58], [%1093, %$63] ; # Q
  %1104 = phi i64 [%1047, %$58], [%1084, %$63] ; # ->
; # (drop *Safe)
  %1105 = inttoptr i64 %6 to i64*
  %1106 = getelementptr i64, i64* %1105, i32 1
  %1107 = load i64, i64* %1106
  %1108 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %1107, i64* %1108
  ret i64 %1104
}

define i64 @divu(i64, i64) align 8 {
$1:
; # (cond ((big? A) (div1 A B NO)) ((big? B) ZERO) (T (cnt (/ (int A)...
; # (big? A)
  %2 = and i64 %0, 4
  %3 = icmp ne i64 %2, 0
  br i1 %3, label %$4, label %$3
$4:
; # (div1 A B NO)
  %4 = call i64 @div1(i64 %0, i64 %1, i1 0)
  br label %$2
$3:
; # (big? B)
  %5 = and i64 %1, 4
  %6 = icmp ne i64 %5, 0
  br i1 %6, label %$6, label %$5
$6:
  br label %$2
$5:
; # (int A)
  %7 = lshr i64 %0, 4
; # (int B)
  %8 = lshr i64 %1, 4
; # (/ (int A) (int B))
  %9 = udiv i64 %7, %8
; # (cnt (/ (int A) (int B)))
  %10 = shl i64 %9, 4
  %11 = or i64 %10, 2
  br label %$2
$2:
  %12 = phi i64 [%4, %$4], [2, %$6], [%11, %$5] ; # ->
  ret i64 %12
}

define i64 @remu(i64, i64) align 8 {
$1:
; # (cond ((big? A) (div1 A B YES)) ((big? B) A) (T (cnt (% (int A) (...
; # (big? A)
  %2 = and i64 %0, 4
  %3 = icmp ne i64 %2, 0
  br i1 %3, label %$4, label %$3
$4:
; # (div1 A B YES)
  %4 = call i64 @div1(i64 %0, i64 %1, i1 1)
  br label %$2
$3:
; # (big? B)
  %5 = and i64 %1, 4
  %6 = icmp ne i64 %5, 0
  br i1 %6, label %$6, label %$5
$6:
  br label %$2
$5:
; # (int A)
  %7 = lshr i64 %0, 4
; # (int B)
  %8 = lshr i64 %1, 4
; # (% (int A) (int B))
  %9 = urem i64 %7, %8
; # (cnt (% (int A) (int B)))
  %10 = shl i64 %9, 4
  %11 = or i64 %10, 2
  br label %$2
$2:
  %12 = phi i64 [%4, %$4], [%0, %$6], [%11, %$5] ; # ->
  ret i64 %12
}

define i64 @incs(i64) align 8 {
$1:
; # (if (sign? A) (neg (subu (pos A) ONE)) (addu A ONE))
; # (sign? A)
  %1 = and i64 %0, 8
  %2 = icmp ne i64 %1, 0
  br i1 %2, label %$2, label %$3
$2:
; # (pos A)
  %3 = and i64 %0, -9
; # (subu (pos A) ONE)
  %4 = call i64 @subu(i64 %3, i64 18)
; # (neg (subu (pos A) ONE))
  %5 = icmp eq i64 %4, 2
  br i1 %5, label %$5, label %$6
$5:
  br label %$7
$6:
  %6 = xor i64 %4, 8
  br label %$7
$7:
  %7 = phi i64 [%4, %$5], [%6, %$6] ; # ->
  br label %$4
$3:
; # (addu A ONE)
  %8 = call i64 @addu(i64 %0, i64 18)
  br label %$4
$4:
  %9 = phi i64 [%7, %$7], [%8, %$3] ; # ->
  ret i64 %9
}

define i64 @decs(i64) align 8 {
$1:
; # (if (sign? A) (neg (addu (pos A) ONE)) (subu A ONE))
; # (sign? A)
  %1 = and i64 %0, 8
  %2 = icmp ne i64 %1, 0
  br i1 %2, label %$2, label %$3
$2:
; # (pos A)
  %3 = and i64 %0, -9
; # (addu (pos A) ONE)
  %4 = call i64 @addu(i64 %3, i64 18)
; # (neg (addu (pos A) ONE))
  %5 = icmp eq i64 %4, 2
  br i1 %5, label %$5, label %$6
$5:
  br label %$7
$6:
  %6 = xor i64 %4, 8
  br label %$7
$7:
  %7 = phi i64 [%4, %$5], [%6, %$6] ; # ->
  br label %$4
$3:
; # (subu A ONE)
  %8 = call i64 @subu(i64 %0, i64 18)
  br label %$4
$4:
  %9 = phi i64 [%7, %$7], [%8, %$3] ; # ->
  ret i64 %9
}

define i64 @adds(i64, i64) align 8 {
$1:
; # (ifn (sign? A) (ifn (sign? B) (addu A B) (subu A (pos B))) (neg (...
; # (sign? A)
  %2 = and i64 %0, 8
  %3 = icmp ne i64 %2, 0
  br i1 %3, label %$3, label %$2
$2:
; # (ifn (sign? B) (addu A B) (subu A (pos B)))
; # (sign? B)
  %4 = and i64 %1, 8
  %5 = icmp ne i64 %4, 0
  br i1 %5, label %$6, label %$5
$5:
; # (addu A B)
  %6 = call i64 @addu(i64 %0, i64 %1)
  br label %$7
$6:
; # (pos B)
  %7 = and i64 %1, -9
; # (subu A (pos B))
  %8 = call i64 @subu(i64 %0, i64 %7)
  br label %$7
$7:
  %9 = phi i64 [%6, %$5], [%8, %$6] ; # ->
  br label %$4
$3:
; # (ifn (sign? B) (subu (pos A) B) (addu (pos A) (pos B)))
; # (sign? B)
  %10 = and i64 %1, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$9, label %$8
$8:
; # (pos A)
  %12 = and i64 %0, -9
; # (subu (pos A) B)
  %13 = call i64 @subu(i64 %12, i64 %1)
  br label %$10
$9:
; # (pos A)
  %14 = and i64 %0, -9
; # (pos B)
  %15 = and i64 %1, -9
; # (addu (pos A) (pos B))
  %16 = call i64 @addu(i64 %14, i64 %15)
  br label %$10
$10:
  %17 = phi i64 [%13, %$8], [%16, %$9] ; # ->
; # (neg (ifn (sign? B) (subu (pos A) B) (addu (pos A) (pos B))))
  %18 = icmp eq i64 %17, 2
  br i1 %18, label %$11, label %$12
$11:
  br label %$13
$12:
  %19 = xor i64 %17, 8
  br label %$13
$13:
  %20 = phi i64 [%17, %$11], [%19, %$12] ; # ->
  br label %$4
$4:
  %21 = phi i64 [%9, %$7], [%20, %$13] ; # ->
  ret i64 %21
}

define i64 @subs(i64, i64) align 8 {
$1:
; # (ifn (sign? A) (ifn (sign? B) (subu A B) (addu A (pos B))) (neg (...
; # (sign? A)
  %2 = and i64 %0, 8
  %3 = icmp ne i64 %2, 0
  br i1 %3, label %$3, label %$2
$2:
; # (ifn (sign? B) (subu A B) (addu A (pos B)))
; # (sign? B)
  %4 = and i64 %1, 8
  %5 = icmp ne i64 %4, 0
  br i1 %5, label %$6, label %$5
$5:
; # (subu A B)
  %6 = call i64 @subu(i64 %0, i64 %1)
  br label %$7
$6:
; # (pos B)
  %7 = and i64 %1, -9
; # (addu A (pos B))
  %8 = call i64 @addu(i64 %0, i64 %7)
  br label %$7
$7:
  %9 = phi i64 [%6, %$5], [%8, %$6] ; # ->
  br label %$4
$3:
; # (ifn (sign? B) (addu (pos A) B) (subu (pos A) (pos B)))
; # (sign? B)
  %10 = and i64 %1, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$9, label %$8
$8:
; # (pos A)
  %12 = and i64 %0, -9
; # (addu (pos A) B)
  %13 = call i64 @addu(i64 %12, i64 %1)
  br label %$10
$9:
; # (pos A)
  %14 = and i64 %0, -9
; # (pos B)
  %15 = and i64 %1, -9
; # (subu (pos A) (pos B))
  %16 = call i64 @subu(i64 %14, i64 %15)
  br label %$10
$10:
  %17 = phi i64 [%13, %$8], [%16, %$9] ; # ->
; # (neg (ifn (sign? B) (addu (pos A) B) (subu (pos A) (pos B))))
  %18 = icmp eq i64 %17, 2
  br i1 %18, label %$11, label %$12
$11:
  br label %$13
$12:
  %19 = xor i64 %17, 8
  br label %$13
$13:
  %20 = phi i64 [%17, %$11], [%19, %$12] ; # ->
  br label %$4
$4:
  %21 = phi i64 [%9, %$7], [%20, %$13] ; # ->
  ret i64 %21
}

define i64 @cmpu(i64, i64) align 8 {
$1:
; # (if (cnt? A) (cond ((or (big? B) (> B A)) -1) ((== B A) 0) (T 1))...
; # (cnt? A)
  %2 = and i64 %0, 2
  %3 = icmp ne i64 %2, 0
  br i1 %3, label %$2, label %$3
$2:
  %4 = phi i64 [%0, %$1] ; # A
  %5 = phi i64 [%1, %$1] ; # B
; # (cond ((or (big? B) (> B A)) -1) ((== B A) 0) (T 1))
; # (or (big? B) (> B A))
; # (big? B)
  %6 = and i64 %5, 4
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$6, label %$7
$7:
  %8 = phi i64 [%4, %$2] ; # A
  %9 = phi i64 [%5, %$2] ; # B
; # (> B A)
  %10 = icmp ugt i64 %9, %8
  br label %$6
$6:
  %11 = phi i64 [%4, %$2], [%8, %$7] ; # A
  %12 = phi i64 [%5, %$2], [%9, %$7] ; # B
  %13 = phi i1 [1, %$2], [%10, %$7] ; # ->
  br i1 %13, label %$9, label %$8
$9:
  %14 = phi i64 [%11, %$6] ; # A
  %15 = phi i64 [%12, %$6] ; # B
  br label %$5
$8:
  %16 = phi i64 [%11, %$6] ; # A
  %17 = phi i64 [%12, %$6] ; # B
; # (== B A)
  %18 = icmp eq i64 %17, %16
  br i1 %18, label %$11, label %$10
$11:
  %19 = phi i64 [%16, %$8] ; # A
  %20 = phi i64 [%17, %$8] ; # B
  br label %$5
$10:
  %21 = phi i64 [%16, %$8] ; # A
  %22 = phi i64 [%17, %$8] ; # B
  br label %$5
$5:
  %23 = phi i64 [%14, %$9], [%19, %$11], [%21, %$10] ; # A
  %24 = phi i64 [%15, %$9], [%20, %$11], [%22, %$10] ; # B
  %25 = phi i64 [-1, %$9], [0, %$11], [1, %$10] ; # ->
  br label %$4
$3:
  %26 = phi i64 [%0, %$1] ; # A
  %27 = phi i64 [%1, %$1] ; # B
; # (if (cnt? B) 1 (let (X 0 Y 0) (prog1 (loop (let (C (val (big A)) ...
; # (cnt? B)
  %28 = and i64 %27, 2
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %$12, label %$13
$12:
  %30 = phi i64 [%26, %$3] ; # A
  %31 = phi i64 [%27, %$3] ; # B
  br label %$14
$13:
  %32 = phi i64 [%26, %$3] ; # A
  %33 = phi i64 [%27, %$3] ; # B
; # (let (X 0 Y 0) (prog1 (loop (let (C (val (big A)) D (val (big B))...
; # (prog1 (loop (let (C (val (big A)) D (val (big B))) (? (== C D) (...
; # (loop (let (C (val (big A)) D (val (big B))) (? (== C D) (loop (s...
  br label %$15
$15:
  %34 = phi i64 [%32, %$13], [%199, %$36] ; # A
  %35 = phi i64 [%33, %$13], [%200, %$36] ; # B
  %36 = phi i64 [0, %$13], [%195, %$36] ; # X
  %37 = phi i64 [0, %$13], [%196, %$36] ; # Y
; # (let (C (val (big A)) D (val (big B))) (? (== C D) (loop (setq C ...
; # (big A)
  %38 = add i64 %34, 4
; # (val (big A))
  %39 = inttoptr i64 %38 to i64*
  %40 = load i64, i64* %39
; # (big B)
  %41 = add i64 %35, 4
; # (val (big B))
  %42 = inttoptr i64 %41 to i64*
  %43 = load i64, i64* %42
; # (? (== C D) (loop (setq C (val (dig A)) D (val (dig B))) (? (> D ...
; # (== C D)
  %44 = icmp eq i64 %40, %43
  br i1 %44, label %$18, label %$16
$18:
  %45 = phi i64 [%34, %$15] ; # A
  %46 = phi i64 [%35, %$15] ; # B
  %47 = phi i64 [%36, %$15] ; # X
  %48 = phi i64 [%37, %$15] ; # Y
  %49 = phi i64 [%40, %$15] ; # C
  %50 = phi i64 [%43, %$15] ; # D
; # (loop (setq C (val (dig A)) D (val (dig B))) (? (> D C) -1) (? (>...
  br label %$19
$19:
  %51 = phi i64 [%45, %$18], [%98, %$25] ; # A
  %52 = phi i64 [%46, %$18], [%99, %$25] ; # B
  %53 = phi i64 [%47, %$18], [%104, %$25] ; # X
  %54 = phi i64 [%48, %$18], [%109, %$25] ; # Y
  %55 = phi i64 [%49, %$18], [%100, %$25] ; # C
  %56 = phi i64 [%50, %$18], [%101, %$25] ; # D
; # (dig A)
  %57 = add i64 %51, -4
; # (val (dig A))
  %58 = inttoptr i64 %57 to i64*
  %59 = load i64, i64* %58
; # (dig B)
  %60 = add i64 %52, -4
; # (val (dig B))
  %61 = inttoptr i64 %60 to i64*
  %62 = load i64, i64* %61
; # (? (> D C) -1)
; # (> D C)
  %63 = icmp ugt i64 %62, %59
  br i1 %63, label %$22, label %$20
$22:
  %64 = phi i64 [%51, %$19] ; # A
  %65 = phi i64 [%52, %$19] ; # B
  %66 = phi i64 [%53, %$19] ; # X
  %67 = phi i64 [%54, %$19] ; # Y
  %68 = phi i64 [%59, %$19] ; # C
  %69 = phi i64 [%62, %$19] ; # D
  br label %$21
$20:
  %70 = phi i64 [%51, %$19] ; # A
  %71 = phi i64 [%52, %$19] ; # B
  %72 = phi i64 [%53, %$19] ; # X
  %73 = phi i64 [%54, %$19] ; # Y
  %74 = phi i64 [%59, %$19] ; # C
  %75 = phi i64 [%62, %$19] ; # D
; # (? (> C D) 1)
; # (> C D)
  %76 = icmp ugt i64 %74, %75
  br i1 %76, label %$24, label %$23
$24:
  %77 = phi i64 [%70, %$20] ; # A
  %78 = phi i64 [%71, %$20] ; # B
  %79 = phi i64 [%72, %$20] ; # X
  %80 = phi i64 [%73, %$20] ; # Y
  %81 = phi i64 [%74, %$20] ; # C
  %82 = phi i64 [%75, %$20] ; # D
  br label %$21
$23:
  %83 = phi i64 [%70, %$20] ; # A
  %84 = phi i64 [%71, %$20] ; # B
  %85 = phi i64 [%72, %$20] ; # X
  %86 = phi i64 [%73, %$20] ; # Y
  %87 = phi i64 [%74, %$20] ; # C
  %88 = phi i64 [%75, %$20] ; # D
; # (? (=0 X) 0)
; # (=0 X)
  %89 = icmp eq i64 %85, 0
  br i1 %89, label %$26, label %$25
$26:
  %90 = phi i64 [%83, %$23] ; # A
  %91 = phi i64 [%84, %$23] ; # B
  %92 = phi i64 [%85, %$23] ; # X
  %93 = phi i64 [%86, %$23] ; # Y
  %94 = phi i64 [%87, %$23] ; # C
  %95 = phi i64 [%88, %$23] ; # D
  br label %$21
$25:
  %96 = phi i64 [%83, %$23] ; # A
  %97 = phi i64 [%84, %$23] ; # B
  %98 = phi i64 [%85, %$23] ; # X
  %99 = phi i64 [%86, %$23] ; # Y
  %100 = phi i64 [%87, %$23] ; # C
  %101 = phi i64 [%88, %$23] ; # D
; # (let Z (val (big X)) (set (big X) A) (setq A X X Z))
; # (big X)
  %102 = add i64 %98, 4
; # (val (big X))
  %103 = inttoptr i64 %102 to i64*
  %104 = load i64, i64* %103
; # (set (big X) A)
; # (big X)
  %105 = add i64 %98, 4
  %106 = inttoptr i64 %105 to i64*
  store i64 %96, i64* %106
; # (let Z (val (big Y)) (set (big Y) B) (setq B Y Y Z))
; # (big Y)
  %107 = add i64 %99, 4
; # (val (big Y))
  %108 = inttoptr i64 %107 to i64*
  %109 = load i64, i64* %108
; # (set (big Y) B)
; # (big Y)
  %110 = add i64 %99, 4
  %111 = inttoptr i64 %110 to i64*
  store i64 %97, i64* %111
  br label %$19
$21:
  %112 = phi i64 [%64, %$22], [%77, %$24], [%90, %$26] ; # A
  %113 = phi i64 [%65, %$22], [%78, %$24], [%91, %$26] ; # B
  %114 = phi i64 [%66, %$22], [%79, %$24], [%92, %$26] ; # X
  %115 = phi i64 [%67, %$22], [%80, %$24], [%93, %$26] ; # Y
  %116 = phi i64 [%68, %$22], [%81, %$24], [%94, %$26] ; # C
  %117 = phi i64 [%69, %$22], [%82, %$24], [%95, %$26] ; # D
  %118 = phi i64 [-1, %$22], [1, %$24], [0, %$26] ; # ->
  br label %$17
$16:
  %119 = phi i64 [%34, %$15] ; # A
  %120 = phi i64 [%35, %$15] ; # B
  %121 = phi i64 [%36, %$15] ; # X
  %122 = phi i64 [%37, %$15] ; # Y
  %123 = phi i64 [%40, %$15] ; # C
  %124 = phi i64 [%43, %$15] ; # D
; # (? (cnt? C) (cond ((or (big? D) (> D C)) -1) ((== D C) 0) (T 1)))...
; # (cnt? C)
  %125 = and i64 %123, 2
  %126 = icmp ne i64 %125, 0
  br i1 %126, label %$28, label %$27
$28:
  %127 = phi i64 [%119, %$16] ; # A
  %128 = phi i64 [%120, %$16] ; # B
  %129 = phi i64 [%121, %$16] ; # X
  %130 = phi i64 [%122, %$16] ; # Y
  %131 = phi i64 [%123, %$16] ; # C
  %132 = phi i64 [%124, %$16] ; # D
; # (cond ((or (big? D) (> D C)) -1) ((== D C) 0) (T 1))
; # (or (big? D) (> D C))
; # (big? D)
  %133 = and i64 %132, 4
  %134 = icmp ne i64 %133, 0
  br i1 %134, label %$30, label %$31
$31:
  %135 = phi i64 [%127, %$28] ; # A
  %136 = phi i64 [%128, %$28] ; # B
  %137 = phi i64 [%129, %$28] ; # X
  %138 = phi i64 [%130, %$28] ; # Y
  %139 = phi i64 [%131, %$28] ; # C
  %140 = phi i64 [%132, %$28] ; # D
; # (> D C)
  %141 = icmp ugt i64 %140, %139
  br label %$30
$30:
  %142 = phi i64 [%127, %$28], [%135, %$31] ; # A
  %143 = phi i64 [%128, %$28], [%136, %$31] ; # B
  %144 = phi i64 [%129, %$28], [%137, %$31] ; # X
  %145 = phi i64 [%130, %$28], [%138, %$31] ; # Y
  %146 = phi i64 [%131, %$28], [%139, %$31] ; # C
  %147 = phi i64 [%132, %$28], [%140, %$31] ; # D
  %148 = phi i1 [1, %$28], [%141, %$31] ; # ->
  br i1 %148, label %$33, label %$32
$33:
  %149 = phi i64 [%142, %$30] ; # A
  %150 = phi i64 [%143, %$30] ; # B
  %151 = phi i64 [%144, %$30] ; # X
  %152 = phi i64 [%145, %$30] ; # Y
  %153 = phi i64 [%146, %$30] ; # C
  %154 = phi i64 [%147, %$30] ; # D
  br label %$29
$32:
  %155 = phi i64 [%142, %$30] ; # A
  %156 = phi i64 [%143, %$30] ; # B
  %157 = phi i64 [%144, %$30] ; # X
  %158 = phi i64 [%145, %$30] ; # Y
  %159 = phi i64 [%146, %$30] ; # C
  %160 = phi i64 [%147, %$30] ; # D
; # (== D C)
  %161 = icmp eq i64 %160, %159
  br i1 %161, label %$35, label %$34
$35:
  %162 = phi i64 [%155, %$32] ; # A
  %163 = phi i64 [%156, %$32] ; # B
  %164 = phi i64 [%157, %$32] ; # X
  %165 = phi i64 [%158, %$32] ; # Y
  %166 = phi i64 [%159, %$32] ; # C
  %167 = phi i64 [%160, %$32] ; # D
  br label %$29
$34:
  %168 = phi i64 [%155, %$32] ; # A
  %169 = phi i64 [%156, %$32] ; # B
  %170 = phi i64 [%157, %$32] ; # X
  %171 = phi i64 [%158, %$32] ; # Y
  %172 = phi i64 [%159, %$32] ; # C
  %173 = phi i64 [%160, %$32] ; # D
  br label %$29
$29:
  %174 = phi i64 [%149, %$33], [%162, %$35], [%168, %$34] ; # A
  %175 = phi i64 [%150, %$33], [%163, %$35], [%169, %$34] ; # B
  %176 = phi i64 [%151, %$33], [%164, %$35], [%170, %$34] ; # X
  %177 = phi i64 [%152, %$33], [%165, %$35], [%171, %$34] ; # Y
  %178 = phi i64 [%153, %$33], [%166, %$35], [%172, %$34] ; # C
  %179 = phi i64 [%154, %$33], [%167, %$35], [%173, %$34] ; # D
  %180 = phi i64 [-1, %$33], [0, %$35], [1, %$34] ; # ->
  br label %$17
$27:
  %181 = phi i64 [%119, %$16] ; # A
  %182 = phi i64 [%120, %$16] ; # B
  %183 = phi i64 [%121, %$16] ; # X
  %184 = phi i64 [%122, %$16] ; # Y
  %185 = phi i64 [%123, %$16] ; # C
  %186 = phi i64 [%124, %$16] ; # D
; # (? (cnt? D) 1)
; # (cnt? D)
  %187 = and i64 %186, 2
  %188 = icmp ne i64 %187, 0
  br i1 %188, label %$37, label %$36
$37:
  %189 = phi i64 [%181, %$27] ; # A
  %190 = phi i64 [%182, %$27] ; # B
  %191 = phi i64 [%183, %$27] ; # X
  %192 = phi i64 [%184, %$27] ; # Y
  %193 = phi i64 [%185, %$27] ; # C
  %194 = phi i64 [%186, %$27] ; # D
  br label %$17
$36:
  %195 = phi i64 [%181, %$27] ; # A
  %196 = phi i64 [%182, %$27] ; # B
  %197 = phi i64 [%183, %$27] ; # X
  %198 = phi i64 [%184, %$27] ; # Y
  %199 = phi i64 [%185, %$27] ; # C
  %200 = phi i64 [%186, %$27] ; # D
; # (set (big A) X)
; # (big A)
  %201 = add i64 %195, 4
  %202 = inttoptr i64 %201 to i64*
  store i64 %197, i64* %202
; # (set (big B) Y)
; # (big B)
  %203 = add i64 %196, 4
  %204 = inttoptr i64 %203 to i64*
  store i64 %198, i64* %204
  br label %$15
$17:
  %205 = phi i64 [%112, %$21], [%174, %$29], [%189, %$37] ; # A
  %206 = phi i64 [%113, %$21], [%175, %$29], [%190, %$37] ; # B
  %207 = phi i64 [%114, %$21], [%176, %$29], [%191, %$37] ; # X
  %208 = phi i64 [%115, %$21], [%177, %$29], [%192, %$37] ; # Y
  %209 = phi i64 [%118, %$21], [%180, %$29], [1, %$37] ; # ->
; # (while X (let Z (val (big X)) (set (big X) A) (setq A X X Z)) (le...
  br label %$38
$38:
  %210 = phi i64 [%205, %$17], [%217, %$39] ; # A
  %211 = phi i64 [%206, %$17], [%218, %$39] ; # B
  %212 = phi i64 [%207, %$17], [%221, %$39] ; # X
  %213 = phi i64 [%208, %$17], [%226, %$39] ; # Y
  %214 = icmp ne i64 %212, 0
  br i1 %214, label %$39, label %$40
$39:
  %215 = phi i64 [%210, %$38] ; # A
  %216 = phi i64 [%211, %$38] ; # B
  %217 = phi i64 [%212, %$38] ; # X
  %218 = phi i64 [%213, %$38] ; # Y
; # (let Z (val (big X)) (set (big X) A) (setq A X X Z))
; # (big X)
  %219 = add i64 %217, 4
; # (val (big X))
  %220 = inttoptr i64 %219 to i64*
  %221 = load i64, i64* %220
; # (set (big X) A)
; # (big X)
  %222 = add i64 %217, 4
  %223 = inttoptr i64 %222 to i64*
  store i64 %215, i64* %223
; # (let Z (val (big Y)) (set (big Y) B) (setq B Y Y Z))
; # (big Y)
  %224 = add i64 %218, 4
; # (val (big Y))
  %225 = inttoptr i64 %224 to i64*
  %226 = load i64, i64* %225
; # (set (big Y) B)
; # (big Y)
  %227 = add i64 %218, 4
  %228 = inttoptr i64 %227 to i64*
  store i64 %216, i64* %228
  br label %$38
$40:
  %229 = phi i64 [%210, %$38] ; # A
  %230 = phi i64 [%211, %$38] ; # B
  %231 = phi i64 [%212, %$38] ; # X
  %232 = phi i64 [%213, %$38] ; # Y
  br label %$14
$14:
  %233 = phi i64 [%30, %$12], [%229, %$40] ; # A
  %234 = phi i64 [%31, %$12], [%230, %$40] ; # B
  %235 = phi i64 [1, %$12], [%209, %$40] ; # ->
  br label %$4
$4:
  %236 = phi i64 [%23, %$5], [%233, %$14] ; # A
  %237 = phi i64 [%24, %$5], [%234, %$14] ; # B
  %238 = phi i64 [%25, %$5], [%235, %$14] ; # ->
  ret i64 %238
}

define i64 @cmpNum(i64, i64) align 8 {
$1:
; # (ifn (sign? A) (ifn (sign? B) (cmpu A B) 1) (ifn (sign? B) -1 (cm...
; # (sign? A)
  %2 = and i64 %0, 8
  %3 = icmp ne i64 %2, 0
  br i1 %3, label %$3, label %$2
$2:
; # (ifn (sign? B) (cmpu A B) 1)
; # (sign? B)
  %4 = and i64 %1, 8
  %5 = icmp ne i64 %4, 0
  br i1 %5, label %$6, label %$5
$5:
; # (cmpu A B)
  %6 = call i64 @cmpu(i64 %0, i64 %1)
  br label %$7
$6:
  br label %$7
$7:
  %7 = phi i64 [%6, %$5], [1, %$6] ; # ->
  br label %$4
$3:
; # (ifn (sign? B) -1 (cmpu (pos B) (pos A)))
; # (sign? B)
  %8 = and i64 %1, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$9, label %$8
$8:
  br label %$10
$9:
; # (pos B)
  %10 = and i64 %1, -9
; # (pos A)
  %11 = and i64 %0, -9
; # (cmpu (pos B) (pos A))
  %12 = call i64 @cmpu(i64 %10, i64 %11)
  br label %$10
$10:
  %13 = phi i64 [-1, %$8], [%12, %$9] ; # ->
  br label %$4
$4:
  %14 = phi i64 [%7, %$7], [%13, %$10] ; # ->
  ret i64 %14
}

define i64 @symToNum(i64, i64, i8, i8) align 8 {
$1:
; # (let (P (push 0 Name) Num (push ZERO NIL) Sign NO Frac NO B T) (u...
; # (push 0 Name)
  %4 = alloca i64, i64 2, align 16
  store i64 0, i64* %4
  %5 = getelementptr i64, i64* %4, i32 1
  store i64 %0, i64* %5
; # (push ZERO NIL)
  %6 = alloca i64, i64 2, align 16
  %7 = ptrtoint i64* %6 to i64
  %8 = inttoptr i64 %7 to i64*
  store i64 2, i64* %8
; # (until (> (setq B (symByte P)) (char " ")) (unless B (ret 0)))
  br label %$2
$2:
  %9 = phi i64 [%1, %$1], [%26, %$6] ; # Scl
  %10 = phi i64 [%7, %$1], [%27, %$6] ; # Num
  %11 = phi i1 [0, %$1], [%28, %$6] ; # Sign
  %12 = phi i1 [0, %$1], [%29, %$6] ; # Frac
; # (symByte P)
  %13 = call i8 @symByte(i64* %4)
; # (> (setq B (symByte P)) (char " "))
  %14 = icmp ugt i8 %13, 32
  br i1 %14, label %$4, label %$3
$3:
  %15 = phi i64 [%9, %$2] ; # Scl
  %16 = phi i64 [%10, %$2] ; # Num
  %17 = phi i1 [%11, %$2] ; # Sign
  %18 = phi i1 [%12, %$2] ; # Frac
  %19 = phi i8 [%13, %$2] ; # B
; # (unless B (ret 0))
  %20 = icmp ne i8 %19, 0
  br i1 %20, label %$6, label %$5
$5:
  %21 = phi i64 [%15, %$3] ; # Scl
  %22 = phi i64 [%16, %$3] ; # Num
  %23 = phi i1 [%17, %$3] ; # Sign
  %24 = phi i1 [%18, %$3] ; # Frac
  %25 = phi i8 [%19, %$3] ; # B
; # (ret 0)
  ret i64 0
$6:
  %26 = phi i64 [%15, %$3] ; # Scl
  %27 = phi i64 [%16, %$3] ; # Num
  %28 = phi i1 [%17, %$3] ; # Sign
  %29 = phi i1 [%18, %$3] ; # Frac
  %30 = phi i8 [%19, %$3] ; # B
  br label %$2
$4:
  %31 = phi i64 [%9, %$2] ; # Scl
  %32 = phi i64 [%10, %$2] ; # Num
  %33 = phi i1 [%11, %$2] ; # Sign
  %34 = phi i1 [%12, %$2] ; # Frac
  %35 = phi i8 [%13, %$2] ; # B
; # (cond ((== B (char "+")) (goto 1)) ((== B (char "-")) (setq Sign ...
; # (== B (char "+"))
  %36 = icmp eq i8 %35, 43
  br i1 %36, label %$9, label %$8
$9:
  %37 = phi i64 [%31, %$4] ; # Scl
  %38 = phi i64 [%32, %$4] ; # Num
  %39 = phi i1 [%33, %$4] ; # Sign
  %40 = phi i1 [%34, %$4] ; # Frac
  %41 = phi i8 [%35, %$4] ; # B
; # (goto 1)
  br label %$-1
$8:
  %42 = phi i64 [%31, %$4] ; # Scl
  %43 = phi i64 [%32, %$4] ; # Num
  %44 = phi i1 [%33, %$4] ; # Sign
  %45 = phi i1 [%34, %$4] ; # Frac
  %46 = phi i8 [%35, %$4] ; # B
; # (== B (char "-"))
  %47 = icmp eq i8 %46, 45
  br i1 %47, label %$11, label %$10
$11:
  %48 = phi i64 [%42, %$8] ; # Scl
  %49 = phi i64 [%43, %$8] ; # Num
  %50 = phi i1 [%44, %$8] ; # Sign
  %51 = phi i1 [%45, %$8] ; # Frac
  %52 = phi i8 [%46, %$8] ; # B
; # (: 1 (unless (setq B (symByte P)) (ret 0)))
  br label %$-1
$-1:
  %53 = phi i64 [%37, %$9], [%48, %$11] ; # Scl
  %54 = phi i64 [%38, %$9], [%49, %$11] ; # Num
  %55 = phi i1 [%39, %$9], [1, %$11] ; # Sign
  %56 = phi i1 [%40, %$9], [%51, %$11] ; # Frac
  %57 = phi i8 [%41, %$9], [%52, %$11] ; # B
; # (unless (setq B (symByte P)) (ret 0))
; # (symByte P)
  %58 = call i8 @symByte(i64* %4)
  %59 = icmp ne i8 %58, 0
  br i1 %59, label %$13, label %$12
$12:
  %60 = phi i64 [%53, %$-1] ; # Scl
  %61 = phi i64 [%54, %$-1] ; # Num
  %62 = phi i1 [%55, %$-1] ; # Sign
  %63 = phi i1 [%56, %$-1] ; # Frac
  %64 = phi i8 [%58, %$-1] ; # B
; # (ret 0)
  ret i64 0
$13:
  %65 = phi i64 [%53, %$-1] ; # Scl
  %66 = phi i64 [%54, %$-1] ; # Num
  %67 = phi i1 [%55, %$-1] ; # Sign
  %68 = phi i1 [%56, %$-1] ; # Frac
  %69 = phi i8 [%58, %$-1] ; # B
  br label %$7
$10:
  %70 = phi i64 [%42, %$8] ; # Scl
  %71 = phi i64 [%43, %$8] ; # Num
  %72 = phi i1 [%44, %$8] ; # Sign
  %73 = phi i1 [%45, %$8] ; # Frac
  %74 = phi i8 [%46, %$8] ; # B
  br label %$7
$7:
  %75 = phi i64 [%65, %$13], [%70, %$10] ; # Scl
  %76 = phi i64 [%66, %$13], [%71, %$10] ; # Num
  %77 = phi i1 [%67, %$13], [%72, %$10] ; # Sign
  %78 = phi i1 [%68, %$13], [%73, %$10] ; # Frac
  %79 = phi i8 [%69, %$13], [%74, %$10] ; # B
; # (when (> (dec 'B (char "0")) 9) (ret 0))
; # (dec 'B (char "0"))
  %80 = sub i8 %79, 48
; # (> (dec 'B (char "0")) 9)
  %81 = icmp ugt i8 %80, 9
  br i1 %81, label %$14, label %$15
$14:
  %82 = phi i64 [%75, %$7] ; # Scl
  %83 = phi i64 [%76, %$7] ; # Num
  %84 = phi i1 [%77, %$7] ; # Sign
  %85 = phi i1 [%78, %$7] ; # Frac
  %86 = phi i8 [%80, %$7] ; # B
; # (ret 0)
  ret i64 0
$15:
  %87 = phi i64 [%75, %$7] ; # Scl
  %88 = phi i64 [%76, %$7] ; # Num
  %89 = phi i1 [%77, %$7] ; # Sign
  %90 = phi i1 [%78, %$7] ; # Frac
  %91 = phi i8 [%80, %$7] ; # B
; # (set (link Num T) (cnt (i64 B)))
; # (link Num T)
  %92 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %93 = load i64, i64* %92
  %94 = inttoptr i64 %88 to i64*
  %95 = getelementptr i64, i64* %94, i32 1
  store i64 %93, i64* %95
  %96 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %88, i64* %96
; # (i64 B)
  %97 = zext i8 %91 to i64
; # (cnt (i64 B))
  %98 = shl i64 %97, 4
  %99 = or i64 %98, 2
  %100 = inttoptr i64 %88 to i64*
  store i64 %99, i64* %100
; # (while (setq B (symByte P)) (? (and Frac (=0 Scl)) (when (> (dec ...
  br label %$16
$16:
  %101 = phi i64 [%87, %$15], [%270, %$32] ; # Scl
  %102 = phi i64 [%88, %$15], [%271, %$32] ; # Num
  %103 = phi i1 [%89, %$15], [%272, %$32] ; # Sign
  %104 = phi i1 [%90, %$15], [%273, %$32] ; # Frac
  %105 = phi i8 [%91, %$15], [%274, %$32] ; # B
; # (symByte P)
  %106 = call i8 @symByte(i64* %4)
  %107 = icmp ne i8 %106, 0
  br i1 %107, label %$17, label %$18
$17:
  %108 = phi i64 [%101, %$16] ; # Scl
  %109 = phi i64 [%102, %$16] ; # Num
  %110 = phi i1 [%103, %$16] ; # Sign
  %111 = phi i1 [%104, %$16] ; # Frac
  %112 = phi i8 [%106, %$16] ; # B
; # (? (and Frac (=0 Scl)) (when (> (dec 'B (char "0")) 9) (ret 0)) (...
; # (and Frac (=0 Scl))
  br i1 %111, label %$20, label %$19
$20:
  %113 = phi i64 [%108, %$17] ; # Scl
  %114 = phi i64 [%109, %$17] ; # Num
  %115 = phi i1 [%110, %$17] ; # Sign
  %116 = phi i1 [%111, %$17] ; # Frac
  %117 = phi i8 [%112, %$17] ; # B
; # (=0 Scl)
  %118 = icmp eq i64 %113, 0
  br label %$19
$19:
  %119 = phi i64 [%108, %$17], [%113, %$20] ; # Scl
  %120 = phi i64 [%109, %$17], [%114, %$20] ; # Num
  %121 = phi i1 [%110, %$17], [%115, %$20] ; # Sign
  %122 = phi i1 [%111, %$17], [%116, %$20] ; # Frac
  %123 = phi i8 [%112, %$17], [%117, %$20] ; # B
  %124 = phi i1 [0, %$17], [%118, %$20] ; # ->
  br i1 %124, label %$22, label %$21
$22:
  %125 = phi i64 [%119, %$19] ; # Scl
  %126 = phi i64 [%120, %$19] ; # Num
  %127 = phi i1 [%121, %$19] ; # Sign
  %128 = phi i1 [%122, %$19] ; # Frac
  %129 = phi i8 [%123, %$19] ; # B
; # (when (> (dec 'B (char "0")) 9) (ret 0))
; # (dec 'B (char "0"))
  %130 = sub i8 %129, 48
; # (> (dec 'B (char "0")) 9)
  %131 = icmp ugt i8 %130, 9
  br i1 %131, label %$23, label %$24
$23:
  %132 = phi i64 [%125, %$22] ; # Scl
  %133 = phi i64 [%126, %$22] ; # Num
  %134 = phi i1 [%127, %$22] ; # Sign
  %135 = phi i1 [%128, %$22] ; # Frac
  %136 = phi i8 [%130, %$22] ; # B
; # (ret 0)
; # (drop *Safe)
  %137 = inttoptr i64 %88 to i64*
  %138 = getelementptr i64, i64* %137, i32 1
  %139 = load i64, i64* %138
  %140 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %139, i64* %140
  ret i64 0
$24:
  %141 = phi i64 [%125, %$22] ; # Scl
  %142 = phi i64 [%126, %$22] ; # Num
  %143 = phi i1 [%127, %$22] ; # Sign
  %144 = phi i1 [%128, %$22] ; # Frac
  %145 = phi i8 [%130, %$22] ; # B
; # (when (>= B 5) (set Num (addu (val Num) ONE)))
; # (>= B 5)
  %146 = icmp uge i8 %145, 5
  br i1 %146, label %$25, label %$26
$25:
  %147 = phi i64 [%141, %$24] ; # Scl
  %148 = phi i64 [%142, %$24] ; # Num
  %149 = phi i1 [%143, %$24] ; # Sign
  %150 = phi i1 [%144, %$24] ; # Frac
  %151 = phi i8 [%145, %$24] ; # B
; # (set Num (addu (val Num) ONE))
; # (val Num)
  %152 = inttoptr i64 %148 to i64*
  %153 = load i64, i64* %152
; # (addu (val Num) ONE)
  %154 = call i64 @addu(i64 %153, i64 18)
  %155 = inttoptr i64 %148 to i64*
  store i64 %154, i64* %155
  br label %$26
$26:
  %156 = phi i64 [%141, %$24], [%147, %$25] ; # Scl
  %157 = phi i64 [%142, %$24], [%148, %$25] ; # Num
  %158 = phi i1 [%143, %$24], [%149, %$25] ; # Sign
  %159 = phi i1 [%144, %$24], [%150, %$25] ; # Frac
  %160 = phi i8 [%145, %$24], [%151, %$25] ; # B
; # (while (setq B (symByte P)) (when (> (dec 'B (char "0")) 9) (ret ...
  br label %$27
$27:
  %161 = phi i64 [%156, %$26], [%184, %$31] ; # Scl
  %162 = phi i64 [%157, %$26], [%185, %$31] ; # Num
  %163 = phi i1 [%158, %$26], [%186, %$31] ; # Sign
  %164 = phi i1 [%159, %$26], [%187, %$31] ; # Frac
  %165 = phi i8 [%160, %$26], [%188, %$31] ; # B
; # (symByte P)
  %166 = call i8 @symByte(i64* %4)
  %167 = icmp ne i8 %166, 0
  br i1 %167, label %$28, label %$29
$28:
  %168 = phi i64 [%161, %$27] ; # Scl
  %169 = phi i64 [%162, %$27] ; # Num
  %170 = phi i1 [%163, %$27] ; # Sign
  %171 = phi i1 [%164, %$27] ; # Frac
  %172 = phi i8 [%166, %$27] ; # B
; # (when (> (dec 'B (char "0")) 9) (ret 0))
; # (dec 'B (char "0"))
  %173 = sub i8 %172, 48
; # (> (dec 'B (char "0")) 9)
  %174 = icmp ugt i8 %173, 9
  br i1 %174, label %$30, label %$31
$30:
  %175 = phi i64 [%168, %$28] ; # Scl
  %176 = phi i64 [%169, %$28] ; # Num
  %177 = phi i1 [%170, %$28] ; # Sign
  %178 = phi i1 [%171, %$28] ; # Frac
  %179 = phi i8 [%173, %$28] ; # B
; # (ret 0)
; # (drop *Safe)
  %180 = inttoptr i64 %88 to i64*
  %181 = getelementptr i64, i64* %180, i32 1
  %182 = load i64, i64* %181
  %183 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %182, i64* %183
  ret i64 0
$31:
  %184 = phi i64 [%168, %$28] ; # Scl
  %185 = phi i64 [%169, %$28] ; # Num
  %186 = phi i1 [%170, %$28] ; # Sign
  %187 = phi i1 [%171, %$28] ; # Frac
  %188 = phi i8 [%173, %$28] ; # B
  br label %$27
$29:
  %189 = phi i64 [%161, %$27] ; # Scl
  %190 = phi i64 [%162, %$27] ; # Num
  %191 = phi i1 [%163, %$27] ; # Sign
  %192 = phi i1 [%164, %$27] ; # Frac
  %193 = phi i8 [%166, %$27] ; # B
  br label %$18
$21:
  %194 = phi i64 [%119, %$19] ; # Scl
  %195 = phi i64 [%120, %$19] ; # Num
  %196 = phi i1 [%121, %$19] ; # Sign
  %197 = phi i1 [%122, %$19] ; # Frac
  %198 = phi i8 [%123, %$19] ; # B
; # (cond ((== B Sep) (when Frac (ret 0)) (setq Frac YES)) ((<> B Ign...
; # (== B Sep)
  %199 = icmp eq i8 %198, %2
  br i1 %199, label %$34, label %$33
$34:
  %200 = phi i64 [%194, %$21] ; # Scl
  %201 = phi i64 [%195, %$21] ; # Num
  %202 = phi i1 [%196, %$21] ; # Sign
  %203 = phi i1 [%197, %$21] ; # Frac
  %204 = phi i8 [%198, %$21] ; # B
; # (when Frac (ret 0))
  br i1 %203, label %$35, label %$36
$35:
  %205 = phi i64 [%200, %$34] ; # Scl
  %206 = phi i64 [%201, %$34] ; # Num
  %207 = phi i1 [%202, %$34] ; # Sign
  %208 = phi i1 [%203, %$34] ; # Frac
  %209 = phi i8 [%204, %$34] ; # B
; # (ret 0)
; # (drop *Safe)
  %210 = inttoptr i64 %88 to i64*
  %211 = getelementptr i64, i64* %210, i32 1
  %212 = load i64, i64* %211
  %213 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %212, i64* %213
  ret i64 0
$36:
  %214 = phi i64 [%200, %$34] ; # Scl
  %215 = phi i64 [%201, %$34] ; # Num
  %216 = phi i1 [%202, %$34] ; # Sign
  %217 = phi i1 [%203, %$34] ; # Frac
  %218 = phi i8 [%204, %$34] ; # B
  br label %$32
$33:
  %219 = phi i64 [%194, %$21] ; # Scl
  %220 = phi i64 [%195, %$21] ; # Num
  %221 = phi i1 [%196, %$21] ; # Sign
  %222 = phi i1 [%197, %$21] ; # Frac
  %223 = phi i8 [%198, %$21] ; # B
; # (<> B Ign)
  %224 = icmp ne i8 %223, %3
  br i1 %224, label %$38, label %$37
$38:
  %225 = phi i64 [%219, %$33] ; # Scl
  %226 = phi i64 [%220, %$33] ; # Num
  %227 = phi i1 [%221, %$33] ; # Sign
  %228 = phi i1 [%222, %$33] ; # Frac
  %229 = phi i8 [%223, %$33] ; # B
; # (when (> (dec 'B (char "0")) 9) (ret 0))
; # (dec 'B (char "0"))
  %230 = sub i8 %229, 48
; # (> (dec 'B (char "0")) 9)
  %231 = icmp ugt i8 %230, 9
  br i1 %231, label %$39, label %$40
$39:
  %232 = phi i64 [%225, %$38] ; # Scl
  %233 = phi i64 [%226, %$38] ; # Num
  %234 = phi i1 [%227, %$38] ; # Sign
  %235 = phi i1 [%228, %$38] ; # Frac
  %236 = phi i8 [%230, %$38] ; # B
; # (ret 0)
; # (drop *Safe)
  %237 = inttoptr i64 %88 to i64*
  %238 = getelementptr i64, i64* %237, i32 1
  %239 = load i64, i64* %238
  %240 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %239, i64* %240
  ret i64 0
$40:
  %241 = phi i64 [%225, %$38] ; # Scl
  %242 = phi i64 [%226, %$38] ; # Num
  %243 = phi i1 [%227, %$38] ; # Sign
  %244 = phi i1 [%228, %$38] ; # Frac
  %245 = phi i8 [%230, %$38] ; # B
; # (set Num (addu (tenfold (val Num)) (cnt (i64 B))))
; # (val Num)
  %246 = inttoptr i64 %242 to i64*
  %247 = load i64, i64* %246
; # (tenfold (val Num))
  %248 = call i64 @tenfold(i64 %247)
; # (i64 B)
  %249 = zext i8 %245 to i64
; # (cnt (i64 B))
  %250 = shl i64 %249, 4
  %251 = or i64 %250, 2
; # (addu (tenfold (val Num)) (cnt (i64 B)))
  %252 = call i64 @addu(i64 %248, i64 %251)
  %253 = inttoptr i64 %242 to i64*
  store i64 %252, i64* %253
; # (when Frac (dec 'Scl))
  br i1 %244, label %$41, label %$42
$41:
  %254 = phi i64 [%241, %$40] ; # Scl
  %255 = phi i64 [%242, %$40] ; # Num
  %256 = phi i1 [%243, %$40] ; # Sign
  %257 = phi i1 [%244, %$40] ; # Frac
  %258 = phi i8 [%245, %$40] ; # B
; # (dec 'Scl)
  %259 = sub i64 %254, 1
  br label %$42
$42:
  %260 = phi i64 [%241, %$40], [%259, %$41] ; # Scl
  %261 = phi i64 [%242, %$40], [%255, %$41] ; # Num
  %262 = phi i1 [%243, %$40], [%256, %$41] ; # Sign
  %263 = phi i1 [%244, %$40], [%257, %$41] ; # Frac
  %264 = phi i8 [%245, %$40], [%258, %$41] ; # B
  br label %$32
$37:
  %265 = phi i64 [%219, %$33] ; # Scl
  %266 = phi i64 [%220, %$33] ; # Num
  %267 = phi i1 [%221, %$33] ; # Sign
  %268 = phi i1 [%222, %$33] ; # Frac
  %269 = phi i8 [%223, %$33] ; # B
  br label %$32
$32:
  %270 = phi i64 [%214, %$36], [%260, %$42], [%265, %$37] ; # Scl
  %271 = phi i64 [%215, %$36], [%261, %$42], [%266, %$37] ; # Num
  %272 = phi i1 [%216, %$36], [%262, %$42], [%267, %$37] ; # Sign
  %273 = phi i1 [1, %$36], [%263, %$42], [%268, %$37] ; # Frac
  %274 = phi i8 [%218, %$36], [%264, %$42], [%269, %$37] ; # B
  br label %$16
$18:
  %275 = phi i64 [%101, %$16], [%189, %$29] ; # Scl
  %276 = phi i64 [%102, %$16], [%190, %$29] ; # Num
  %277 = phi i1 [%103, %$16], [%191, %$29] ; # Sign
  %278 = phi i1 [%104, %$16], [%192, %$29] ; # Frac
  %279 = phi i8 [%106, %$16], [%193, %$29] ; # B
; # (when Frac (while (ge0 (dec 'Scl)) (set Num (tenfold (val Num))))...
  br i1 %278, label %$43, label %$44
$43:
  %280 = phi i64 [%275, %$18] ; # Scl
  %281 = phi i64 [%276, %$18] ; # Num
  %282 = phi i1 [%277, %$18] ; # Sign
  %283 = phi i1 [%278, %$18] ; # Frac
  %284 = phi i8 [%279, %$18] ; # B
; # (while (ge0 (dec 'Scl)) (set Num (tenfold (val Num))))
  br label %$45
$45:
  %285 = phi i64 [%280, %$43], [%292, %$46] ; # Scl
  %286 = phi i64 [%281, %$43], [%293, %$46] ; # Num
  %287 = phi i1 [%282, %$43], [%294, %$46] ; # Sign
  %288 = phi i1 [%283, %$43], [%295, %$46] ; # Frac
  %289 = phi i8 [%284, %$43], [%296, %$46] ; # B
; # (dec 'Scl)
  %290 = sub i64 %285, 1
; # (ge0 (dec 'Scl))
  %291 = icmp sge i64 %290, 0
  br i1 %291, label %$46, label %$47
$46:
  %292 = phi i64 [%290, %$45] ; # Scl
  %293 = phi i64 [%286, %$45] ; # Num
  %294 = phi i1 [%287, %$45] ; # Sign
  %295 = phi i1 [%288, %$45] ; # Frac
  %296 = phi i8 [%289, %$45] ; # B
; # (set Num (tenfold (val Num)))
; # (val Num)
  %297 = inttoptr i64 %293 to i64*
  %298 = load i64, i64* %297
; # (tenfold (val Num))
  %299 = call i64 @tenfold(i64 %298)
  %300 = inttoptr i64 %293 to i64*
  store i64 %299, i64* %300
  br label %$45
$47:
  %301 = phi i64 [%290, %$45] ; # Scl
  %302 = phi i64 [%286, %$45] ; # Num
  %303 = phi i1 [%287, %$45] ; # Sign
  %304 = phi i1 [%288, %$45] ; # Frac
  %305 = phi i8 [%289, %$45] ; # B
  br label %$44
$44:
  %306 = phi i64 [%275, %$18], [%301, %$47] ; # Scl
  %307 = phi i64 [%276, %$18], [%302, %$47] ; # Num
  %308 = phi i1 [%277, %$18], [%303, %$47] ; # Sign
  %309 = phi i1 [%278, %$18], [%304, %$47] ; # Frac
  %310 = phi i8 [%279, %$18], [%305, %$47] ; # B
; # (val Num)
  %311 = inttoptr i64 %307 to i64*
  %312 = load i64, i64* %311
; # (if Sign (neg Num) Num)
  br i1 %308, label %$48, label %$49
$48:
  %313 = phi i64 [%306, %$44] ; # Scl
  %314 = phi i64 [%312, %$44] ; # Num
  %315 = phi i1 [%308, %$44] ; # Sign
  %316 = phi i1 [%309, %$44] ; # Frac
  %317 = phi i8 [%310, %$44] ; # B
; # (neg Num)
  %318 = icmp eq i64 %314, 2
  br i1 %318, label %$51, label %$52
$51:
  br label %$53
$52:
  %319 = xor i64 %314, 8
  br label %$53
$53:
  %320 = phi i64 [%314, %$51], [%319, %$52] ; # ->
  br label %$50
$49:
  %321 = phi i64 [%306, %$44] ; # Scl
  %322 = phi i64 [%312, %$44] ; # Num
  %323 = phi i1 [%308, %$44] ; # Sign
  %324 = phi i1 [%309, %$44] ; # Frac
  %325 = phi i8 [%310, %$44] ; # B
  br label %$50
$50:
  %326 = phi i64 [%313, %$53], [%321, %$49] ; # Scl
  %327 = phi i64 [%314, %$53], [%322, %$49] ; # Num
  %328 = phi i1 [%315, %$53], [%323, %$49] ; # Sign
  %329 = phi i1 [%316, %$53], [%324, %$49] ; # Frac
  %330 = phi i8 [%317, %$53], [%325, %$49] ; # B
  %331 = phi i64 [%320, %$53], [%322, %$49] ; # ->
; # (drop *Safe)
  %332 = inttoptr i64 %88 to i64*
  %333 = getelementptr i64, i64* %332, i32 1
  %334 = load i64, i64* %333
  %335 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %334, i64* %335
  ret i64 %331
}

define i64 @fmtScl(i64, i64, i8, i8, i64*) align 8 {
$1:
; # (when (> N 9) (setq Scl (fmtScl (/ N 10) Scl Sep Ign P)) (cond ((...
; # (> N 9)
  %5 = icmp ugt i64 %0, 9
  br i1 %5, label %$2, label %$3
$2:
  %6 = phi i64 [%0, %$1] ; # N
  %7 = phi i64 [%1, %$1] ; # Scl
; # (/ N 10)
  %8 = udiv i64 %6, 10
; # (fmtScl (/ N 10) Scl Sep Ign P)
  %9 = call i64 @fmtScl(i64 %8, i64 %7, i8 %2, i8 %3, i64* %4)
; # (cond ((=0 Scl) (byteSym Sep P)) ((and Ign (gt0 Scl) (=0 (% Scl 3...
; # (=0 Scl)
  %10 = icmp eq i64 %9, 0
  br i1 %10, label %$6, label %$5
$6:
  %11 = phi i64 [%6, %$2] ; # N
  %12 = phi i64 [%9, %$2] ; # Scl
; # (byteSym Sep P)
  call void @byteSym(i8 %2, i64* %4)
  br label %$4
$5:
  %13 = phi i64 [%6, %$2] ; # N
  %14 = phi i64 [%9, %$2] ; # Scl
; # (and Ign (gt0 Scl) (=0 (% Scl 3)))
  %15 = icmp ne i8 %3, 0
  br i1 %15, label %$8, label %$7
$8:
  %16 = phi i64 [%13, %$5] ; # N
  %17 = phi i64 [%14, %$5] ; # Scl
; # (gt0 Scl)
  %18 = icmp sgt i64 %17, 0
  br i1 %18, label %$9, label %$7
$9:
  %19 = phi i64 [%16, %$8] ; # N
  %20 = phi i64 [%17, %$8] ; # Scl
; # (% Scl 3)
  %21 = urem i64 %20, 3
; # (=0 (% Scl 3))
  %22 = icmp eq i64 %21, 0
  br label %$7
$7:
  %23 = phi i64 [%13, %$5], [%16, %$8], [%19, %$9] ; # N
  %24 = phi i64 [%14, %$5], [%17, %$8], [%20, %$9] ; # Scl
  %25 = phi i1 [0, %$5], [0, %$8], [%22, %$9] ; # ->
  br i1 %25, label %$11, label %$10
$11:
  %26 = phi i64 [%23, %$7] ; # N
  %27 = phi i64 [%24, %$7] ; # Scl
; # (byteSym Ign P)
  call void @byteSym(i8 %3, i64* %4)
  br label %$4
$10:
  %28 = phi i64 [%23, %$7] ; # N
  %29 = phi i64 [%24, %$7] ; # Scl
  br label %$4
$4:
  %30 = phi i64 [%11, %$6], [%26, %$11], [%28, %$10] ; # N
  %31 = phi i64 [%12, %$6], [%27, %$11], [%29, %$10] ; # Scl
; # (dec 'Scl)
  %32 = sub i64 %31, 1
; # (% N 10)
  %33 = urem i64 %30, 10
  br label %$3
$3:
  %34 = phi i64 [%0, %$1], [%33, %$4] ; # N
  %35 = phi i64 [%1, %$1], [%32, %$4] ; # Scl
; # (i8 N)
  %36 = trunc i64 %34 to i8
; # (+ (i8 N) (char "0"))
  %37 = add i8 %36, 48
; # (byteSym (+ (i8 N) (char "0")) P)
  call void @byteSym(i8 %37, i64* %4)
  ret i64 %35
}

define i64 @outScl(i64, i64, i8) align 8 {
$1:
; # (when (> N 9) (setq Scl (outScl (/ N 10) Scl Sep)) (when (=0 Scl)...
; # (> N 9)
  %3 = icmp ugt i64 %0, 9
  br i1 %3, label %$2, label %$3
$2:
  %4 = phi i64 [%0, %$1] ; # N
  %5 = phi i64 [%1, %$1] ; # Scl
; # (/ N 10)
  %6 = udiv i64 %4, 10
; # (outScl (/ N 10) Scl Sep)
  %7 = call i64 @outScl(i64 %6, i64 %5, i8 %2)
; # (when (=0 Scl) (call $Put Sep))
; # (=0 Scl)
  %8 = icmp eq i64 %7, 0
  br i1 %8, label %$4, label %$5
$4:
  %9 = phi i64 [%4, %$2] ; # N
  %10 = phi i64 [%7, %$2] ; # Scl
; # (call $Put Sep)
  %11 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %11(i8 %2)
  br label %$5
$5:
  %12 = phi i64 [%4, %$2], [%9, %$4] ; # N
  %13 = phi i64 [%7, %$2], [%10, %$4] ; # Scl
; # (dec 'Scl)
  %14 = sub i64 %13, 1
; # (% N 10)
  %15 = urem i64 %12, 10
  br label %$3
$3:
  %16 = phi i64 [%0, %$1], [%15, %$5] ; # N
  %17 = phi i64 [%1, %$1], [%14, %$5] ; # Scl
; # (i8 N)
  %18 = trunc i64 %16 to i8
; # (+ (i8 N) (char "0"))
  %19 = add i8 %18, 48
; # (call $Put (+ (i8 N) (char "0")))
  %20 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %20(i8 %19)
  ret i64 %17
}

define i64 @fmtNum(i64, i64, i8, i8, i64*) align 8 {
$1:
; # (let (Sign (sign? Num) Len (+ 19 17)) (let N (setq Num (& Num -9)...
; # (sign? Num)
  %5 = and i64 %0, 8
  %6 = icmp ne i64 %5, 0
; # (+ 19 17)
; # (let N (setq Num (& Num -9)) (until (cnt? N) (inc 'Len 20) (setq ...
; # (& Num -9)
  %7 = and i64 %0, -9
; # (until (cnt? N) (inc 'Len 20) (setq N (val (big N))))
  br label %$2
$2:
  %8 = phi i64 [%7, %$1], [%14, %$3] ; # Num
  %9 = phi i64 [%1, %$1], [%15, %$3] ; # Scl
  %10 = phi i64 [36, %$1], [%18, %$3] ; # Len
  %11 = phi i64 [%7, %$1], [%21, %$3] ; # N
; # (cnt? N)
  %12 = and i64 %11, 2
  %13 = icmp ne i64 %12, 0
  br i1 %13, label %$4, label %$3
$3:
  %14 = phi i64 [%8, %$2] ; # Num
  %15 = phi i64 [%9, %$2] ; # Scl
  %16 = phi i64 [%10, %$2] ; # Len
  %17 = phi i64 [%11, %$2] ; # N
; # (inc 'Len 20)
  %18 = add i64 %16, 20
; # (big N)
  %19 = add i64 %17, 4
; # (val (big N))
  %20 = inttoptr i64 %19 to i64*
  %21 = load i64, i64* %20
  br label %$2
$4:
  %22 = phi i64 [%8, %$2] ; # Num
  %23 = phi i64 [%9, %$2] ; # Scl
  %24 = phi i64 [%10, %$2] ; # Len
  %25 = phi i64 [%11, %$2] ; # N
; # (/ Len 18)
  %26 = udiv i64 %24, 18
; # (let (Acc (b64 Len) TopA Acc) (let (Inc (b64 Len) TopI Inc) (set ...
; # (b64 Len)
  %27 = alloca i64, i64 %26
; # (let (Inc (b64 Len) TopI Inc) (set Acc 0 Inc 1) (loop (let (Dig N...
; # (b64 Len)
  %28 = alloca i64, i64 %26
; # (set Acc 0 Inc 1)
  store i64 0, i64* %27
  store i64 1, i64* %28
; # (loop (let (Dig Num Mask 16) (when (big? Num) (setq Dig (val (dig...
  br label %$5
$5:
  %29 = phi i64 [%22, %$4], [%306, %$31] ; # Num
  %30 = phi i64 [%23, %$4], [%300, %$31] ; # Scl
  %31 = phi i64 [%26, %$4], [%301, %$31] ; # Len
  %32 = phi i64* [%27, %$4], [%302, %$31] ; # TopA
  %33 = phi i64* [%28, %$4], [%303, %$31] ; # TopI
; # (let (Dig Num Mask 16) (when (big? Num) (setq Dig (val (dig Num))...
; # (when (big? Num) (setq Dig (val (dig Num)) Mask 1))
; # (big? Num)
  %34 = and i64 %29, 4
  %35 = icmp ne i64 %34, 0
  br i1 %35, label %$6, label %$7
$6:
  %36 = phi i64 [%29, %$5] ; # Num
  %37 = phi i64 [%30, %$5] ; # Scl
  %38 = phi i64 [%31, %$5] ; # Len
  %39 = phi i64* [%32, %$5] ; # TopA
  %40 = phi i64* [%33, %$5] ; # TopI
  %41 = phi i64 [%29, %$5] ; # Dig
  %42 = phi i64 [16, %$5] ; # Mask
; # (dig Num)
  %43 = add i64 %36, -4
; # (val (dig Num))
  %44 = inttoptr i64 %43 to i64*
  %45 = load i64, i64* %44
  br label %$7
$7:
  %46 = phi i64 [%29, %$5], [%36, %$6] ; # Num
  %47 = phi i64 [%30, %$5], [%37, %$6] ; # Scl
  %48 = phi i64 [%31, %$5], [%38, %$6] ; # Len
  %49 = phi i64* [%32, %$5], [%39, %$6] ; # TopA
  %50 = phi i64* [%33, %$5], [%40, %$6] ; # TopI
  %51 = phi i64 [%29, %$5], [%45, %$6] ; # Dig
  %52 = phi i64 [16, %$5], [1, %$6] ; # Mask
; # (loop (when (& Dig Mask) (let (A Acc I Inc C 0) (loop (let N (+ (...
  br label %$8
$8:
  %53 = phi i64 [%46, %$7], [%282, %$29] ; # Num
  %54 = phi i64 [%47, %$7], [%283, %$29] ; # Scl
  %55 = phi i64 [%48, %$7], [%284, %$29] ; # Len
  %56 = phi i64* [%49, %$7], [%285, %$29] ; # TopA
  %57 = phi i64* [%50, %$7], [%286, %$29] ; # TopI
  %58 = phi i64 [%51, %$7], [%287, %$29] ; # Dig
  %59 = phi i64 [%52, %$7], [%288, %$29] ; # Mask
; # (when (& Dig Mask) (let (A Acc I Inc C 0) (loop (let N (+ (val A)...
; # (& Dig Mask)
  %60 = and i64 %58, %59
  %61 = icmp ne i64 %60, 0
  br i1 %61, label %$9, label %$10
$9:
  %62 = phi i64 [%53, %$8] ; # Num
  %63 = phi i64 [%54, %$8] ; # Scl
  %64 = phi i64 [%55, %$8] ; # Len
  %65 = phi i64* [%56, %$8] ; # TopA
  %66 = phi i64* [%57, %$8] ; # TopI
  %67 = phi i64 [%58, %$8] ; # Dig
  %68 = phi i64 [%59, %$8] ; # Mask
; # (let (A Acc I Inc C 0) (loop (let N (+ (val A) (val I) C) (setq C...
; # (loop (let N (+ (val A) (val I) C) (setq C (if (> 100000000000000...
  br label %$11
$11:
  %69 = phi i64 [%62, %$9], [%144, %$18] ; # Num
  %70 = phi i64 [%63, %$9], [%145, %$18] ; # Scl
  %71 = phi i64 [%64, %$9], [%146, %$18] ; # Len
  %72 = phi i64* [%65, %$9], [%147, %$18] ; # TopA
  %73 = phi i64* [%66, %$9], [%148, %$18] ; # TopI
  %74 = phi i64 [%67, %$9], [%149, %$18] ; # Dig
  %75 = phi i64 [%68, %$9], [%150, %$18] ; # Mask
  %76 = phi i64* [%27, %$9], [%151, %$18] ; # A
  %77 = phi i64* [%28, %$9], [%152, %$18] ; # I
  %78 = phi i64 [0, %$9], [%153, %$18] ; # C
; # (let N (+ (val A) (val I) C) (setq C (if (> 1000000000000000000 N...
; # (val A)
  %79 = load i64, i64* %76
; # (val I)
  %80 = load i64, i64* %77
; # (+ (val A) (val I) C)
  %81 = add i64 %79, %80
  %82 = add i64 %81, %78
; # (if (> 1000000000000000000 N) 0 (dec 'N 1000000000000000000) 1)
; # (> 1000000000000000000 N)
  %83 = icmp ugt i64 1000000000000000000, %82
  br i1 %83, label %$12, label %$13
$12:
  %84 = phi i64 [%69, %$11] ; # Num
  %85 = phi i64 [%70, %$11] ; # Scl
  %86 = phi i64 [%71, %$11] ; # Len
  %87 = phi i64* [%72, %$11] ; # TopA
  %88 = phi i64* [%73, %$11] ; # TopI
  %89 = phi i64 [%74, %$11] ; # Dig
  %90 = phi i64 [%75, %$11] ; # Mask
  %91 = phi i64* [%76, %$11] ; # A
  %92 = phi i64* [%77, %$11] ; # I
  %93 = phi i64 [%78, %$11] ; # C
  %94 = phi i64 [%82, %$11] ; # N
  br label %$14
$13:
  %95 = phi i64 [%69, %$11] ; # Num
  %96 = phi i64 [%70, %$11] ; # Scl
  %97 = phi i64 [%71, %$11] ; # Len
  %98 = phi i64* [%72, %$11] ; # TopA
  %99 = phi i64* [%73, %$11] ; # TopI
  %100 = phi i64 [%74, %$11] ; # Dig
  %101 = phi i64 [%75, %$11] ; # Mask
  %102 = phi i64* [%76, %$11] ; # A
  %103 = phi i64* [%77, %$11] ; # I
  %104 = phi i64 [%78, %$11] ; # C
  %105 = phi i64 [%82, %$11] ; # N
; # (dec 'N 1000000000000000000)
  %106 = sub i64 %105, 1000000000000000000
  br label %$14
$14:
  %107 = phi i64 [%84, %$12], [%95, %$13] ; # Num
  %108 = phi i64 [%85, %$12], [%96, %$13] ; # Scl
  %109 = phi i64 [%86, %$12], [%97, %$13] ; # Len
  %110 = phi i64* [%87, %$12], [%98, %$13] ; # TopA
  %111 = phi i64* [%88, %$12], [%99, %$13] ; # TopI
  %112 = phi i64 [%89, %$12], [%100, %$13] ; # Dig
  %113 = phi i64 [%90, %$12], [%101, %$13] ; # Mask
  %114 = phi i64* [%91, %$12], [%102, %$13] ; # A
  %115 = phi i64* [%92, %$12], [%103, %$13] ; # I
  %116 = phi i64 [%93, %$12], [%104, %$13] ; # C
  %117 = phi i64 [%94, %$12], [%106, %$13] ; # N
  %118 = phi i64 [0, %$12], [1, %$13] ; # ->
; # (set A N)
  store i64 %117, i64* %114
; # (? (> (inc 'I) TopI))
; # (inc 'I)
  %119 = getelementptr i64, i64* %115, i32 1
; # (> (inc 'I) TopI)
  %120 = icmp ugt i64* %119, %111
  br i1 %120, label %$16, label %$15
$15:
  %121 = phi i64 [%107, %$14] ; # Num
  %122 = phi i64 [%108, %$14] ; # Scl
  %123 = phi i64 [%109, %$14] ; # Len
  %124 = phi i64* [%110, %$14] ; # TopA
  %125 = phi i64* [%111, %$14] ; # TopI
  %126 = phi i64 [%112, %$14] ; # Dig
  %127 = phi i64 [%113, %$14] ; # Mask
  %128 = phi i64* [%114, %$14] ; # A
  %129 = phi i64* [%119, %$14] ; # I
  %130 = phi i64 [%118, %$14] ; # C
; # (when (> (inc 'A) TopA) (inc 'TopA) (set A 0))
; # (inc 'A)
  %131 = getelementptr i64, i64* %128, i32 1
; # (> (inc 'A) TopA)
  %132 = icmp ugt i64* %131, %124
  br i1 %132, label %$17, label %$18
$17:
  %133 = phi i64 [%121, %$15] ; # Num
  %134 = phi i64 [%122, %$15] ; # Scl
  %135 = phi i64 [%123, %$15] ; # Len
  %136 = phi i64* [%124, %$15] ; # TopA
  %137 = phi i64* [%125, %$15] ; # TopI
  %138 = phi i64 [%126, %$15] ; # Dig
  %139 = phi i64 [%127, %$15] ; # Mask
  %140 = phi i64* [%131, %$15] ; # A
  %141 = phi i64* [%129, %$15] ; # I
  %142 = phi i64 [%130, %$15] ; # C
; # (inc 'TopA)
  %143 = getelementptr i64, i64* %136, i32 1
; # (set A 0)
  store i64 0, i64* %140
  br label %$18
$18:
  %144 = phi i64 [%121, %$15], [%133, %$17] ; # Num
  %145 = phi i64 [%122, %$15], [%134, %$17] ; # Scl
  %146 = phi i64 [%123, %$15], [%135, %$17] ; # Len
  %147 = phi i64* [%124, %$15], [%143, %$17] ; # TopA
  %148 = phi i64* [%125, %$15], [%137, %$17] ; # TopI
  %149 = phi i64 [%126, %$15], [%138, %$17] ; # Dig
  %150 = phi i64 [%127, %$15], [%139, %$17] ; # Mask
  %151 = phi i64* [%131, %$15], [%140, %$17] ; # A
  %152 = phi i64* [%129, %$15], [%141, %$17] ; # I
  %153 = phi i64 [%130, %$15], [%142, %$17] ; # C
  br label %$11
$16:
  %154 = phi i64 [%107, %$14] ; # Num
  %155 = phi i64 [%108, %$14] ; # Scl
  %156 = phi i64 [%109, %$14] ; # Len
  %157 = phi i64* [%110, %$14] ; # TopA
  %158 = phi i64* [%111, %$14] ; # TopI
  %159 = phi i64 [%112, %$14] ; # Dig
  %160 = phi i64 [%113, %$14] ; # Mask
  %161 = phi i64* [%114, %$14] ; # A
  %162 = phi i64* [%119, %$14] ; # I
  %163 = phi i64 [%118, %$14] ; # C
  %164 = phi i64 [0, %$14] ; # ->
; # (when C (set (inc 'TopA) 1))
  %165 = icmp ne i64 %163, 0
  br i1 %165, label %$19, label %$20
$19:
  %166 = phi i64 [%154, %$16] ; # Num
  %167 = phi i64 [%155, %$16] ; # Scl
  %168 = phi i64 [%156, %$16] ; # Len
  %169 = phi i64* [%157, %$16] ; # TopA
  %170 = phi i64* [%158, %$16] ; # TopI
  %171 = phi i64 [%159, %$16] ; # Dig
  %172 = phi i64 [%160, %$16] ; # Mask
  %173 = phi i64* [%161, %$16] ; # A
  %174 = phi i64* [%162, %$16] ; # I
  %175 = phi i64 [%163, %$16] ; # C
; # (set (inc 'TopA) 1)
; # (inc 'TopA)
  %176 = getelementptr i64, i64* %169, i32 1
  store i64 1, i64* %176
  br label %$20
$20:
  %177 = phi i64 [%154, %$16], [%166, %$19] ; # Num
  %178 = phi i64 [%155, %$16], [%167, %$19] ; # Scl
  %179 = phi i64 [%156, %$16], [%168, %$19] ; # Len
  %180 = phi i64* [%157, %$16], [%176, %$19] ; # TopA
  %181 = phi i64* [%158, %$16], [%170, %$19] ; # TopI
  %182 = phi i64 [%159, %$16], [%171, %$19] ; # Dig
  %183 = phi i64 [%160, %$16], [%172, %$19] ; # Mask
  %184 = phi i64* [%161, %$16], [%173, %$19] ; # A
  %185 = phi i64* [%162, %$16], [%174, %$19] ; # I
  %186 = phi i64 [%163, %$16], [%175, %$19] ; # C
  br label %$10
$10:
  %187 = phi i64 [%53, %$8], [%177, %$20] ; # Num
  %188 = phi i64 [%54, %$8], [%178, %$20] ; # Scl
  %189 = phi i64 [%55, %$8], [%179, %$20] ; # Len
  %190 = phi i64* [%56, %$8], [%180, %$20] ; # TopA
  %191 = phi i64* [%57, %$8], [%181, %$20] ; # TopI
  %192 = phi i64 [%58, %$8], [%182, %$20] ; # Dig
  %193 = phi i64 [%59, %$8], [%183, %$20] ; # Mask
; # (let (I Inc C 0) (loop (let N (val I) (setq C (if (> 100000000000...
; # (loop (let N (val I) (setq C (if (> 1000000000000000000 (setq N (...
  br label %$21
$21:
  %194 = phi i64 [%187, %$10], [%241, %$25] ; # Num
  %195 = phi i64 [%188, %$10], [%242, %$25] ; # Scl
  %196 = phi i64 [%189, %$10], [%243, %$25] ; # Len
  %197 = phi i64* [%190, %$10], [%244, %$25] ; # TopA
  %198 = phi i64* [%191, %$10], [%245, %$25] ; # TopI
  %199 = phi i64 [%192, %$10], [%246, %$25] ; # Dig
  %200 = phi i64 [%193, %$10], [%247, %$25] ; # Mask
  %201 = phi i64* [%28, %$10], [%248, %$25] ; # I
  %202 = phi i64 [0, %$10], [%249, %$25] ; # C
; # (let N (val I) (setq C (if (> 1000000000000000000 (setq N (+ N N ...
; # (val I)
  %203 = load i64, i64* %201
; # (if (> 1000000000000000000 (setq N (+ N N C))) 0 (dec 'N 10000000...
; # (+ N N C)
  %204 = add i64 %203, %203
  %205 = add i64 %204, %202
; # (> 1000000000000000000 (setq N (+ N N C)))
  %206 = icmp ugt i64 1000000000000000000, %205
  br i1 %206, label %$22, label %$23
$22:
  %207 = phi i64 [%194, %$21] ; # Num
  %208 = phi i64 [%195, %$21] ; # Scl
  %209 = phi i64 [%196, %$21] ; # Len
  %210 = phi i64* [%197, %$21] ; # TopA
  %211 = phi i64* [%198, %$21] ; # TopI
  %212 = phi i64 [%199, %$21] ; # Dig
  %213 = phi i64 [%200, %$21] ; # Mask
  %214 = phi i64* [%201, %$21] ; # I
  %215 = phi i64 [%202, %$21] ; # C
  %216 = phi i64 [%205, %$21] ; # N
  br label %$24
$23:
  %217 = phi i64 [%194, %$21] ; # Num
  %218 = phi i64 [%195, %$21] ; # Scl
  %219 = phi i64 [%196, %$21] ; # Len
  %220 = phi i64* [%197, %$21] ; # TopA
  %221 = phi i64* [%198, %$21] ; # TopI
  %222 = phi i64 [%199, %$21] ; # Dig
  %223 = phi i64 [%200, %$21] ; # Mask
  %224 = phi i64* [%201, %$21] ; # I
  %225 = phi i64 [%202, %$21] ; # C
  %226 = phi i64 [%205, %$21] ; # N
; # (dec 'N 1000000000000000000)
  %227 = sub i64 %226, 1000000000000000000
  br label %$24
$24:
  %228 = phi i64 [%207, %$22], [%217, %$23] ; # Num
  %229 = phi i64 [%208, %$22], [%218, %$23] ; # Scl
  %230 = phi i64 [%209, %$22], [%219, %$23] ; # Len
  %231 = phi i64* [%210, %$22], [%220, %$23] ; # TopA
  %232 = phi i64* [%211, %$22], [%221, %$23] ; # TopI
  %233 = phi i64 [%212, %$22], [%222, %$23] ; # Dig
  %234 = phi i64 [%213, %$22], [%223, %$23] ; # Mask
  %235 = phi i64* [%214, %$22], [%224, %$23] ; # I
  %236 = phi i64 [%215, %$22], [%225, %$23] ; # C
  %237 = phi i64 [%216, %$22], [%227, %$23] ; # N
  %238 = phi i64 [0, %$22], [1, %$23] ; # ->
; # (set I N)
  store i64 %237, i64* %235
; # (? (> (inc 'I) TopI))
; # (inc 'I)
  %239 = getelementptr i64, i64* %235, i32 1
; # (> (inc 'I) TopI)
  %240 = icmp ugt i64* %239, %232
  br i1 %240, label %$26, label %$25
$25:
  %241 = phi i64 [%228, %$24] ; # Num
  %242 = phi i64 [%229, %$24] ; # Scl
  %243 = phi i64 [%230, %$24] ; # Len
  %244 = phi i64* [%231, %$24] ; # TopA
  %245 = phi i64* [%232, %$24] ; # TopI
  %246 = phi i64 [%233, %$24] ; # Dig
  %247 = phi i64 [%234, %$24] ; # Mask
  %248 = phi i64* [%239, %$24] ; # I
  %249 = phi i64 [%238, %$24] ; # C
  br label %$21
$26:
  %250 = phi i64 [%228, %$24] ; # Num
  %251 = phi i64 [%229, %$24] ; # Scl
  %252 = phi i64 [%230, %$24] ; # Len
  %253 = phi i64* [%231, %$24] ; # TopA
  %254 = phi i64* [%232, %$24] ; # TopI
  %255 = phi i64 [%233, %$24] ; # Dig
  %256 = phi i64 [%234, %$24] ; # Mask
  %257 = phi i64* [%239, %$24] ; # I
  %258 = phi i64 [%238, %$24] ; # C
  %259 = phi i64 [0, %$24] ; # ->
; # (when C (inc 'TopI) (set I 1))
  %260 = icmp ne i64 %258, 0
  br i1 %260, label %$27, label %$28
$27:
  %261 = phi i64 [%250, %$26] ; # Num
  %262 = phi i64 [%251, %$26] ; # Scl
  %263 = phi i64 [%252, %$26] ; # Len
  %264 = phi i64* [%253, %$26] ; # TopA
  %265 = phi i64* [%254, %$26] ; # TopI
  %266 = phi i64 [%255, %$26] ; # Dig
  %267 = phi i64 [%256, %$26] ; # Mask
  %268 = phi i64* [%257, %$26] ; # I
  %269 = phi i64 [%258, %$26] ; # C
; # (inc 'TopI)
  %270 = getelementptr i64, i64* %265, i32 1
; # (set I 1)
  store i64 1, i64* %268
  br label %$28
$28:
  %271 = phi i64 [%250, %$26], [%261, %$27] ; # Num
  %272 = phi i64 [%251, %$26], [%262, %$27] ; # Scl
  %273 = phi i64 [%252, %$26], [%263, %$27] ; # Len
  %274 = phi i64* [%253, %$26], [%264, %$27] ; # TopA
  %275 = phi i64* [%254, %$26], [%270, %$27] ; # TopI
  %276 = phi i64 [%255, %$26], [%266, %$27] ; # Dig
  %277 = phi i64 [%256, %$26], [%267, %$27] ; # Mask
  %278 = phi i64* [%257, %$26], [%268, %$27] ; # I
  %279 = phi i64 [%258, %$26], [%269, %$27] ; # C
; # (? (=0 (setq Mask (shl Mask 1))))
; # (shl Mask 1)
  %280 = shl i64 %277, 1
; # (=0 (setq Mask (shl Mask 1)))
  %281 = icmp eq i64 %280, 0
  br i1 %281, label %$30, label %$29
$29:
  %282 = phi i64 [%271, %$28] ; # Num
  %283 = phi i64 [%272, %$28] ; # Scl
  %284 = phi i64 [%273, %$28] ; # Len
  %285 = phi i64* [%274, %$28] ; # TopA
  %286 = phi i64* [%275, %$28] ; # TopI
  %287 = phi i64 [%276, %$28] ; # Dig
  %288 = phi i64 [%280, %$28] ; # Mask
  br label %$8
$30:
  %289 = phi i64 [%271, %$28] ; # Num
  %290 = phi i64 [%272, %$28] ; # Scl
  %291 = phi i64 [%273, %$28] ; # Len
  %292 = phi i64* [%274, %$28] ; # TopA
  %293 = phi i64* [%275, %$28] ; # TopI
  %294 = phi i64 [%276, %$28] ; # Dig
  %295 = phi i64 [%280, %$28] ; # Mask
  %296 = phi i64 [0, %$28] ; # ->
; # (? (cnt? Num))
; # (cnt? Num)
  %297 = and i64 %289, 2
  %298 = icmp ne i64 %297, 0
  br i1 %298, label %$32, label %$31
$31:
  %299 = phi i64 [%289, %$30] ; # Num
  %300 = phi i64 [%290, %$30] ; # Scl
  %301 = phi i64 [%291, %$30] ; # Len
  %302 = phi i64* [%292, %$30] ; # TopA
  %303 = phi i64* [%293, %$30] ; # TopI
; # (big Num)
  %304 = add i64 %299, 4
; # (val (big Num))
  %305 = inttoptr i64 %304 to i64*
  %306 = load i64, i64* %305
  br label %$5
$32:
  %307 = phi i64 [%289, %$30] ; # Num
  %308 = phi i64 [%290, %$30] ; # Scl
  %309 = phi i64 [%291, %$30] ; # Len
  %310 = phi i64* [%292, %$30] ; # TopA
  %311 = phi i64* [%293, %$30] ; # TopI
  %312 = phi i64 [0, %$30] ; # ->
; # (let (N (* (shr (- TopA Acc) 3) 18) D (val TopA)) (cond (P (when ...
; # (- TopA Acc)
  %313 = ptrtoint i64* %310 to i64
  %314 = ptrtoint i64* %27 to i64
  %315 = sub i64 %313, %314
; # (shr (- TopA Acc) 3)
  %316 = lshr i64 %315, 3
; # (* (shr (- TopA Acc) 3) 18)
  %317 = mul i64 %316, 18
; # (val TopA)
  %318 = load i64, i64* %310
; # (cond (P (when Sign (byteSym (char "-") P)) (while (setq D (/ D 1...
  %319 = icmp ne i64* %4, null
  br i1 %319, label %$35, label %$34
$35:
  %320 = phi i64 [%307, %$32] ; # Num
  %321 = phi i64 [%308, %$32] ; # Scl
  %322 = phi i64 [%309, %$32] ; # Len
  %323 = phi i64* [%310, %$32] ; # TopA
  %324 = phi i64 [%317, %$32] ; # N
  %325 = phi i64 [%318, %$32] ; # D
; # (when Sign (byteSym (char "-") P))
  br i1 %6, label %$36, label %$37
$36:
  %326 = phi i64 [%320, %$35] ; # Num
  %327 = phi i64 [%321, %$35] ; # Scl
  %328 = phi i64 [%322, %$35] ; # Len
  %329 = phi i64* [%323, %$35] ; # TopA
  %330 = phi i64 [%324, %$35] ; # N
  %331 = phi i64 [%325, %$35] ; # D
; # (byteSym (char "-") P)
  call void @byteSym(i8 45, i64* %4)
  br label %$37
$37:
  %332 = phi i64 [%320, %$35], [%326, %$36] ; # Num
  %333 = phi i64 [%321, %$35], [%327, %$36] ; # Scl
  %334 = phi i64 [%322, %$35], [%328, %$36] ; # Len
  %335 = phi i64* [%323, %$35], [%329, %$36] ; # TopA
  %336 = phi i64 [%324, %$35], [%330, %$36] ; # N
  %337 = phi i64 [%325, %$35], [%331, %$36] ; # D
; # (while (setq D (/ D 10)) (inc 'N))
  br label %$38
$38:
  %338 = phi i64 [%332, %$37], [%346, %$39] ; # Num
  %339 = phi i64 [%333, %$37], [%347, %$39] ; # Scl
  %340 = phi i64 [%334, %$37], [%348, %$39] ; # Len
  %341 = phi i64* [%335, %$37], [%349, %$39] ; # TopA
  %342 = phi i64 [%336, %$37], [%352, %$39] ; # N
  %343 = phi i64 [%337, %$37], [%351, %$39] ; # D
; # (/ D 10)
  %344 = udiv i64 %343, 10
  %345 = icmp ne i64 %344, 0
  br i1 %345, label %$39, label %$40
$39:
  %346 = phi i64 [%338, %$38] ; # Num
  %347 = phi i64 [%339, %$38] ; # Scl
  %348 = phi i64 [%340, %$38] ; # Len
  %349 = phi i64* [%341, %$38] ; # TopA
  %350 = phi i64 [%342, %$38] ; # N
  %351 = phi i64 [%344, %$38] ; # D
; # (inc 'N)
  %352 = add i64 %350, 1
  br label %$38
$40:
  %353 = phi i64 [%338, %$38] ; # Num
  %354 = phi i64 [%339, %$38] ; # Scl
  %355 = phi i64 [%340, %$38] ; # Len
  %356 = phi i64* [%341, %$38] ; # TopA
  %357 = phi i64 [%342, %$38] ; # N
  %358 = phi i64 [%344, %$38] ; # D
; # (when (lt0 (setq Scl (- N Scl))) (byteSym (char "0") P) (byteSym ...
; # (- N Scl)
  %359 = sub i64 %357, %354
; # (lt0 (setq Scl (- N Scl)))
  %360 = icmp slt i64 %359, 0
  br i1 %360, label %$41, label %$42
$41:
  %361 = phi i64 [%353, %$40] ; # Num
  %362 = phi i64 [%359, %$40] ; # Scl
  %363 = phi i64 [%355, %$40] ; # Len
  %364 = phi i64* [%356, %$40] ; # TopA
  %365 = phi i64 [%357, %$40] ; # N
  %366 = phi i64 [%358, %$40] ; # D
; # (byteSym (char "0") P)
  call void @byteSym(i8 48, i64* %4)
; # (byteSym Sep P)
  call void @byteSym(i8 %2, i64* %4)
; # (while (> -1 Scl) (inc 'Scl) (byteSym (char "0") P))
  br label %$43
$43:
  %367 = phi i64 [%361, %$41], [%374, %$44] ; # Num
  %368 = phi i64 [%362, %$41], [%380, %$44] ; # Scl
  %369 = phi i64 [%363, %$41], [%376, %$44] ; # Len
  %370 = phi i64* [%364, %$41], [%377, %$44] ; # TopA
  %371 = phi i64 [%365, %$41], [%378, %$44] ; # N
  %372 = phi i64 [%366, %$41], [%379, %$44] ; # D
; # (> -1 Scl)
  %373 = icmp ugt i64 -1, %368
  br i1 %373, label %$44, label %$45
$44:
  %374 = phi i64 [%367, %$43] ; # Num
  %375 = phi i64 [%368, %$43] ; # Scl
  %376 = phi i64 [%369, %$43] ; # Len
  %377 = phi i64* [%370, %$43] ; # TopA
  %378 = phi i64 [%371, %$43] ; # N
  %379 = phi i64 [%372, %$43] ; # D
; # (inc 'Scl)
  %380 = add i64 %375, 1
; # (byteSym (char "0") P)
  call void @byteSym(i8 48, i64* %4)
  br label %$43
$45:
  %381 = phi i64 [%367, %$43] ; # Num
  %382 = phi i64 [%368, %$43] ; # Scl
  %383 = phi i64 [%369, %$43] ; # Len
  %384 = phi i64* [%370, %$43] ; # TopA
  %385 = phi i64 [%371, %$43] ; # N
  %386 = phi i64 [%372, %$43] ; # D
  br label %$42
$42:
  %387 = phi i64 [%353, %$40], [%381, %$45] ; # Num
  %388 = phi i64 [%359, %$40], [%382, %$45] ; # Scl
  %389 = phi i64 [%355, %$40], [%383, %$45] ; # Len
  %390 = phi i64* [%356, %$40], [%384, %$45] ; # TopA
  %391 = phi i64 [%357, %$40], [%385, %$45] ; # N
  %392 = phi i64 [%358, %$40], [%386, %$45] ; # D
; # (val TopA)
  %393 = load i64, i64* %390
; # (fmtScl (val TopA) Scl Sep Ign P)
  %394 = call i64 @fmtScl(i64 %393, i64 %388, i8 %2, i8 %3, i64* %4)
; # (while (>= (dec 'TopA) Acc) (let (N (val TopA) D 1000000000000000...
  br label %$46
$46:
  %395 = phi i64 [%387, %$42], [%483, %$59] ; # Num
  %396 = phi i64 [%394, %$42], [%484, %$59] ; # Scl
  %397 = phi i64 [%389, %$42], [%485, %$59] ; # Len
  %398 = phi i64* [%390, %$42], [%486, %$59] ; # TopA
  %399 = phi i64 [%391, %$42], [%407, %$59] ; # N
  %400 = phi i64 [%392, %$42], [%408, %$59] ; # D
; # (dec 'TopA)
  %401 = getelementptr i64, i64* %398, i32 -1
; # (>= (dec 'TopA) Acc)
  %402 = icmp uge i64* %401, %27
  br i1 %402, label %$47, label %$48
$47:
  %403 = phi i64 [%395, %$46] ; # Num
  %404 = phi i64 [%396, %$46] ; # Scl
  %405 = phi i64 [%397, %$46] ; # Len
  %406 = phi i64* [%401, %$46] ; # TopA
  %407 = phi i64 [%399, %$46] ; # N
  %408 = phi i64 [%400, %$46] ; # D
; # (let (N (val TopA) D 100000000000000000) (loop (cond ((=0 Scl) (b...
; # (val TopA)
  %409 = load i64, i64* %406
; # (loop (cond ((=0 Scl) (byteSym Sep P)) ((and Ign (gt0 Scl) (=0 (%...
  br label %$49
$49:
  %410 = phi i64 [%403, %$47], [%477, %$58] ; # Num
  %411 = phi i64 [%404, %$47], [%478, %$58] ; # Scl
  %412 = phi i64 [%405, %$47], [%479, %$58] ; # Len
  %413 = phi i64* [%406, %$47], [%480, %$58] ; # TopA
  %414 = phi i64 [%409, %$47], [%481, %$58] ; # N
  %415 = phi i64 [100000000000000000, %$47], [%482, %$58] ; # D
; # (cond ((=0 Scl) (byteSym Sep P)) ((and Ign (gt0 Scl) (=0 (% Scl 3...
; # (=0 Scl)
  %416 = icmp eq i64 %411, 0
  br i1 %416, label %$52, label %$51
$52:
  %417 = phi i64 [%410, %$49] ; # Num
  %418 = phi i64 [%411, %$49] ; # Scl
  %419 = phi i64 [%412, %$49] ; # Len
  %420 = phi i64* [%413, %$49] ; # TopA
  %421 = phi i64 [%414, %$49] ; # N
  %422 = phi i64 [%415, %$49] ; # D
; # (byteSym Sep P)
  call void @byteSym(i8 %2, i64* %4)
  br label %$50
$51:
  %423 = phi i64 [%410, %$49] ; # Num
  %424 = phi i64 [%411, %$49] ; # Scl
  %425 = phi i64 [%412, %$49] ; # Len
  %426 = phi i64* [%413, %$49] ; # TopA
  %427 = phi i64 [%414, %$49] ; # N
  %428 = phi i64 [%415, %$49] ; # D
; # (and Ign (gt0 Scl) (=0 (% Scl 3)))
  %429 = icmp ne i8 %3, 0
  br i1 %429, label %$54, label %$53
$54:
  %430 = phi i64 [%423, %$51] ; # Num
  %431 = phi i64 [%424, %$51] ; # Scl
  %432 = phi i64 [%425, %$51] ; # Len
  %433 = phi i64* [%426, %$51] ; # TopA
  %434 = phi i64 [%427, %$51] ; # N
  %435 = phi i64 [%428, %$51] ; # D
; # (gt0 Scl)
  %436 = icmp sgt i64 %431, 0
  br i1 %436, label %$55, label %$53
$55:
  %437 = phi i64 [%430, %$54] ; # Num
  %438 = phi i64 [%431, %$54] ; # Scl
  %439 = phi i64 [%432, %$54] ; # Len
  %440 = phi i64* [%433, %$54] ; # TopA
  %441 = phi i64 [%434, %$54] ; # N
  %442 = phi i64 [%435, %$54] ; # D
; # (% Scl 3)
  %443 = urem i64 %438, 3
; # (=0 (% Scl 3))
  %444 = icmp eq i64 %443, 0
  br label %$53
$53:
  %445 = phi i64 [%423, %$51], [%430, %$54], [%437, %$55] ; # Num
  %446 = phi i64 [%424, %$51], [%431, %$54], [%438, %$55] ; # Scl
  %447 = phi i64 [%425, %$51], [%432, %$54], [%439, %$55] ; # Len
  %448 = phi i64* [%426, %$51], [%433, %$54], [%440, %$55] ; # TopA
  %449 = phi i64 [%427, %$51], [%434, %$54], [%441, %$55] ; # N
  %450 = phi i64 [%428, %$51], [%435, %$54], [%442, %$55] ; # D
  %451 = phi i1 [0, %$51], [0, %$54], [%444, %$55] ; # ->
  br i1 %451, label %$57, label %$56
$57:
  %452 = phi i64 [%445, %$53] ; # Num
  %453 = phi i64 [%446, %$53] ; # Scl
  %454 = phi i64 [%447, %$53] ; # Len
  %455 = phi i64* [%448, %$53] ; # TopA
  %456 = phi i64 [%449, %$53] ; # N
  %457 = phi i64 [%450, %$53] ; # D
; # (byteSym Ign P)
  call void @byteSym(i8 %3, i64* %4)
  br label %$50
$56:
  %458 = phi i64 [%445, %$53] ; # Num
  %459 = phi i64 [%446, %$53] ; # Scl
  %460 = phi i64 [%447, %$53] ; # Len
  %461 = phi i64* [%448, %$53] ; # TopA
  %462 = phi i64 [%449, %$53] ; # N
  %463 = phi i64 [%450, %$53] ; # D
  br label %$50
$50:
  %464 = phi i64 [%417, %$52], [%452, %$57], [%458, %$56] ; # Num
  %465 = phi i64 [%418, %$52], [%453, %$57], [%459, %$56] ; # Scl
  %466 = phi i64 [%419, %$52], [%454, %$57], [%460, %$56] ; # Len
  %467 = phi i64* [%420, %$52], [%455, %$57], [%461, %$56] ; # TopA
  %468 = phi i64 [%421, %$52], [%456, %$57], [%462, %$56] ; # N
  %469 = phi i64 [%422, %$52], [%457, %$57], [%463, %$56] ; # D
; # (dec 'Scl)
  %470 = sub i64 %465, 1
; # (/ N D)
  %471 = udiv i64 %468, %469
; # (i8 (/ N D))
  %472 = trunc i64 %471 to i8
; # (+ (i8 (/ N D)) (char "0"))
  %473 = add i8 %472, 48
; # (byteSym (+ (i8 (/ N D)) (char "0")) P)
  call void @byteSym(i8 %473, i64* %4)
; # (% N D)
  %474 = urem i64 %468, %469
; # (? (== 1 (setq D (/ D 10))))
; # (/ D 10)
  %475 = udiv i64 %469, 10
; # (== 1 (setq D (/ D 10)))
  %476 = icmp eq i64 1, %475
  br i1 %476, label %$59, label %$58
$58:
  %477 = phi i64 [%464, %$50] ; # Num
  %478 = phi i64 [%470, %$50] ; # Scl
  %479 = phi i64 [%466, %$50] ; # Len
  %480 = phi i64* [%467, %$50] ; # TopA
  %481 = phi i64 [%474, %$50] ; # N
  %482 = phi i64 [%475, %$50] ; # D
  br label %$49
$59:
  %483 = phi i64 [%464, %$50] ; # Num
  %484 = phi i64 [%470, %$50] ; # Scl
  %485 = phi i64 [%466, %$50] ; # Len
  %486 = phi i64* [%467, %$50] ; # TopA
  %487 = phi i64 [%474, %$50] ; # N
  %488 = phi i64 [%475, %$50] ; # D
  %489 = phi i64 [0, %$50] ; # ->
; # (i8 N)
  %490 = trunc i64 %487 to i8
; # (+ (i8 N) (char "0"))
  %491 = add i8 %490, 48
; # (byteSym (+ (i8 N) (char "0")) P)
  call void @byteSym(i8 %491, i64* %4)
  br label %$46
$48:
  %492 = phi i64 [%395, %$46] ; # Num
  %493 = phi i64 [%396, %$46] ; # Scl
  %494 = phi i64 [%397, %$46] ; # Len
  %495 = phi i64* [%401, %$46] ; # TopA
  %496 = phi i64 [%399, %$46] ; # N
  %497 = phi i64 [%400, %$46] ; # D
  br label %$33
$34:
  %498 = phi i64 [%307, %$32] ; # Num
  %499 = phi i64 [%308, %$32] ; # Scl
  %500 = phi i64 [%309, %$32] ; # Len
  %501 = phi i64* [%310, %$32] ; # TopA
  %502 = phi i64 [%317, %$32] ; # N
  %503 = phi i64 [%318, %$32] ; # D
; # (== Scl -1)
  %504 = icmp eq i64 %499, -1
  br i1 %504, label %$61, label %$60
$61:
  %505 = phi i64 [%498, %$34] ; # Num
  %506 = phi i64 [%499, %$34] ; # Scl
  %507 = phi i64 [%500, %$34] ; # Len
  %508 = phi i64* [%501, %$34] ; # TopA
  %509 = phi i64 [%502, %$34] ; # N
  %510 = phi i64 [%503, %$34] ; # D
; # (loop (inc 'N) (? (=0 (setq D (/ D 10)))))
  br label %$62
$62:
  %511 = phi i64 [%505, %$61], [%520, %$63] ; # Num
  %512 = phi i64 [%506, %$61], [%521, %$63] ; # Scl
  %513 = phi i64 [%507, %$61], [%522, %$63] ; # Len
  %514 = phi i64* [%508, %$61], [%523, %$63] ; # TopA
  %515 = phi i64 [%509, %$61], [%524, %$63] ; # N
  %516 = phi i64 [%510, %$61], [%525, %$63] ; # D
; # (inc 'N)
  %517 = add i64 %515, 1
; # (? (=0 (setq D (/ D 10))))
; # (/ D 10)
  %518 = udiv i64 %516, 10
; # (=0 (setq D (/ D 10)))
  %519 = icmp eq i64 %518, 0
  br i1 %519, label %$64, label %$63
$63:
  %520 = phi i64 [%511, %$62] ; # Num
  %521 = phi i64 [%512, %$62] ; # Scl
  %522 = phi i64 [%513, %$62] ; # Len
  %523 = phi i64* [%514, %$62] ; # TopA
  %524 = phi i64 [%517, %$62] ; # N
  %525 = phi i64 [%518, %$62] ; # D
  br label %$62
$64:
  %526 = phi i64 [%511, %$62] ; # Num
  %527 = phi i64 [%512, %$62] ; # Scl
  %528 = phi i64 [%513, %$62] ; # Len
  %529 = phi i64* [%514, %$62] ; # TopA
  %530 = phi i64 [%517, %$62] ; # N
  %531 = phi i64 [%518, %$62] ; # D
  %532 = phi i64 [0, %$62] ; # ->
; # (when Sign (inc 'N))
  br i1 %6, label %$65, label %$66
$65:
  %533 = phi i64 [%526, %$64] ; # Num
  %534 = phi i64 [%527, %$64] ; # Scl
  %535 = phi i64 [%528, %$64] ; # Len
  %536 = phi i64* [%529, %$64] ; # TopA
  %537 = phi i64 [%530, %$64] ; # N
  %538 = phi i64 [%531, %$64] ; # D
; # (inc 'N)
  %539 = add i64 %537, 1
  br label %$66
$66:
  %540 = phi i64 [%526, %$64], [%533, %$65] ; # Num
  %541 = phi i64 [%527, %$64], [%534, %$65] ; # Scl
  %542 = phi i64 [%528, %$64], [%535, %$65] ; # Len
  %543 = phi i64* [%529, %$64], [%536, %$65] ; # TopA
  %544 = phi i64 [%530, %$64], [%539, %$65] ; # N
  %545 = phi i64 [%531, %$64], [%538, %$65] ; # D
; # (cnt N)
  %546 = shl i64 %544, 4
  %547 = or i64 %546, 2
  br label %$33
$60:
  %548 = phi i64 [%498, %$34] ; # Num
  %549 = phi i64 [%499, %$34] ; # Scl
  %550 = phi i64 [%500, %$34] ; # Len
  %551 = phi i64* [%501, %$34] ; # TopA
  %552 = phi i64 [%502, %$34] ; # N
  %553 = phi i64 [%503, %$34] ; # D
; # (when Sign (call $Put (char "-")))
  br i1 %6, label %$67, label %$68
$67:
  %554 = phi i64 [%548, %$60] ; # Num
  %555 = phi i64 [%549, %$60] ; # Scl
  %556 = phi i64 [%550, %$60] ; # Len
  %557 = phi i64* [%551, %$60] ; # TopA
  %558 = phi i64 [%552, %$60] ; # N
  %559 = phi i64 [%553, %$60] ; # D
; # (call $Put (char "-"))
  %560 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %560(i8 45)
  br label %$68
$68:
  %561 = phi i64 [%548, %$60], [%554, %$67] ; # Num
  %562 = phi i64 [%549, %$60], [%555, %$67] ; # Scl
  %563 = phi i64 [%550, %$60], [%556, %$67] ; # Len
  %564 = phi i64* [%551, %$60], [%557, %$67] ; # TopA
  %565 = phi i64 [%552, %$60], [%558, %$67] ; # N
  %566 = phi i64 [%553, %$60], [%559, %$67] ; # D
; # (if (=0 Sep) (outWord (val TopA)) (while (setq D (/ D 10)) (inc '...
; # (=0 Sep)
  %567 = icmp eq i8 %2, 0
  br i1 %567, label %$69, label %$70
$69:
  %568 = phi i64 [%561, %$68] ; # Num
  %569 = phi i64 [%562, %$68] ; # Scl
  %570 = phi i64 [%563, %$68] ; # Len
  %571 = phi i64* [%564, %$68] ; # TopA
  %572 = phi i64 [%565, %$68] ; # N
  %573 = phi i64 [%566, %$68] ; # D
; # (val TopA)
  %574 = load i64, i64* %571
; # (outWord (val TopA))
  call void @outWord(i64 %574)
  br label %$71
$70:
  %575 = phi i64 [%561, %$68] ; # Num
  %576 = phi i64 [%562, %$68] ; # Scl
  %577 = phi i64 [%563, %$68] ; # Len
  %578 = phi i64* [%564, %$68] ; # TopA
  %579 = phi i64 [%565, %$68] ; # N
  %580 = phi i64 [%566, %$68] ; # D
; # (while (setq D (/ D 10)) (inc 'N))
  br label %$72
$72:
  %581 = phi i64 [%575, %$70], [%589, %$73] ; # Num
  %582 = phi i64 [%576, %$70], [%590, %$73] ; # Scl
  %583 = phi i64 [%577, %$70], [%591, %$73] ; # Len
  %584 = phi i64* [%578, %$70], [%592, %$73] ; # TopA
  %585 = phi i64 [%579, %$70], [%595, %$73] ; # N
  %586 = phi i64 [%580, %$70], [%594, %$73] ; # D
; # (/ D 10)
  %587 = udiv i64 %586, 10
  %588 = icmp ne i64 %587, 0
  br i1 %588, label %$73, label %$74
$73:
  %589 = phi i64 [%581, %$72] ; # Num
  %590 = phi i64 [%582, %$72] ; # Scl
  %591 = phi i64 [%583, %$72] ; # Len
  %592 = phi i64* [%584, %$72] ; # TopA
  %593 = phi i64 [%585, %$72] ; # N
  %594 = phi i64 [%587, %$72] ; # D
; # (inc 'N)
  %595 = add i64 %593, 1
  br label %$72
$74:
  %596 = phi i64 [%581, %$72] ; # Num
  %597 = phi i64 [%582, %$72] ; # Scl
  %598 = phi i64 [%583, %$72] ; # Len
  %599 = phi i64* [%584, %$72] ; # TopA
  %600 = phi i64 [%585, %$72] ; # N
  %601 = phi i64 [%587, %$72] ; # D
; # (when (lt0 (setq Scl (- N Scl))) (call $Put (char "0")) (call $Pu...
; # (- N Scl)
  %602 = sub i64 %600, %597
; # (lt0 (setq Scl (- N Scl)))
  %603 = icmp slt i64 %602, 0
  br i1 %603, label %$75, label %$76
$75:
  %604 = phi i64 [%596, %$74] ; # Num
  %605 = phi i64 [%602, %$74] ; # Scl
  %606 = phi i64 [%598, %$74] ; # Len
  %607 = phi i64* [%599, %$74] ; # TopA
  %608 = phi i64 [%600, %$74] ; # N
  %609 = phi i64 [%601, %$74] ; # D
; # (call $Put (char "0"))
  %610 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %610(i8 48)
; # (call $Put Sep)
  %611 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %611(i8 %2)
; # (while (> -1 Scl) (inc 'Scl) (call $Put (char "0")))
  br label %$77
$77:
  %612 = phi i64 [%604, %$75], [%619, %$78] ; # Num
  %613 = phi i64 [%605, %$75], [%625, %$78] ; # Scl
  %614 = phi i64 [%606, %$75], [%621, %$78] ; # Len
  %615 = phi i64* [%607, %$75], [%622, %$78] ; # TopA
  %616 = phi i64 [%608, %$75], [%623, %$78] ; # N
  %617 = phi i64 [%609, %$75], [%624, %$78] ; # D
; # (> -1 Scl)
  %618 = icmp ugt i64 -1, %613
  br i1 %618, label %$78, label %$79
$78:
  %619 = phi i64 [%612, %$77] ; # Num
  %620 = phi i64 [%613, %$77] ; # Scl
  %621 = phi i64 [%614, %$77] ; # Len
  %622 = phi i64* [%615, %$77] ; # TopA
  %623 = phi i64 [%616, %$77] ; # N
  %624 = phi i64 [%617, %$77] ; # D
; # (inc 'Scl)
  %625 = add i64 %620, 1
; # (call $Put (char "0"))
  %626 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %626(i8 48)
  br label %$77
$79:
  %627 = phi i64 [%612, %$77] ; # Num
  %628 = phi i64 [%613, %$77] ; # Scl
  %629 = phi i64 [%614, %$77] ; # Len
  %630 = phi i64* [%615, %$77] ; # TopA
  %631 = phi i64 [%616, %$77] ; # N
  %632 = phi i64 [%617, %$77] ; # D
  br label %$76
$76:
  %633 = phi i64 [%596, %$74], [%627, %$79] ; # Num
  %634 = phi i64 [%602, %$74], [%628, %$79] ; # Scl
  %635 = phi i64 [%598, %$74], [%629, %$79] ; # Len
  %636 = phi i64* [%599, %$74], [%630, %$79] ; # TopA
  %637 = phi i64 [%600, %$74], [%631, %$79] ; # N
  %638 = phi i64 [%601, %$74], [%632, %$79] ; # D
; # (val TopA)
  %639 = load i64, i64* %636
; # (outScl (val TopA) Scl Sep)
  %640 = call i64 @outScl(i64 %639, i64 %634, i8 %2)
  br label %$71
$71:
  %641 = phi i64 [%568, %$69], [%633, %$76] ; # Num
  %642 = phi i64 [%569, %$69], [%640, %$76] ; # Scl
  %643 = phi i64 [%570, %$69], [%635, %$76] ; # Len
  %644 = phi i64* [%571, %$69], [%636, %$76] ; # TopA
  %645 = phi i64 [%572, %$69], [%637, %$76] ; # N
  %646 = phi i64 [%573, %$69], [%638, %$76] ; # D
; # (while (>= (dec 'TopA) Acc) (let (N (val TopA) D 1000000000000000...
  br label %$80
$80:
  %647 = phi i64 [%641, %$71], [%710, %$89] ; # Num
  %648 = phi i64 [%642, %$71], [%711, %$89] ; # Scl
  %649 = phi i64 [%643, %$71], [%712, %$89] ; # Len
  %650 = phi i64* [%644, %$71], [%713, %$89] ; # TopA
  %651 = phi i64 [%645, %$71], [%659, %$89] ; # N
  %652 = phi i64 [%646, %$71], [%660, %$89] ; # D
; # (dec 'TopA)
  %653 = getelementptr i64, i64* %650, i32 -1
; # (>= (dec 'TopA) Acc)
  %654 = icmp uge i64* %653, %27
  br i1 %654, label %$81, label %$82
$81:
  %655 = phi i64 [%647, %$80] ; # Num
  %656 = phi i64 [%648, %$80] ; # Scl
  %657 = phi i64 [%649, %$80] ; # Len
  %658 = phi i64* [%653, %$80] ; # TopA
  %659 = phi i64 [%651, %$80] ; # N
  %660 = phi i64 [%652, %$80] ; # D
; # (let (N (val TopA) D 100000000000000000) (loop (when (and Sep (=0...
; # (val TopA)
  %661 = load i64, i64* %658
; # (loop (when (and Sep (=0 Scl)) (call $Put Sep)) (dec 'Scl) (call ...
  br label %$83
$83:
  %662 = phi i64 [%655, %$81], [%704, %$88] ; # Num
  %663 = phi i64 [%656, %$81], [%705, %$88] ; # Scl
  %664 = phi i64 [%657, %$81], [%706, %$88] ; # Len
  %665 = phi i64* [%658, %$81], [%707, %$88] ; # TopA
  %666 = phi i64 [%661, %$81], [%708, %$88] ; # N
  %667 = phi i64 [100000000000000000, %$81], [%709, %$88] ; # D
; # (when (and Sep (=0 Scl)) (call $Put Sep))
; # (and Sep (=0 Scl))
  %668 = icmp ne i8 %2, 0
  br i1 %668, label %$85, label %$84
$85:
  %669 = phi i64 [%662, %$83] ; # Num
  %670 = phi i64 [%663, %$83] ; # Scl
  %671 = phi i64 [%664, %$83] ; # Len
  %672 = phi i64* [%665, %$83] ; # TopA
  %673 = phi i64 [%666, %$83] ; # N
  %674 = phi i64 [%667, %$83] ; # D
; # (=0 Scl)
  %675 = icmp eq i64 %670, 0
  br label %$84
$84:
  %676 = phi i64 [%662, %$83], [%669, %$85] ; # Num
  %677 = phi i64 [%663, %$83], [%670, %$85] ; # Scl
  %678 = phi i64 [%664, %$83], [%671, %$85] ; # Len
  %679 = phi i64* [%665, %$83], [%672, %$85] ; # TopA
  %680 = phi i64 [%666, %$83], [%673, %$85] ; # N
  %681 = phi i64 [%667, %$83], [%674, %$85] ; # D
  %682 = phi i1 [0, %$83], [%675, %$85] ; # ->
  br i1 %682, label %$86, label %$87
$86:
  %683 = phi i64 [%676, %$84] ; # Num
  %684 = phi i64 [%677, %$84] ; # Scl
  %685 = phi i64 [%678, %$84] ; # Len
  %686 = phi i64* [%679, %$84] ; # TopA
  %687 = phi i64 [%680, %$84] ; # N
  %688 = phi i64 [%681, %$84] ; # D
; # (call $Put Sep)
  %689 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %689(i8 %2)
  br label %$87
$87:
  %690 = phi i64 [%676, %$84], [%683, %$86] ; # Num
  %691 = phi i64 [%677, %$84], [%684, %$86] ; # Scl
  %692 = phi i64 [%678, %$84], [%685, %$86] ; # Len
  %693 = phi i64* [%679, %$84], [%686, %$86] ; # TopA
  %694 = phi i64 [%680, %$84], [%687, %$86] ; # N
  %695 = phi i64 [%681, %$84], [%688, %$86] ; # D
; # (dec 'Scl)
  %696 = sub i64 %691, 1
; # (/ N D)
  %697 = udiv i64 %694, %695
; # (i8 (/ N D))
  %698 = trunc i64 %697 to i8
; # (+ (i8 (/ N D)) (char "0"))
  %699 = add i8 %698, 48
; # (call $Put (+ (i8 (/ N D)) (char "0")))
  %700 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %700(i8 %699)
; # (% N D)
  %701 = urem i64 %694, %695
; # (? (== 1 (setq D (/ D 10))))
; # (/ D 10)
  %702 = udiv i64 %695, 10
; # (== 1 (setq D (/ D 10)))
  %703 = icmp eq i64 1, %702
  br i1 %703, label %$89, label %$88
$88:
  %704 = phi i64 [%690, %$87] ; # Num
  %705 = phi i64 [%696, %$87] ; # Scl
  %706 = phi i64 [%692, %$87] ; # Len
  %707 = phi i64* [%693, %$87] ; # TopA
  %708 = phi i64 [%701, %$87] ; # N
  %709 = phi i64 [%702, %$87] ; # D
  br label %$83
$89:
  %710 = phi i64 [%690, %$87] ; # Num
  %711 = phi i64 [%696, %$87] ; # Scl
  %712 = phi i64 [%692, %$87] ; # Len
  %713 = phi i64* [%693, %$87] ; # TopA
  %714 = phi i64 [%701, %$87] ; # N
  %715 = phi i64 [%702, %$87] ; # D
  %716 = phi i64 [0, %$87] ; # ->
; # (i8 N)
  %717 = trunc i64 %714 to i8
; # (+ (i8 N) (char "0"))
  %718 = add i8 %717, 48
; # (call $Put (+ (i8 N) (char "0")))
  %719 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %719(i8 %718)
  br label %$80
$82:
  %720 = phi i64 [%647, %$80] ; # Num
  %721 = phi i64 [%648, %$80] ; # Scl
  %722 = phi i64 [%649, %$80] ; # Len
  %723 = phi i64* [%653, %$80] ; # TopA
  %724 = phi i64 [%651, %$80] ; # N
  %725 = phi i64 [%652, %$80] ; # D
  br label %$33
$33:
  %726 = phi i64 [%492, %$48], [%540, %$66], [%720, %$82] ; # Num
  %727 = phi i64 [%493, %$48], [%541, %$66], [%721, %$82] ; # Scl
  %728 = phi i64 [%494, %$48], [%542, %$66], [%722, %$82] ; # Len
  %729 = phi i64* [%495, %$48], [%543, %$66], [%723, %$82] ; # TopA
  %730 = phi i64 [%496, %$48], [%544, %$66], [%724, %$82] ; # N
  %731 = phi i64 [%497, %$48], [%545, %$66], [%725, %$82] ; # D
  %732 = phi i64 [0, %$48], [%547, %$66], [0, %$82] ; # ->
  ret i64 %732
}

define i64 @_Format(i64) align 8 {
$1:
; # (let (X (cdr Exe) A (save (eval (++ X))) Y (eval (++ X)) Scl (if ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (save (eval (++ X)))
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %17 = load i64, i64* %16
  %18 = alloca i64, i64 2, align 16
  %19 = ptrtoint i64* %18 to i64
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = add i64 %19, 8
  %22 = inttoptr i64 %21 to i64*
  store i64 %17, i64* %22
  %23 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %19, i64* %23
; # (++ X)
  %24 = inttoptr i64 %7 to i64*
  %25 = load i64, i64* %24
  %26 = getelementptr i64, i64* %24, i32 1
  %27 = load i64, i64* %26
; # (eval (++ X))
  %28 = and i64 %25, 6
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %$9, label %$8
$9:
  br label %$7
$8:
  %30 = and i64 %25, 8
  %31 = icmp ne i64 %30, 0
  br i1 %31, label %$11, label %$10
$11:
  %32 = inttoptr i64 %25 to i64*
  %33 = load i64, i64* %32
  br label %$7
$10:
  %34 = call i64 @evList(i64 %25)
  br label %$7
$7:
  %35 = phi i64 [%25, %$9], [%33, %$11], [%34, %$10] ; # ->
; # (if (nil? Y) 0 (xCnt Exe Y))
; # (nil? Y)
  %36 = icmp eq i64 %35, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %36, label %$12, label %$13
$12:
  %37 = phi i64 [%27, %$7] ; # X
  br label %$14
$13:
  %38 = phi i64 [%27, %$7] ; # X
; # (xCnt Exe Y)
  %39 = call i64 @xCnt(i64 %0, i64 %35)
  br label %$14
$14:
  %40 = phi i64 [%37, %$12], [%38, %$13] ; # X
  %41 = phi i64 [0, %$12], [%39, %$13] ; # ->
; # (i8 (char "."))
; # (i8 0)
; # (when (pair X) (setq Sep (firstByte (needSymb Exe (eval (++ X))))...
; # (pair X)
  %42 = and i64 %40, 15
  %43 = icmp eq i64 %42, 0
  br i1 %43, label %$15, label %$16
$15:
  %44 = phi i64 [%40, %$14] ; # X
  %45 = phi i8 [46, %$14] ; # Sep
  %46 = phi i8 [0, %$14] ; # Ign
; # (++ X)
  %47 = inttoptr i64 %44 to i64*
  %48 = load i64, i64* %47
  %49 = getelementptr i64, i64* %47, i32 1
  %50 = load i64, i64* %49
; # (eval (++ X))
  %51 = and i64 %48, 6
  %52 = icmp ne i64 %51, 0
  br i1 %52, label %$19, label %$18
$19:
  br label %$17
$18:
  %53 = and i64 %48, 8
  %54 = icmp ne i64 %53, 0
  br i1 %54, label %$21, label %$20
$21:
  %55 = inttoptr i64 %48 to i64*
  %56 = load i64, i64* %55
  br label %$17
$20:
  %57 = call i64 @evList(i64 %48)
  br label %$17
$17:
  %58 = phi i64 [%48, %$19], [%56, %$21], [%57, %$20] ; # ->
; # (needSymb Exe (eval (++ X)))
  %59 = xor i64 %58, 8
  %60 = and i64 %59, 14
  %61 = icmp eq i64 %60, 0
  br i1 %61, label %$23, label %$22
$22:
  call void @symErr(i64 %0, i64 %58)
  unreachable
$23:
; # (firstByte (needSymb Exe (eval (++ X))))
  %62 = call i8 @firstByte(i64 %58)
; # (when (pair X) (setq Ign (firstByte (needSymb Exe (eval (car X)))...
; # (pair X)
  %63 = and i64 %50, 15
  %64 = icmp eq i64 %63, 0
  br i1 %64, label %$24, label %$25
$24:
  %65 = phi i64 [%50, %$23] ; # X
  %66 = phi i8 [%62, %$23] ; # Sep
  %67 = phi i8 [%46, %$23] ; # Ign
; # (car X)
  %68 = inttoptr i64 %65 to i64*
  %69 = load i64, i64* %68
; # (eval (car X))
  %70 = and i64 %69, 6
  %71 = icmp ne i64 %70, 0
  br i1 %71, label %$28, label %$27
$28:
  br label %$26
$27:
  %72 = and i64 %69, 8
  %73 = icmp ne i64 %72, 0
  br i1 %73, label %$30, label %$29
$30:
  %74 = inttoptr i64 %69 to i64*
  %75 = load i64, i64* %74
  br label %$26
$29:
  %76 = call i64 @evList(i64 %69)
  br label %$26
$26:
  %77 = phi i64 [%69, %$28], [%75, %$30], [%76, %$29] ; # ->
; # (needSymb Exe (eval (car X)))
  %78 = xor i64 %77, 8
  %79 = and i64 %78, 14
  %80 = icmp eq i64 %79, 0
  br i1 %80, label %$32, label %$31
$31:
  call void @symErr(i64 %0, i64 %77)
  unreachable
$32:
; # (firstByte (needSymb Exe (eval (car X))))
  %81 = call i8 @firstByte(i64 %77)
  br label %$25
$25:
  %82 = phi i64 [%50, %$23], [%65, %$32] ; # X
  %83 = phi i8 [%62, %$23], [%66, %$32] ; # Sep
  %84 = phi i8 [%46, %$23], [%81, %$32] ; # Ign
  br label %$16
$16:
  %85 = phi i64 [%40, %$14], [%82, %$25] ; # X
  %86 = phi i8 [46, %$14], [%83, %$25] ; # Sep
  %87 = phi i8 [0, %$14], [%84, %$25] ; # Ign
; # (cond ((num? A) (let P (push 4 NIL ZERO NIL) (link (ofs P 2)) (fm...
; # (num? A)
  %88 = and i64 %15, 6
  %89 = icmp ne i64 %88, 0
  br i1 %89, label %$35, label %$34
$35:
  %90 = phi i64 [%85, %$16] ; # X
  %91 = phi i8 [%86, %$16] ; # Sep
  %92 = phi i8 [%87, %$16] ; # Ign
; # (let P (push 4 NIL ZERO NIL) (link (ofs P 2)) (fmtNum A Scl Sep I...
; # (push 4 NIL ZERO NIL)
  %93 = alloca i64, i64 4, align 16
  store i64 4, i64* %93
  %94 = getelementptr i64, i64* %93, i32 2
  store i64 2, i64* %94
; # (ofs P 2)
  %95 = getelementptr i64, i64* %93, i32 2
; # (link (ofs P 2))
  %96 = ptrtoint i64* %95 to i64
  %97 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %98 = load i64, i64* %97
  %99 = inttoptr i64 %96 to i64*
  %100 = getelementptr i64, i64* %99, i32 1
  store i64 %98, i64* %100
  %101 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %96, i64* %101
; # (fmtNum A Scl Sep Ign P)
  %102 = call i64 @fmtNum(i64 %15, i64 %41, i8 %91, i8 %92, i64* %93)
; # (val 3 P)
  %103 = getelementptr i64, i64* %93, i32 2
  %104 = load i64, i64* %103
; # (consStr (val 3 P))
  %105 = call i64 @consStr(i64 %104)
  br label %$33
$34:
  %106 = phi i64 [%85, %$16] ; # X
  %107 = phi i8 [%86, %$16] ; # Sep
  %108 = phi i8 [%87, %$16] ; # Ign
; # (sym? A)
  %109 = and i64 %15, 8
  %110 = icmp ne i64 %109, 0
  br i1 %110, label %$37, label %$36
$37:
  %111 = phi i64 [%106, %$34] ; # X
  %112 = phi i8 [%107, %$34] ; # Sep
  %113 = phi i8 [%108, %$34] ; # Ign
; # (cond ((sym? (val (tail A))) $Nil) ((=0 (symToNum (name @) Scl Se...
; # (tail A)
  %114 = add i64 %15, -8
; # (val (tail A))
  %115 = inttoptr i64 %114 to i64*
  %116 = load i64, i64* %115
; # (sym? (val (tail A)))
  %117 = and i64 %116, 8
  %118 = icmp ne i64 %117, 0
  br i1 %118, label %$40, label %$39
$40:
  %119 = phi i64 [%111, %$37] ; # X
  %120 = phi i8 [%112, %$37] ; # Sep
  %121 = phi i8 [%113, %$37] ; # Ign
  br label %$38
$39:
  %122 = phi i64 [%111, %$37] ; # X
  %123 = phi i8 [%112, %$37] ; # Sep
  %124 = phi i8 [%113, %$37] ; # Ign
; # (name @)
  br label %$41
$41:
  %125 = phi i64 [%116, %$39], [%131, %$42] ; # Tail
  %126 = and i64 %125, 6
  %127 = icmp ne i64 %126, 0
  br i1 %127, label %$43, label %$42
$42:
  %128 = phi i64 [%125, %$41] ; # Tail
  %129 = inttoptr i64 %128 to i64*
  %130 = getelementptr i64, i64* %129, i32 1
  %131 = load i64, i64* %130
  br label %$41
$43:
  %132 = phi i64 [%125, %$41] ; # Tail
; # (symToNum (name @) Scl Sep Ign)
  %133 = call i64 @symToNum(i64 %132, i64 %41, i8 %123, i8 %124)
; # (=0 (symToNum (name @) Scl Sep Ign))
  %134 = icmp eq i64 %133, 0
  br i1 %134, label %$45, label %$44
$45:
  %135 = phi i64 [%122, %$43] ; # X
  %136 = phi i8 [%123, %$43] ; # Sep
  %137 = phi i8 [%124, %$43] ; # Ign
  br label %$38
$44:
  %138 = phi i64 [%122, %$43] ; # X
  %139 = phi i8 [%123, %$43] ; # Sep
  %140 = phi i8 [%124, %$43] ; # Ign
  br label %$38
$38:
  %141 = phi i64 [%119, %$40], [%135, %$45], [%138, %$44] ; # X
  %142 = phi i8 [%120, %$40], [%136, %$45], [%139, %$44] ; # Sep
  %143 = phi i8 [%121, %$40], [%137, %$45], [%140, %$44] ; # Ign
  %144 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$40], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$45], [%133, %$44] ; # ->
  br label %$33
$36:
  %145 = phi i64 [%106, %$34] ; # X
  %146 = phi i8 [%107, %$34] ; # Sep
  %147 = phi i8 [%108, %$34] ; # Ign
; # (if (symToNum (let P (push 4 NIL ZERO NIL) (link (ofs P 2)) (pack...
; # (let P (push 4 NIL ZERO NIL) (link (ofs P 2)) (pack A P) (val 3 P...
; # (push 4 NIL ZERO NIL)
  %148 = alloca i64, i64 4, align 16
  store i64 4, i64* %148
  %149 = getelementptr i64, i64* %148, i32 2
  store i64 2, i64* %149
; # (ofs P 2)
  %150 = getelementptr i64, i64* %148, i32 2
; # (link (ofs P 2))
  %151 = ptrtoint i64* %150 to i64
  %152 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %153 = load i64, i64* %152
  %154 = inttoptr i64 %151 to i64*
  %155 = getelementptr i64, i64* %154, i32 1
  store i64 %153, i64* %155
  %156 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %151, i64* %156
; # (pack A P)
  call void @pack(i64 %15, i64* %148)
; # (val 3 P)
  %157 = getelementptr i64, i64* %148, i32 2
  %158 = load i64, i64* %157
; # (symToNum (let P (push 4 NIL ZERO NIL) (link (ofs P 2)) (pack A P...
  %159 = call i64 @symToNum(i64 %158, i64 %41, i8 %146, i8 %147)
  %160 = icmp ne i64 %159, 0
  br i1 %160, label %$46, label %$47
$46:
  %161 = phi i64 [%145, %$36] ; # X
  %162 = phi i8 [%146, %$36] ; # Sep
  %163 = phi i8 [%147, %$36] ; # Ign
  br label %$48
$47:
  %164 = phi i64 [%145, %$36] ; # X
  %165 = phi i8 [%146, %$36] ; # Sep
  %166 = phi i8 [%147, %$36] ; # Ign
  br label %$48
$48:
  %167 = phi i64 [%161, %$46], [%164, %$47] ; # X
  %168 = phi i8 [%162, %$46], [%165, %$47] ; # Sep
  %169 = phi i8 [%163, %$46], [%166, %$47] ; # Ign
  %170 = phi i64 [%159, %$46], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$47] ; # ->
  br label %$33
$33:
  %171 = phi i64 [%90, %$35], [%141, %$38], [%167, %$48] ; # X
  %172 = phi i8 [%91, %$35], [%142, %$38], [%168, %$48] ; # Sep
  %173 = phi i8 [%92, %$35], [%143, %$38], [%169, %$48] ; # Ign
  %174 = phi i64 [%105, %$35], [%144, %$38], [%170, %$48] ; # ->
; # (drop *Safe)
  %175 = inttoptr i64 %19 to i64*
  %176 = getelementptr i64, i64* %175, i32 1
  %177 = load i64, i64* %176
  %178 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %177, i64* %178
  ret i64 %174
}

define i64 @_Add(i64) align 8 {
$1:
; # (let X (cdr Exe) (if (nil? (eval (car X))) @ (save -ZERO (let R (...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (if (nil? (eval (car X))) @ (save -ZERO (let R (link (push (needN...
; # (car X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (car X))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (nil? (eval (car X)))
  %14 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %14, label %$7, label %$8
$7:
  %15 = phi i64 [%3, %$2] ; # X
  br label %$9
$8:
  %16 = phi i64 [%3, %$2] ; # X
; # (save -ZERO (let R (link (push (needNum Exe @) NIL)) (loop (? (at...
  %17 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %18 = load i64, i64* %17
  %19 = alloca i64, i64 2, align 16
  %20 = ptrtoint i64* %19 to i64
  %21 = inttoptr i64 %20 to i64*
  store i64 10, i64* %21
  %22 = add i64 %20, 8
  %23 = inttoptr i64 %22 to i64*
  store i64 %18, i64* %23
  %24 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %20, i64* %24
; # (let R (link (push (needNum Exe @) NIL)) (loop (? (atom (shift X)...
; # (needNum Exe @)
  %25 = and i64 %13, 6
  %26 = icmp ne i64 %25, 0
  br i1 %26, label %$11, label %$10
$10:
  call void @numErr(i64 %0, i64 %13)
  unreachable
$11:
; # (push (needNum Exe @) NIL)
  %27 = alloca i64, i64 2, align 16
  %28 = ptrtoint i64* %27 to i64
  %29 = inttoptr i64 %28 to i64*
  store i64 %13, i64* %29
; # (link (push (needNum Exe @) NIL))
  %30 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %31 = load i64, i64* %30
  %32 = inttoptr i64 %28 to i64*
  %33 = getelementptr i64, i64* %32, i32 1
  store i64 %31, i64* %33
  %34 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %28, i64* %34
; # (loop (? (atom (shift X)) (val R)) (? (nil? (eval (car X))) @) (s...
  br label %$12
$12:
  %35 = phi i64 [%16, %$11], [%57, %$24] ; # X
; # (? (atom (shift X)) (val R))
; # (shift X)
  %36 = inttoptr i64 %35 to i64*
  %37 = getelementptr i64, i64* %36, i32 1
  %38 = load i64, i64* %37
; # (atom (shift X))
  %39 = and i64 %38, 15
  %40 = icmp ne i64 %39, 0
  br i1 %40, label %$15, label %$13
$15:
  %41 = phi i64 [%38, %$12] ; # X
; # (val R)
  %42 = inttoptr i64 %28 to i64*
  %43 = load i64, i64* %42
  br label %$14
$13:
  %44 = phi i64 [%38, %$12] ; # X
; # (? (nil? (eval (car X))) @)
; # (car X)
  %45 = inttoptr i64 %44 to i64*
  %46 = load i64, i64* %45
; # (eval (car X))
  %47 = and i64 %46, 6
  %48 = icmp ne i64 %47, 0
  br i1 %48, label %$18, label %$17
$18:
  br label %$16
$17:
  %49 = and i64 %46, 8
  %50 = icmp ne i64 %49, 0
  br i1 %50, label %$20, label %$19
$20:
  %51 = inttoptr i64 %46 to i64*
  %52 = load i64, i64* %51
  br label %$16
$19:
  %53 = call i64 @evList(i64 %46)
  br label %$16
$16:
  %54 = phi i64 [%46, %$18], [%52, %$20], [%53, %$19] ; # ->
; # (nil? (eval (car X)))
  %55 = icmp eq i64 %54, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %55, label %$22, label %$21
$22:
  %56 = phi i64 [%44, %$16] ; # X
  br label %$14
$21:
  %57 = phi i64 [%44, %$16] ; # X
; # (needNum Exe @)
  %58 = and i64 %54, 6
  %59 = icmp ne i64 %58, 0
  br i1 %59, label %$24, label %$23
$23:
  call void @numErr(i64 %0, i64 %54)
  unreachable
$24:
; # (safe (needNum Exe @))
  %60 = inttoptr i64 %20 to i64*
  store i64 %54, i64* %60
; # (set R (adds (val R) @))
; # (val R)
  %61 = inttoptr i64 %28 to i64*
  %62 = load i64, i64* %61
; # (adds (val R) @)
  %63 = call i64 @adds(i64 %62, i64 %54)
  %64 = inttoptr i64 %28 to i64*
  store i64 %63, i64* %64
  br label %$12
$14:
  %65 = phi i64 [%41, %$15], [%56, %$22] ; # X
  %66 = phi i64 [%43, %$15], [%54, %$22] ; # ->
; # drop
  %67 = inttoptr i64 %20 to i64*
  %68 = getelementptr i64, i64* %67, i32 1
  %69 = load i64, i64* %68
  %70 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %69, i64* %70
  br label %$9
$9:
  %71 = phi i64 [%15, %$7], [%65, %$14] ; # X
  %72 = phi i64 [%13, %$7], [%66, %$14] ; # ->
  ret i64 %72
}

define i64 @_Sub(i64) align 8 {
$1:
; # (let (X (cdr Exe) N (eval (++ X))) (if (nil? N) N (needNum Exe N)...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (if (nil? N) N (needNum Exe N) (if (atom X) (neg N) (save -ZERO (...
; # (nil? N)
  %16 = icmp eq i64 %15, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %16, label %$7, label %$8
$7:
  %17 = phi i64 [%7, %$2] ; # X
  br label %$9
$8:
  %18 = phi i64 [%7, %$2] ; # X
; # (needNum Exe N)
  %19 = and i64 %15, 6
  %20 = icmp ne i64 %19, 0
  br i1 %20, label %$11, label %$10
$10:
  call void @numErr(i64 %0, i64 %15)
  unreachable
$11:
; # (if (atom X) (neg N) (save -ZERO (let R (link (push N NIL)) (loop...
; # (atom X)
  %21 = and i64 %18, 15
  %22 = icmp ne i64 %21, 0
  br i1 %22, label %$12, label %$13
$12:
  %23 = phi i64 [%18, %$11] ; # X
; # (neg N)
  %24 = icmp eq i64 %15, 2
  br i1 %24, label %$15, label %$16
$15:
  br label %$17
$16:
  %25 = xor i64 %15, 8
  br label %$17
$17:
  %26 = phi i64 [%15, %$15], [%25, %$16] ; # ->
  br label %$14
$13:
  %27 = phi i64 [%18, %$11] ; # X
; # (save -ZERO (let R (link (push N NIL)) (loop (? (nil? (eval (++ X...
  %28 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %29 = load i64, i64* %28
  %30 = alloca i64, i64 2, align 16
  %31 = ptrtoint i64* %30 to i64
  %32 = inttoptr i64 %31 to i64*
  store i64 10, i64* %32
  %33 = add i64 %31, 8
  %34 = inttoptr i64 %33 to i64*
  store i64 %29, i64* %34
  %35 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %31, i64* %35
; # (let R (link (push N NIL)) (loop (? (nil? (eval (++ X))) @) (safe...
; # (push N NIL)
  %36 = alloca i64, i64 2, align 16
  %37 = ptrtoint i64* %36 to i64
  %38 = inttoptr i64 %37 to i64*
  store i64 %15, i64* %38
; # (link (push N NIL))
  %39 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %40 = load i64, i64* %39
  %41 = inttoptr i64 %37 to i64*
  %42 = getelementptr i64, i64* %41, i32 1
  store i64 %40, i64* %42
  %43 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %37, i64* %43
; # (loop (? (nil? (eval (++ X))) @) (safe (needNum Exe @)) (set R (s...
  br label %$18
$18:
  %44 = phi i64 [%27, %$13], [%72, %$29] ; # X
; # (? (nil? (eval (++ X))) @)
; # (++ X)
  %45 = inttoptr i64 %44 to i64*
  %46 = load i64, i64* %45
  %47 = getelementptr i64, i64* %45, i32 1
  %48 = load i64, i64* %47
; # (eval (++ X))
  %49 = and i64 %46, 6
  %50 = icmp ne i64 %49, 0
  br i1 %50, label %$21, label %$20
$21:
  br label %$19
$20:
  %51 = and i64 %46, 8
  %52 = icmp ne i64 %51, 0
  br i1 %52, label %$23, label %$22
$23:
  %53 = inttoptr i64 %46 to i64*
  %54 = load i64, i64* %53
  br label %$19
$22:
  %55 = call i64 @evList(i64 %46)
  br label %$19
$19:
  %56 = phi i64 [%46, %$21], [%54, %$23], [%55, %$22] ; # ->
; # (nil? (eval (++ X)))
  %57 = icmp eq i64 %56, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %57, label %$26, label %$24
$26:
  %58 = phi i64 [%48, %$19] ; # X
  br label %$25
$24:
  %59 = phi i64 [%48, %$19] ; # X
; # (needNum Exe @)
  %60 = and i64 %56, 6
  %61 = icmp ne i64 %60, 0
  br i1 %61, label %$28, label %$27
$27:
  call void @numErr(i64 %0, i64 %56)
  unreachable
$28:
; # (safe (needNum Exe @))
  %62 = inttoptr i64 %31 to i64*
  store i64 %56, i64* %62
; # (set R (subs (val R) @))
; # (val R)
  %63 = inttoptr i64 %37 to i64*
  %64 = load i64, i64* %63
; # (subs (val R) @)
  %65 = call i64 @subs(i64 %64, i64 %56)
  %66 = inttoptr i64 %37 to i64*
  store i64 %65, i64* %66
; # (? (atom X) (val R))
; # (atom X)
  %67 = and i64 %59, 15
  %68 = icmp ne i64 %67, 0
  br i1 %68, label %$30, label %$29
$30:
  %69 = phi i64 [%59, %$28] ; # X
; # (val R)
  %70 = inttoptr i64 %37 to i64*
  %71 = load i64, i64* %70
  br label %$25
$29:
  %72 = phi i64 [%59, %$28] ; # X
  br label %$18
$25:
  %73 = phi i64 [%58, %$26], [%69, %$30] ; # X
  %74 = phi i64 [%56, %$26], [%71, %$30] ; # ->
; # drop
  %75 = inttoptr i64 %31 to i64*
  %76 = getelementptr i64, i64* %75, i32 1
  %77 = load i64, i64* %76
  %78 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %77, i64* %78
  br label %$14
$14:
  %79 = phi i64 [%23, %$17], [%73, %$25] ; # X
  %80 = phi i64 [%26, %$17], [%74, %$25] ; # ->
  br label %$9
$9:
  %81 = phi i64 [%17, %$7], [%79, %$14] ; # X
  %82 = phi i64 [%15, %$7], [%80, %$14] ; # ->
  ret i64 %82
}

define i64 @_Inc(i64) align 8 {
$1:
; # (let X (cdr Exe) (cond ((nil? (eval (car X))) @) ((num? @) (incs ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (cond ((nil? (eval (car X))) @) ((num? @) (incs @)) (T (let Y (sa...
; # (car X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (car X))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$5, label %$4
$5:
  br label %$3
$4:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$7, label %$6
$7:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$3
$6:
  %12 = call i64 @evList(i64 %5)
  br label %$3
$3:
  %13 = phi i64 [%5, %$5], [%11, %$7], [%12, %$6] ; # ->
; # (nil? (eval (car X)))
  %14 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %14, label %$9, label %$8
$9:
  %15 = phi i64 [%3, %$3] ; # X
  br label %$2
$8:
  %16 = phi i64 [%3, %$3] ; # X
; # (num? @)
  %17 = and i64 %13, 6
  %18 = icmp ne i64 %17, 0
  br i1 %18, label %$11, label %$10
$11:
  %19 = phi i64 [%16, %$8] ; # X
; # (incs @)
  %20 = call i64 @incs(i64 %13)
  br label %$2
$10:
  %21 = phi i64 [%16, %$8] ; # X
; # (let Y (save (chkVar Exe @)) (when (and (sym? Y) (sym? (val (tail...
; # (chkVar Exe @)
  %22 = icmp uge i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %22, label %$13, label %$12
$13:
  %23 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %13
  br label %$12
$12:
  %24 = phi i1 [0, %$10], [%23, %$13] ; # ->
  br i1 %24, label %$14, label %$15
$14:
  call void @protErr(i64 %0, i64 %13)
  unreachable
$15:
; # (save (chkVar Exe @))
  %25 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %26 = load i64, i64* %25
  %27 = alloca i64, i64 2, align 16
  %28 = ptrtoint i64* %27 to i64
  %29 = inttoptr i64 %28 to i64*
  store i64 %13, i64* %29
  %30 = add i64 %28, 8
  %31 = inttoptr i64 %30 to i64*
  store i64 %26, i64* %31
  %32 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %28, i64* %32
; # (when (and (sym? Y) (sym? (val (tail Y)))) (dbTouch Exe Y))
; # (and (sym? Y) (sym? (val (tail Y))))
; # (sym? Y)
  %33 = and i64 %13, 8
  %34 = icmp ne i64 %33, 0
  br i1 %34, label %$17, label %$16
$17:
  %35 = phi i64 [%21, %$15] ; # X
; # (tail Y)
  %36 = add i64 %13, -8
; # (val (tail Y))
  %37 = inttoptr i64 %36 to i64*
  %38 = load i64, i64* %37
; # (sym? (val (tail Y)))
  %39 = and i64 %38, 8
  %40 = icmp ne i64 %39, 0
  br label %$16
$16:
  %41 = phi i64 [%21, %$15], [%35, %$17] ; # X
  %42 = phi i1 [0, %$15], [%40, %$17] ; # ->
  br i1 %42, label %$18, label %$19
$18:
  %43 = phi i64 [%41, %$16] ; # X
; # (dbTouch Exe Y)
  call void @dbTouch(i64 %0, i64 %13)
  br label %$19
$19:
  %44 = phi i64 [%41, %$16], [%43, %$18] ; # X
; # (if (atom (shift X)) (if (nil? (val Y)) @ (set Y (incs (needNum E...
; # (shift X)
  %45 = inttoptr i64 %44 to i64*
  %46 = getelementptr i64, i64* %45, i32 1
  %47 = load i64, i64* %46
; # (atom (shift X))
  %48 = and i64 %47, 15
  %49 = icmp ne i64 %48, 0
  br i1 %49, label %$20, label %$21
$20:
  %50 = phi i64 [%47, %$19] ; # X
; # (if (nil? (val Y)) @ (set Y (incs (needNum Exe @))))
; # (val Y)
  %51 = inttoptr i64 %13 to i64*
  %52 = load i64, i64* %51
; # (nil? (val Y))
  %53 = icmp eq i64 %52, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %53, label %$23, label %$24
$23:
  %54 = phi i64 [%50, %$20] ; # X
  br label %$25
$24:
  %55 = phi i64 [%50, %$20] ; # X
; # (set Y (incs (needNum Exe @)))
; # (needNum Exe @)
  %56 = and i64 %52, 6
  %57 = icmp ne i64 %56, 0
  br i1 %57, label %$27, label %$26
$26:
  call void @numErr(i64 %0, i64 %52)
  unreachable
$27:
; # (incs (needNum Exe @))
  %58 = call i64 @incs(i64 %52)
  %59 = inttoptr i64 %13 to i64*
  store i64 %58, i64* %59
  br label %$25
$25:
  %60 = phi i64 [%54, %$23], [%55, %$27] ; # X
  %61 = phi i64 [%52, %$23], [%58, %$27] ; # ->
  br label %$22
$21:
  %62 = phi i64 [%47, %$19] ; # X
; # (let (D (save (eval (car X))) N (val Y)) (cond ((nil? N) N) ((nil...
; # (car X)
  %63 = inttoptr i64 %62 to i64*
  %64 = load i64, i64* %63
; # (eval (car X))
  %65 = and i64 %64, 6
  %66 = icmp ne i64 %65, 0
  br i1 %66, label %$30, label %$29
$30:
  br label %$28
$29:
  %67 = and i64 %64, 8
  %68 = icmp ne i64 %67, 0
  br i1 %68, label %$32, label %$31
$32:
  %69 = inttoptr i64 %64 to i64*
  %70 = load i64, i64* %69
  br label %$28
$31:
  %71 = call i64 @evList(i64 %64)
  br label %$28
$28:
  %72 = phi i64 [%64, %$30], [%70, %$32], [%71, %$31] ; # ->
; # (save (eval (car X)))
  %73 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %74 = load i64, i64* %73
  %75 = alloca i64, i64 2, align 16
  %76 = ptrtoint i64* %75 to i64
  %77 = inttoptr i64 %76 to i64*
  store i64 %72, i64* %77
  %78 = add i64 %76, 8
  %79 = inttoptr i64 %78 to i64*
  store i64 %74, i64* %79
  %80 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %76, i64* %80
; # (val Y)
  %81 = inttoptr i64 %13 to i64*
  %82 = load i64, i64* %81
; # (cond ((nil? N) N) ((nil? D) D) (T (set Y (adds (needNum Exe N) (...
; # (nil? N)
  %83 = icmp eq i64 %82, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %83, label %$35, label %$34
$35:
  %84 = phi i64 [%62, %$28] ; # X
  br label %$33
$34:
  %85 = phi i64 [%62, %$28] ; # X
; # (nil? D)
  %86 = icmp eq i64 %72, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %86, label %$37, label %$36
$37:
  %87 = phi i64 [%85, %$34] ; # X
  br label %$33
$36:
  %88 = phi i64 [%85, %$34] ; # X
; # (set Y (adds (needNum Exe N) (needNum Exe D)))
; # (needNum Exe N)
  %89 = and i64 %82, 6
  %90 = icmp ne i64 %89, 0
  br i1 %90, label %$39, label %$38
$38:
  call void @numErr(i64 %0, i64 %82)
  unreachable
$39:
; # (needNum Exe D)
  %91 = and i64 %72, 6
  %92 = icmp ne i64 %91, 0
  br i1 %92, label %$41, label %$40
$40:
  call void @numErr(i64 %0, i64 %72)
  unreachable
$41:
; # (adds (needNum Exe N) (needNum Exe D))
  %93 = call i64 @adds(i64 %82, i64 %72)
  %94 = inttoptr i64 %13 to i64*
  store i64 %93, i64* %94
  br label %$33
$33:
  %95 = phi i64 [%84, %$35], [%87, %$37], [%88, %$41] ; # X
  %96 = phi i64 [%82, %$35], [%72, %$37], [%93, %$41] ; # ->
  br label %$22
$22:
  %97 = phi i64 [%60, %$25], [%95, %$33] ; # X
  %98 = phi i64 [%61, %$25], [%96, %$33] ; # ->
; # (drop *Safe)
  %99 = inttoptr i64 %28 to i64*
  %100 = getelementptr i64, i64* %99, i32 1
  %101 = load i64, i64* %100
  %102 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %101, i64* %102
  br label %$2
$2:
  %103 = phi i64 [%15, %$9], [%19, %$11], [%97, %$22] ; # X
  %104 = phi i64 [%13, %$9], [%20, %$11], [%98, %$22] ; # ->
  ret i64 %104
}

define i64 @_Dec(i64) align 8 {
$1:
; # (let X (cdr Exe) (cond ((nil? (eval (car X))) @) ((num? @) (decs ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (cond ((nil? (eval (car X))) @) ((num? @) (decs @)) (T (let Y (sa...
; # (car X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (car X))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$5, label %$4
$5:
  br label %$3
$4:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$7, label %$6
$7:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$3
$6:
  %12 = call i64 @evList(i64 %5)
  br label %$3
$3:
  %13 = phi i64 [%5, %$5], [%11, %$7], [%12, %$6] ; # ->
; # (nil? (eval (car X)))
  %14 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %14, label %$9, label %$8
$9:
  %15 = phi i64 [%3, %$3] ; # X
  br label %$2
$8:
  %16 = phi i64 [%3, %$3] ; # X
; # (num? @)
  %17 = and i64 %13, 6
  %18 = icmp ne i64 %17, 0
  br i1 %18, label %$11, label %$10
$11:
  %19 = phi i64 [%16, %$8] ; # X
; # (decs @)
  %20 = call i64 @decs(i64 %13)
  br label %$2
$10:
  %21 = phi i64 [%16, %$8] ; # X
; # (let Y (save (chkVar Exe @)) (when (and (sym? Y) (sym? (val (tail...
; # (chkVar Exe @)
  %22 = icmp uge i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %22, label %$13, label %$12
$13:
  %23 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %13
  br label %$12
$12:
  %24 = phi i1 [0, %$10], [%23, %$13] ; # ->
  br i1 %24, label %$14, label %$15
$14:
  call void @protErr(i64 %0, i64 %13)
  unreachable
$15:
; # (save (chkVar Exe @))
  %25 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %26 = load i64, i64* %25
  %27 = alloca i64, i64 2, align 16
  %28 = ptrtoint i64* %27 to i64
  %29 = inttoptr i64 %28 to i64*
  store i64 %13, i64* %29
  %30 = add i64 %28, 8
  %31 = inttoptr i64 %30 to i64*
  store i64 %26, i64* %31
  %32 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %28, i64* %32
; # (when (and (sym? Y) (sym? (val (tail Y)))) (dbTouch Exe Y))
; # (and (sym? Y) (sym? (val (tail Y))))
; # (sym? Y)
  %33 = and i64 %13, 8
  %34 = icmp ne i64 %33, 0
  br i1 %34, label %$17, label %$16
$17:
  %35 = phi i64 [%21, %$15] ; # X
; # (tail Y)
  %36 = add i64 %13, -8
; # (val (tail Y))
  %37 = inttoptr i64 %36 to i64*
  %38 = load i64, i64* %37
; # (sym? (val (tail Y)))
  %39 = and i64 %38, 8
  %40 = icmp ne i64 %39, 0
  br label %$16
$16:
  %41 = phi i64 [%21, %$15], [%35, %$17] ; # X
  %42 = phi i1 [0, %$15], [%40, %$17] ; # ->
  br i1 %42, label %$18, label %$19
$18:
  %43 = phi i64 [%41, %$16] ; # X
; # (dbTouch Exe Y)
  call void @dbTouch(i64 %0, i64 %13)
  br label %$19
$19:
  %44 = phi i64 [%41, %$16], [%43, %$18] ; # X
; # (if (atom (shift X)) (if (nil? (val Y)) @ (set Y (decs (needNum E...
; # (shift X)
  %45 = inttoptr i64 %44 to i64*
  %46 = getelementptr i64, i64* %45, i32 1
  %47 = load i64, i64* %46
; # (atom (shift X))
  %48 = and i64 %47, 15
  %49 = icmp ne i64 %48, 0
  br i1 %49, label %$20, label %$21
$20:
  %50 = phi i64 [%47, %$19] ; # X
; # (if (nil? (val Y)) @ (set Y (decs (needNum Exe @))))
; # (val Y)
  %51 = inttoptr i64 %13 to i64*
  %52 = load i64, i64* %51
; # (nil? (val Y))
  %53 = icmp eq i64 %52, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %53, label %$23, label %$24
$23:
  %54 = phi i64 [%50, %$20] ; # X
  br label %$25
$24:
  %55 = phi i64 [%50, %$20] ; # X
; # (set Y (decs (needNum Exe @)))
; # (needNum Exe @)
  %56 = and i64 %52, 6
  %57 = icmp ne i64 %56, 0
  br i1 %57, label %$27, label %$26
$26:
  call void @numErr(i64 %0, i64 %52)
  unreachable
$27:
; # (decs (needNum Exe @))
  %58 = call i64 @decs(i64 %52)
  %59 = inttoptr i64 %13 to i64*
  store i64 %58, i64* %59
  br label %$25
$25:
  %60 = phi i64 [%54, %$23], [%55, %$27] ; # X
  %61 = phi i64 [%52, %$23], [%58, %$27] ; # ->
  br label %$22
$21:
  %62 = phi i64 [%47, %$19] ; # X
; # (let (D (save (eval (car X))) N (val Y)) (cond ((nil? N) N) ((nil...
; # (car X)
  %63 = inttoptr i64 %62 to i64*
  %64 = load i64, i64* %63
; # (eval (car X))
  %65 = and i64 %64, 6
  %66 = icmp ne i64 %65, 0
  br i1 %66, label %$30, label %$29
$30:
  br label %$28
$29:
  %67 = and i64 %64, 8
  %68 = icmp ne i64 %67, 0
  br i1 %68, label %$32, label %$31
$32:
  %69 = inttoptr i64 %64 to i64*
  %70 = load i64, i64* %69
  br label %$28
$31:
  %71 = call i64 @evList(i64 %64)
  br label %$28
$28:
  %72 = phi i64 [%64, %$30], [%70, %$32], [%71, %$31] ; # ->
; # (save (eval (car X)))
  %73 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %74 = load i64, i64* %73
  %75 = alloca i64, i64 2, align 16
  %76 = ptrtoint i64* %75 to i64
  %77 = inttoptr i64 %76 to i64*
  store i64 %72, i64* %77
  %78 = add i64 %76, 8
  %79 = inttoptr i64 %78 to i64*
  store i64 %74, i64* %79
  %80 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %76, i64* %80
; # (val Y)
  %81 = inttoptr i64 %13 to i64*
  %82 = load i64, i64* %81
; # (cond ((nil? N) N) ((nil? D) D) (T (set Y (subs (needNum Exe N) (...
; # (nil? N)
  %83 = icmp eq i64 %82, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %83, label %$35, label %$34
$35:
  %84 = phi i64 [%62, %$28] ; # X
  br label %$33
$34:
  %85 = phi i64 [%62, %$28] ; # X
; # (nil? D)
  %86 = icmp eq i64 %72, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %86, label %$37, label %$36
$37:
  %87 = phi i64 [%85, %$34] ; # X
  br label %$33
$36:
  %88 = phi i64 [%85, %$34] ; # X
; # (set Y (subs (needNum Exe N) (needNum Exe D)))
; # (needNum Exe N)
  %89 = and i64 %82, 6
  %90 = icmp ne i64 %89, 0
  br i1 %90, label %$39, label %$38
$38:
  call void @numErr(i64 %0, i64 %82)
  unreachable
$39:
; # (needNum Exe D)
  %91 = and i64 %72, 6
  %92 = icmp ne i64 %91, 0
  br i1 %92, label %$41, label %$40
$40:
  call void @numErr(i64 %0, i64 %72)
  unreachable
$41:
; # (subs (needNum Exe N) (needNum Exe D))
  %93 = call i64 @subs(i64 %82, i64 %72)
  %94 = inttoptr i64 %13 to i64*
  store i64 %93, i64* %94
  br label %$33
$33:
  %95 = phi i64 [%84, %$35], [%87, %$37], [%88, %$41] ; # X
  %96 = phi i64 [%82, %$35], [%72, %$37], [%93, %$41] ; # ->
  br label %$22
$22:
  %97 = phi i64 [%60, %$25], [%95, %$33] ; # X
  %98 = phi i64 [%61, %$25], [%96, %$33] ; # ->
; # (drop *Safe)
  %99 = inttoptr i64 %28 to i64*
  %100 = getelementptr i64, i64* %99, i32 1
  %101 = load i64, i64* %100
  %102 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %101, i64* %102
  br label %$2
$2:
  %103 = phi i64 [%15, %$9], [%19, %$11], [%97, %$22] ; # X
  %104 = phi i64 [%13, %$9], [%20, %$11], [%98, %$22] ; # ->
  ret i64 %104
}

define i64 @_Mul(i64) align 8 {
$1:
; # (let X (cdr Exe) (if (nil? (eval (car X))) @ (save -ZERO (let (Si...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (if (nil? (eval (car X))) @ (save -ZERO (let (Sign (sign? (needNu...
; # (car X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (car X))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (nil? (eval (car X)))
  %14 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %14, label %$7, label %$8
$7:
  %15 = phi i64 [%3, %$2] ; # X
  br label %$9
$8:
  %16 = phi i64 [%3, %$2] ; # X
; # (save -ZERO (let (Sign (sign? (needNum Exe @)) R (link (push (pos...
  %17 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %18 = load i64, i64* %17
  %19 = alloca i64, i64 2, align 16
  %20 = ptrtoint i64* %19 to i64
  %21 = inttoptr i64 %20 to i64*
  store i64 10, i64* %21
  %22 = add i64 %20, 8
  %23 = inttoptr i64 %22 to i64*
  store i64 %18, i64* %23
  %24 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %20, i64* %24
; # (let (Sign (sign? (needNum Exe @)) R (link (push (pos @) NIL))) (...
; # (needNum Exe @)
  %25 = and i64 %13, 6
  %26 = icmp ne i64 %25, 0
  br i1 %26, label %$11, label %$10
$10:
  call void @numErr(i64 %0, i64 %13)
  unreachable
$11:
; # (sign? (needNum Exe @))
  %27 = and i64 %13, 8
  %28 = icmp ne i64 %27, 0
; # (pos @)
  %29 = and i64 %13, -9
; # (push (pos @) NIL)
  %30 = alloca i64, i64 2, align 16
  %31 = ptrtoint i64* %30 to i64
  %32 = inttoptr i64 %31 to i64*
  store i64 %29, i64* %32
; # (link (push (pos @) NIL))
  %33 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %34 = load i64, i64* %33
  %35 = inttoptr i64 %31 to i64*
  %36 = getelementptr i64, i64* %35, i32 1
  store i64 %34, i64* %36
  %37 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %31, i64* %37
; # (loop (? (atom (shift X)) (let N (val R) (if Sign (neg N) N))) (l...
  br label %$12
$12:
  %38 = phi i64 [%16, %$11], [%94, %$34] ; # X
  %39 = phi i1 [%28, %$11], [%95, %$34] ; # Sign
; # (? (atom (shift X)) (let N (val R) (if Sign (neg N) N)))
; # (shift X)
  %40 = inttoptr i64 %38 to i64*
  %41 = getelementptr i64, i64* %40, i32 1
  %42 = load i64, i64* %41
; # (atom (shift X))
  %43 = and i64 %42, 15
  %44 = icmp ne i64 %43, 0
  br i1 %44, label %$15, label %$13
$15:
  %45 = phi i64 [%42, %$12] ; # X
  %46 = phi i1 [%39, %$12] ; # Sign
; # (let N (val R) (if Sign (neg N) N))
; # (val R)
  %47 = inttoptr i64 %31 to i64*
  %48 = load i64, i64* %47
; # (if Sign (neg N) N)
  br i1 %46, label %$16, label %$17
$16:
  %49 = phi i64 [%45, %$15] ; # X
  %50 = phi i1 [%46, %$15] ; # Sign
; # (neg N)
  %51 = icmp eq i64 %48, 2
  br i1 %51, label %$19, label %$20
$19:
  br label %$21
$20:
  %52 = xor i64 %48, 8
  br label %$21
$21:
  %53 = phi i64 [%48, %$19], [%52, %$20] ; # ->
  br label %$18
$17:
  %54 = phi i64 [%45, %$15] ; # X
  %55 = phi i1 [%46, %$15] ; # Sign
  br label %$18
$18:
  %56 = phi i64 [%49, %$21], [%54, %$17] ; # X
  %57 = phi i1 [%50, %$21], [%55, %$17] ; # Sign
  %58 = phi i64 [%53, %$21], [%48, %$17] ; # ->
  br label %$14
$13:
  %59 = phi i64 [%42, %$12] ; # X
  %60 = phi i1 [%39, %$12] ; # Sign
; # (let N (eval (car X)) (? (nil? N) N) (? (== N ZERO) N) (when (sig...
; # (car X)
  %61 = inttoptr i64 %59 to i64*
  %62 = load i64, i64* %61
; # (eval (car X))
  %63 = and i64 %62, 6
  %64 = icmp ne i64 %63, 0
  br i1 %64, label %$24, label %$23
$24:
  br label %$22
$23:
  %65 = and i64 %62, 8
  %66 = icmp ne i64 %65, 0
  br i1 %66, label %$26, label %$25
$26:
  %67 = inttoptr i64 %62 to i64*
  %68 = load i64, i64* %67
  br label %$22
$25:
  %69 = call i64 @evList(i64 %62)
  br label %$22
$22:
  %70 = phi i64 [%62, %$24], [%68, %$26], [%69, %$25] ; # ->
; # (? (nil? N) N)
; # (nil? N)
  %71 = icmp eq i64 %70, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %71, label %$28, label %$27
$28:
  %72 = phi i64 [%59, %$22] ; # X
  %73 = phi i1 [%60, %$22] ; # Sign
  %74 = phi i64 [%70, %$22] ; # N
  br label %$14
$27:
  %75 = phi i64 [%59, %$22] ; # X
  %76 = phi i1 [%60, %$22] ; # Sign
  %77 = phi i64 [%70, %$22] ; # N
; # (? (== N ZERO) N)
; # (== N ZERO)
  %78 = icmp eq i64 %77, 2
  br i1 %78, label %$30, label %$29
$30:
  %79 = phi i64 [%75, %$27] ; # X
  %80 = phi i1 [%76, %$27] ; # Sign
  %81 = phi i64 [%77, %$27] ; # N
  br label %$14
$29:
  %82 = phi i64 [%75, %$27] ; # X
  %83 = phi i1 [%76, %$27] ; # Sign
  %84 = phi i64 [%77, %$27] ; # N
; # (when (sign? (needNum Exe N)) (setq Sign (not Sign) N (pos N)))
; # (needNum Exe N)
  %85 = and i64 %84, 6
  %86 = icmp ne i64 %85, 0
  br i1 %86, label %$32, label %$31
$31:
  call void @numErr(i64 %0, i64 %84)
  unreachable
$32:
; # (sign? (needNum Exe N))
  %87 = and i64 %84, 8
  %88 = icmp ne i64 %87, 0
  br i1 %88, label %$33, label %$34
$33:
  %89 = phi i64 [%82, %$32] ; # X
  %90 = phi i1 [%83, %$32] ; # Sign
  %91 = phi i64 [%84, %$32] ; # N
; # (not Sign)
  %92 = icmp eq i1 %90, 0
; # (pos N)
  %93 = and i64 %91, -9
  br label %$34
$34:
  %94 = phi i64 [%82, %$32], [%89, %$33] ; # X
  %95 = phi i1 [%83, %$32], [%92, %$33] ; # Sign
  %96 = phi i64 [%84, %$32], [%93, %$33] ; # N
; # (safe N)
  %97 = inttoptr i64 %20 to i64*
  store i64 %96, i64* %97
; # (set R (mulu (val R) N))
; # (val R)
  %98 = inttoptr i64 %31 to i64*
  %99 = load i64, i64* %98
; # (mulu (val R) N)
  %100 = call i64 @mulu(i64 %99, i64 %96)
  %101 = inttoptr i64 %31 to i64*
  store i64 %100, i64* %101
  br label %$12
$14:
  %102 = phi i64 [%56, %$18], [%72, %$28], [%79, %$30] ; # X
  %103 = phi i1 [%57, %$18], [%73, %$28], [%80, %$30] ; # Sign
  %104 = phi i64 [%58, %$18], [%74, %$28], [%81, %$30] ; # ->
; # drop
  %105 = inttoptr i64 %20 to i64*
  %106 = getelementptr i64, i64* %105, i32 1
  %107 = load i64, i64* %106
  %108 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %107, i64* %108
  br label %$9
$9:
  %109 = phi i64 [%15, %$7], [%102, %$14] ; # X
  %110 = phi i64 [%13, %$7], [%104, %$14] ; # ->
  ret i64 %110
}

define i64 @_MulDiv(i64) align 8 {
$1:
; # (let X (cdr Exe) (if (nil? (eval (car X))) @ (save -ZERO (let (Si...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (if (nil? (eval (car X))) @ (save -ZERO (let (Sign (sign? (needNu...
; # (car X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (car X))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (nil? (eval (car X)))
  %14 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %14, label %$7, label %$8
$7:
  %15 = phi i64 [%3, %$2] ; # X
  br label %$9
$8:
  %16 = phi i64 [%3, %$2] ; # X
; # (save -ZERO (let (Sign (sign? (needNum Exe @)) R (link (push (pos...
  %17 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %18 = load i64, i64* %17
  %19 = alloca i64, i64 2, align 16
  %20 = ptrtoint i64* %19 to i64
  %21 = inttoptr i64 %20 to i64*
  store i64 10, i64* %21
  %22 = add i64 %20, 8
  %23 = inttoptr i64 %22 to i64*
  store i64 %18, i64* %23
  %24 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %20, i64* %24
; # (let (Sign (sign? (needNum Exe @)) R (link (push (pos @) NIL))) (...
; # (needNum Exe @)
  %25 = and i64 %13, 6
  %26 = icmp ne i64 %25, 0
  br i1 %26, label %$11, label %$10
$10:
  call void @numErr(i64 %0, i64 %13)
  unreachable
$11:
; # (sign? (needNum Exe @))
  %27 = and i64 %13, 8
  %28 = icmp ne i64 %27, 0
; # (pos @)
  %29 = and i64 %13, -9
; # (push (pos @) NIL)
  %30 = alloca i64, i64 2, align 16
  %31 = ptrtoint i64* %30 to i64
  %32 = inttoptr i64 %31 to i64*
  store i64 %29, i64* %32
; # (link (push (pos @) NIL))
  %33 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %34 = load i64, i64* %33
  %35 = inttoptr i64 %31 to i64*
  %36 = getelementptr i64, i64* %35, i32 1
  store i64 %34, i64* %36
  %37 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %31, i64* %37
; # (shift X)
  %38 = inttoptr i64 %16 to i64*
  %39 = getelementptr i64, i64* %38, i32 1
  %40 = load i64, i64* %39
; # (loop (let N (eval (car X)) (? (nil? N) N) (when (sign? (needNum ...
  br label %$12
$12:
  %41 = phi i64 [%40, %$11], [%122, %$35] ; # X
  %42 = phi i1 [%28, %$11], [%123, %$35] ; # Sign
; # (let N (eval (car X)) (? (nil? N) N) (when (sign? (needNum Exe N)...
; # (car X)
  %43 = inttoptr i64 %41 to i64*
  %44 = load i64, i64* %43
; # (eval (car X))
  %45 = and i64 %44, 6
  %46 = icmp ne i64 %45, 0
  br i1 %46, label %$15, label %$14
$15:
  br label %$13
$14:
  %47 = and i64 %44, 8
  %48 = icmp ne i64 %47, 0
  br i1 %48, label %$17, label %$16
$17:
  %49 = inttoptr i64 %44 to i64*
  %50 = load i64, i64* %49
  br label %$13
$16:
  %51 = call i64 @evList(i64 %44)
  br label %$13
$13:
  %52 = phi i64 [%44, %$15], [%50, %$17], [%51, %$16] ; # ->
; # (? (nil? N) N)
; # (nil? N)
  %53 = icmp eq i64 %52, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %53, label %$20, label %$18
$20:
  %54 = phi i64 [%41, %$13] ; # X
  %55 = phi i1 [%42, %$13] ; # Sign
  %56 = phi i64 [%52, %$13] ; # N
  br label %$19
$18:
  %57 = phi i64 [%41, %$13] ; # X
  %58 = phi i1 [%42, %$13] ; # Sign
  %59 = phi i64 [%52, %$13] ; # N
; # (when (sign? (needNum Exe N)) (setq Sign (not Sign) N (pos N)))
; # (needNum Exe N)
  %60 = and i64 %59, 6
  %61 = icmp ne i64 %60, 0
  br i1 %61, label %$22, label %$21
$21:
  call void @numErr(i64 %0, i64 %59)
  unreachable
$22:
; # (sign? (needNum Exe N))
  %62 = and i64 %59, 8
  %63 = icmp ne i64 %62, 0
  br i1 %63, label %$23, label %$24
$23:
  %64 = phi i64 [%57, %$22] ; # X
  %65 = phi i1 [%58, %$22] ; # Sign
  %66 = phi i64 [%59, %$22] ; # N
; # (not Sign)
  %67 = icmp eq i1 %65, 0
; # (pos N)
  %68 = and i64 %66, -9
  br label %$24
$24:
  %69 = phi i64 [%57, %$22], [%64, %$23] ; # X
  %70 = phi i1 [%58, %$22], [%67, %$23] ; # Sign
  %71 = phi i64 [%59, %$22], [%68, %$23] ; # N
; # (safe N)
  %72 = inttoptr i64 %20 to i64*
  store i64 %71, i64* %72
; # (? (atom (shift X)) (when (== N ZERO) (divErr Exe)) (let Half (sa...
; # (shift X)
  %73 = inttoptr i64 %69 to i64*
  %74 = getelementptr i64, i64* %73, i32 1
  %75 = load i64, i64* %74
; # (atom (shift X))
  %76 = and i64 %75, 15
  %77 = icmp ne i64 %76, 0
  br i1 %77, label %$26, label %$25
$26:
  %78 = phi i64 [%75, %$24] ; # X
  %79 = phi i1 [%70, %$24] ; # Sign
  %80 = phi i64 [%71, %$24] ; # N
; # (when (== N ZERO) (divErr Exe))
; # (== N ZERO)
  %81 = icmp eq i64 %80, 2
  br i1 %81, label %$27, label %$28
$27:
  %82 = phi i64 [%78, %$26] ; # X
  %83 = phi i1 [%79, %$26] ; # Sign
  %84 = phi i64 [%80, %$26] ; # N
; # (divErr Exe)
  call void @divErr(i64 %0)
  unreachable
$28:
  %85 = phi i64 [%78, %$26] ; # X
  %86 = phi i1 [%79, %$26] ; # Sign
  %87 = phi i64 [%80, %$26] ; # N
; # (let Half (save (shru N)) (setq N (divu (set R (addu (val R) Half...
; # (shru N)
  %88 = call i64 @shru(i64 %87)
; # (save (shru N))
  %89 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %90 = load i64, i64* %89
  %91 = alloca i64, i64 2, align 16
  %92 = ptrtoint i64* %91 to i64
  %93 = inttoptr i64 %92 to i64*
  store i64 %88, i64* %93
  %94 = add i64 %92, 8
  %95 = inttoptr i64 %94 to i64*
  store i64 %90, i64* %95
  %96 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %92, i64* %96
; # (set R (addu (val R) Half))
; # (val R)
  %97 = inttoptr i64 %31 to i64*
  %98 = load i64, i64* %97
; # (addu (val R) Half)
  %99 = call i64 @addu(i64 %98, i64 %88)
  %100 = inttoptr i64 %31 to i64*
  store i64 %99, i64* %100
; # (divu (set R (addu (val R) Half)) N)
  %101 = call i64 @divu(i64 %99, i64 %87)
; # (if Sign (neg N) N)
  br i1 %86, label %$29, label %$30
$29:
  %102 = phi i64 [%85, %$28] ; # X
  %103 = phi i1 [%86, %$28] ; # Sign
  %104 = phi i64 [%101, %$28] ; # N
; # (neg N)
  %105 = icmp eq i64 %104, 2
  br i1 %105, label %$32, label %$33
$32:
  br label %$34
$33:
  %106 = xor i64 %104, 8
  br label %$34
$34:
  %107 = phi i64 [%104, %$32], [%106, %$33] ; # ->
  br label %$31
$30:
  %108 = phi i64 [%85, %$28] ; # X
  %109 = phi i1 [%86, %$28] ; # Sign
  %110 = phi i64 [%101, %$28] ; # N
  br label %$31
$31:
  %111 = phi i64 [%102, %$34], [%108, %$30] ; # X
  %112 = phi i1 [%103, %$34], [%109, %$30] ; # Sign
  %113 = phi i64 [%104, %$34], [%110, %$30] ; # N
  %114 = phi i64 [%107, %$34], [%110, %$30] ; # ->
  br label %$19
$25:
  %115 = phi i64 [%75, %$24] ; # X
  %116 = phi i1 [%70, %$24] ; # Sign
  %117 = phi i64 [%71, %$24] ; # N
; # (? (== N ZERO) N)
; # (== N ZERO)
  %118 = icmp eq i64 %117, 2
  br i1 %118, label %$36, label %$35
$36:
  %119 = phi i64 [%115, %$25] ; # X
  %120 = phi i1 [%116, %$25] ; # Sign
  %121 = phi i64 [%117, %$25] ; # N
  br label %$19
$35:
  %122 = phi i64 [%115, %$25] ; # X
  %123 = phi i1 [%116, %$25] ; # Sign
  %124 = phi i64 [%117, %$25] ; # N
; # (set R (mulu (val R) N))
; # (val R)
  %125 = inttoptr i64 %31 to i64*
  %126 = load i64, i64* %125
; # (mulu (val R) N)
  %127 = call i64 @mulu(i64 %126, i64 %124)
  %128 = inttoptr i64 %31 to i64*
  store i64 %127, i64* %128
  br label %$12
$19:
  %129 = phi i64 [%54, %$20], [%111, %$31], [%119, %$36] ; # X
  %130 = phi i1 [%55, %$20], [%112, %$31], [%120, %$36] ; # Sign
  %131 = phi i64 [%56, %$20], [%114, %$31], [%121, %$36] ; # ->
; # drop
  %132 = inttoptr i64 %20 to i64*
  %133 = getelementptr i64, i64* %132, i32 1
  %134 = load i64, i64* %133
  %135 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %134, i64* %135
  br label %$9
$9:
  %136 = phi i64 [%15, %$7], [%129, %$19] ; # X
  %137 = phi i64 [%13, %$7], [%131, %$19] ; # ->
  ret i64 %137
}

define i64 @_Div(i64) align 8 {
$1:
; # (let X (cdr Exe) (if (nil? (eval (car X))) @ (save -ZERO (let (Si...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (if (nil? (eval (car X))) @ (save -ZERO (let (Sign (sign? (needNu...
; # (car X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (car X))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (nil? (eval (car X)))
  %14 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %14, label %$7, label %$8
$7:
  %15 = phi i64 [%3, %$2] ; # X
  br label %$9
$8:
  %16 = phi i64 [%3, %$2] ; # X
; # (save -ZERO (let (Sign (sign? (needNum Exe @)) R (link (push (pos...
  %17 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %18 = load i64, i64* %17
  %19 = alloca i64, i64 2, align 16
  %20 = ptrtoint i64* %19 to i64
  %21 = inttoptr i64 %20 to i64*
  store i64 10, i64* %21
  %22 = add i64 %20, 8
  %23 = inttoptr i64 %22 to i64*
  store i64 %18, i64* %23
  %24 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %20, i64* %24
; # (let (Sign (sign? (needNum Exe @)) R (link (push (pos @) NIL))) (...
; # (needNum Exe @)
  %25 = and i64 %13, 6
  %26 = icmp ne i64 %25, 0
  br i1 %26, label %$11, label %$10
$10:
  call void @numErr(i64 %0, i64 %13)
  unreachable
$11:
; # (sign? (needNum Exe @))
  %27 = and i64 %13, 8
  %28 = icmp ne i64 %27, 0
; # (pos @)
  %29 = and i64 %13, -9
; # (push (pos @) NIL)
  %30 = alloca i64, i64 2, align 16
  %31 = ptrtoint i64* %30 to i64
  %32 = inttoptr i64 %31 to i64*
  store i64 %29, i64* %32
; # (link (push (pos @) NIL))
  %33 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %34 = load i64, i64* %33
  %35 = inttoptr i64 %31 to i64*
  %36 = getelementptr i64, i64* %35, i32 1
  store i64 %34, i64* %36
  %37 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %31, i64* %37
; # (loop (? (atom (shift X)) (let N (val R) (if Sign (neg N) N))) (l...
  br label %$12
$12:
  %38 = phi i64 [%16, %$11], [%94, %$34] ; # X
  %39 = phi i1 [%28, %$11], [%95, %$34] ; # Sign
; # (? (atom (shift X)) (let N (val R) (if Sign (neg N) N)))
; # (shift X)
  %40 = inttoptr i64 %38 to i64*
  %41 = getelementptr i64, i64* %40, i32 1
  %42 = load i64, i64* %41
; # (atom (shift X))
  %43 = and i64 %42, 15
  %44 = icmp ne i64 %43, 0
  br i1 %44, label %$15, label %$13
$15:
  %45 = phi i64 [%42, %$12] ; # X
  %46 = phi i1 [%39, %$12] ; # Sign
; # (let N (val R) (if Sign (neg N) N))
; # (val R)
  %47 = inttoptr i64 %31 to i64*
  %48 = load i64, i64* %47
; # (if Sign (neg N) N)
  br i1 %46, label %$16, label %$17
$16:
  %49 = phi i64 [%45, %$15] ; # X
  %50 = phi i1 [%46, %$15] ; # Sign
; # (neg N)
  %51 = icmp eq i64 %48, 2
  br i1 %51, label %$19, label %$20
$19:
  br label %$21
$20:
  %52 = xor i64 %48, 8
  br label %$21
$21:
  %53 = phi i64 [%48, %$19], [%52, %$20] ; # ->
  br label %$18
$17:
  %54 = phi i64 [%45, %$15] ; # X
  %55 = phi i1 [%46, %$15] ; # Sign
  br label %$18
$18:
  %56 = phi i64 [%49, %$21], [%54, %$17] ; # X
  %57 = phi i1 [%50, %$21], [%55, %$17] ; # Sign
  %58 = phi i64 [%53, %$21], [%48, %$17] ; # ->
  br label %$14
$13:
  %59 = phi i64 [%42, %$12] ; # X
  %60 = phi i1 [%39, %$12] ; # Sign
; # (let N (eval (car X)) (? (nil? N) N) (when (== N ZERO) (divErr Ex...
; # (car X)
  %61 = inttoptr i64 %59 to i64*
  %62 = load i64, i64* %61
; # (eval (car X))
  %63 = and i64 %62, 6
  %64 = icmp ne i64 %63, 0
  br i1 %64, label %$24, label %$23
$24:
  br label %$22
$23:
  %65 = and i64 %62, 8
  %66 = icmp ne i64 %65, 0
  br i1 %66, label %$26, label %$25
$26:
  %67 = inttoptr i64 %62 to i64*
  %68 = load i64, i64* %67
  br label %$22
$25:
  %69 = call i64 @evList(i64 %62)
  br label %$22
$22:
  %70 = phi i64 [%62, %$24], [%68, %$26], [%69, %$25] ; # ->
; # (? (nil? N) N)
; # (nil? N)
  %71 = icmp eq i64 %70, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %71, label %$28, label %$27
$28:
  %72 = phi i64 [%59, %$22] ; # X
  %73 = phi i1 [%60, %$22] ; # Sign
  %74 = phi i64 [%70, %$22] ; # N
  br label %$14
$27:
  %75 = phi i64 [%59, %$22] ; # X
  %76 = phi i1 [%60, %$22] ; # Sign
  %77 = phi i64 [%70, %$22] ; # N
; # (when (== N ZERO) (divErr Exe))
; # (== N ZERO)
  %78 = icmp eq i64 %77, 2
  br i1 %78, label %$29, label %$30
$29:
  %79 = phi i64 [%75, %$27] ; # X
  %80 = phi i1 [%76, %$27] ; # Sign
  %81 = phi i64 [%77, %$27] ; # N
; # (divErr Exe)
  call void @divErr(i64 %0)
  unreachable
$30:
  %82 = phi i64 [%75, %$27] ; # X
  %83 = phi i1 [%76, %$27] ; # Sign
  %84 = phi i64 [%77, %$27] ; # N
; # (when (sign? (needNum Exe N)) (setq Sign (not Sign) N (pos N)))
; # (needNum Exe N)
  %85 = and i64 %84, 6
  %86 = icmp ne i64 %85, 0
  br i1 %86, label %$32, label %$31
$31:
  call void @numErr(i64 %0, i64 %84)
  unreachable
$32:
; # (sign? (needNum Exe N))
  %87 = and i64 %84, 8
  %88 = icmp ne i64 %87, 0
  br i1 %88, label %$33, label %$34
$33:
  %89 = phi i64 [%82, %$32] ; # X
  %90 = phi i1 [%83, %$32] ; # Sign
  %91 = phi i64 [%84, %$32] ; # N
; # (not Sign)
  %92 = icmp eq i1 %90, 0
; # (pos N)
  %93 = and i64 %91, -9
  br label %$34
$34:
  %94 = phi i64 [%82, %$32], [%89, %$33] ; # X
  %95 = phi i1 [%83, %$32], [%92, %$33] ; # Sign
  %96 = phi i64 [%84, %$32], [%93, %$33] ; # N
; # (safe N)
  %97 = inttoptr i64 %20 to i64*
  store i64 %96, i64* %97
; # (set R (divu (val R) N))
; # (val R)
  %98 = inttoptr i64 %31 to i64*
  %99 = load i64, i64* %98
; # (divu (val R) N)
  %100 = call i64 @divu(i64 %99, i64 %96)
  %101 = inttoptr i64 %31 to i64*
  store i64 %100, i64* %101
  br label %$12
$14:
  %102 = phi i64 [%56, %$18], [%72, %$28] ; # X
  %103 = phi i1 [%57, %$18], [%73, %$28] ; # Sign
  %104 = phi i64 [%58, %$18], [%74, %$28] ; # ->
; # drop
  %105 = inttoptr i64 %20 to i64*
  %106 = getelementptr i64, i64* %105, i32 1
  %107 = load i64, i64* %106
  %108 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %107, i64* %108
  br label %$9
$9:
  %109 = phi i64 [%15, %$7], [%102, %$14] ; # X
  %110 = phi i64 [%13, %$7], [%104, %$14] ; # ->
  ret i64 %110
}

define i64 @_Rem(i64) align 8 {
$1:
; # (let X (cdr Exe) (if (nil? (eval (car X))) @ (save -ZERO (let (Si...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (if (nil? (eval (car X))) @ (save -ZERO (let (Sign (sign? (needNu...
; # (car X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (car X))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (nil? (eval (car X)))
  %14 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %14, label %$7, label %$8
$7:
  %15 = phi i64 [%3, %$2] ; # X
  br label %$9
$8:
  %16 = phi i64 [%3, %$2] ; # X
; # (save -ZERO (let (Sign (sign? (needNum Exe @)) R (link (push (pos...
  %17 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %18 = load i64, i64* %17
  %19 = alloca i64, i64 2, align 16
  %20 = ptrtoint i64* %19 to i64
  %21 = inttoptr i64 %20 to i64*
  store i64 10, i64* %21
  %22 = add i64 %20, 8
  %23 = inttoptr i64 %22 to i64*
  store i64 %18, i64* %23
  %24 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %20, i64* %24
; # (let (Sign (sign? (needNum Exe @)) R (link (push (pos @) NIL))) (...
; # (needNum Exe @)
  %25 = and i64 %13, 6
  %26 = icmp ne i64 %25, 0
  br i1 %26, label %$11, label %$10
$10:
  call void @numErr(i64 %0, i64 %13)
  unreachable
$11:
; # (sign? (needNum Exe @))
  %27 = and i64 %13, 8
  %28 = icmp ne i64 %27, 0
; # (pos @)
  %29 = and i64 %13, -9
; # (push (pos @) NIL)
  %30 = alloca i64, i64 2, align 16
  %31 = ptrtoint i64* %30 to i64
  %32 = inttoptr i64 %31 to i64*
  store i64 %29, i64* %32
; # (link (push (pos @) NIL))
  %33 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %34 = load i64, i64* %33
  %35 = inttoptr i64 %31 to i64*
  %36 = getelementptr i64, i64* %35, i32 1
  store i64 %34, i64* %36
  %37 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %31, i64* %37
; # (loop (? (atom (shift X)) (let N (val R) (if Sign (neg N) N))) (l...
  br label %$12
$12:
  %38 = phi i64 [%16, %$11], [%70, %$32] ; # X
; # (? (atom (shift X)) (let N (val R) (if Sign (neg N) N)))
; # (shift X)
  %39 = inttoptr i64 %38 to i64*
  %40 = getelementptr i64, i64* %39, i32 1
  %41 = load i64, i64* %40
; # (atom (shift X))
  %42 = and i64 %41, 15
  %43 = icmp ne i64 %42, 0
  br i1 %43, label %$15, label %$13
$15:
  %44 = phi i64 [%41, %$12] ; # X
; # (let N (val R) (if Sign (neg N) N))
; # (val R)
  %45 = inttoptr i64 %31 to i64*
  %46 = load i64, i64* %45
; # (if Sign (neg N) N)
  br i1 %28, label %$16, label %$17
$16:
  %47 = phi i64 [%44, %$15] ; # X
; # (neg N)
  %48 = icmp eq i64 %46, 2
  br i1 %48, label %$19, label %$20
$19:
  br label %$21
$20:
  %49 = xor i64 %46, 8
  br label %$21
$21:
  %50 = phi i64 [%46, %$19], [%49, %$20] ; # ->
  br label %$18
$17:
  %51 = phi i64 [%44, %$15] ; # X
  br label %$18
$18:
  %52 = phi i64 [%47, %$21], [%51, %$17] ; # X
  %53 = phi i64 [%50, %$21], [%46, %$17] ; # ->
  br label %$14
$13:
  %54 = phi i64 [%41, %$12] ; # X
; # (let N (eval (car X)) (? (nil? N) N) (when (== N ZERO) (divErr Ex...
; # (car X)
  %55 = inttoptr i64 %54 to i64*
  %56 = load i64, i64* %55
; # (eval (car X))
  %57 = and i64 %56, 6
  %58 = icmp ne i64 %57, 0
  br i1 %58, label %$24, label %$23
$24:
  br label %$22
$23:
  %59 = and i64 %56, 8
  %60 = icmp ne i64 %59, 0
  br i1 %60, label %$26, label %$25
$26:
  %61 = inttoptr i64 %56 to i64*
  %62 = load i64, i64* %61
  br label %$22
$25:
  %63 = call i64 @evList(i64 %56)
  br label %$22
$22:
  %64 = phi i64 [%56, %$24], [%62, %$26], [%63, %$25] ; # ->
; # (? (nil? N) N)
; # (nil? N)
  %65 = icmp eq i64 %64, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %65, label %$28, label %$27
$28:
  %66 = phi i64 [%54, %$22] ; # X
  br label %$14
$27:
  %67 = phi i64 [%54, %$22] ; # X
; # (when (== N ZERO) (divErr Exe))
; # (== N ZERO)
  %68 = icmp eq i64 %64, 2
  br i1 %68, label %$29, label %$30
$29:
  %69 = phi i64 [%67, %$27] ; # X
; # (divErr Exe)
  call void @divErr(i64 %0)
  unreachable
$30:
  %70 = phi i64 [%67, %$27] ; # X
; # (set R (remu (val R) (safe (pos (needNum Exe N)))))
; # (val R)
  %71 = inttoptr i64 %31 to i64*
  %72 = load i64, i64* %71
; # (needNum Exe N)
  %73 = and i64 %64, 6
  %74 = icmp ne i64 %73, 0
  br i1 %74, label %$32, label %$31
$31:
  call void @numErr(i64 %0, i64 %64)
  unreachable
$32:
; # (pos (needNum Exe N))
  %75 = and i64 %64, -9
; # (safe (pos (needNum Exe N)))
  %76 = inttoptr i64 %20 to i64*
  store i64 %75, i64* %76
; # (remu (val R) (safe (pos (needNum Exe N))))
  %77 = call i64 @remu(i64 %72, i64 %75)
  %78 = inttoptr i64 %31 to i64*
  store i64 %77, i64* %78
  br label %$12
$14:
  %79 = phi i64 [%52, %$18], [%66, %$28] ; # X
  %80 = phi i64 [%53, %$18], [%64, %$28] ; # ->
; # drop
  %81 = inttoptr i64 %20 to i64*
  %82 = getelementptr i64, i64* %81, i32 1
  %83 = load i64, i64* %82
  %84 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %83, i64* %84
  br label %$9
$9:
  %85 = phi i64 [%15, %$7], [%79, %$14] ; # X
  %86 = phi i64 [%13, %$7], [%80, %$14] ; # ->
  ret i64 %86
}

define i64 @_Shr(i64) align 8 {
$1:
; # (let (X (cdr Exe) N (evCnt Exe X) Y (eval (cadr X))) (if (or (=0 ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (evCnt Exe X)
  %4 = call i64 @evCnt(i64 %0, i64 %3)
; # (cadr X)
  %5 = inttoptr i64 %3 to i64*
  %6 = getelementptr i64, i64* %5, i32 1
  %7 = load i64, i64* %6
  %8 = inttoptr i64 %7 to i64*
  %9 = load i64, i64* %8
; # (eval (cadr X))
  %10 = and i64 %9, 6
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$4, label %$3
$4:
  br label %$2
$3:
  %12 = and i64 %9, 8
  %13 = icmp ne i64 %12, 0
  br i1 %13, label %$6, label %$5
$6:
  %14 = inttoptr i64 %9 to i64*
  %15 = load i64, i64* %14
  br label %$2
$5:
  %16 = call i64 @evList(i64 %9)
  br label %$2
$2:
  %17 = phi i64 [%9, %$4], [%15, %$6], [%16, %$5] ; # ->
; # (if (or (=0 N) (nil? Y) (== ZERO (needNum Exe Y))) Y (let Sign (s...
; # (or (=0 N) (nil? Y) (== ZERO (needNum Exe Y)))
; # (=0 N)
  %18 = icmp eq i64 %4, 0
  br i1 %18, label %$7, label %$8
$8:
  %19 = phi i64 [%4, %$2] ; # N
  %20 = phi i64 [%17, %$2] ; # Y
; # (nil? Y)
  %21 = icmp eq i64 %20, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %21, label %$7, label %$9
$9:
  %22 = phi i64 [%19, %$8] ; # N
  %23 = phi i64 [%20, %$8] ; # Y
; # (needNum Exe Y)
  %24 = and i64 %23, 6
  %25 = icmp ne i64 %24, 0
  br i1 %25, label %$11, label %$10
$10:
  call void @numErr(i64 %0, i64 %23)
  unreachable
$11:
; # (== ZERO (needNum Exe Y))
  %26 = icmp eq i64 2, %23
  br label %$7
$7:
  %27 = phi i64 [%4, %$2], [%19, %$8], [%22, %$11] ; # N
  %28 = phi i64 [%17, %$2], [%20, %$8], [%23, %$11] ; # Y
  %29 = phi i1 [1, %$2], [1, %$8], [%26, %$11] ; # ->
  br i1 %29, label %$12, label %$13
$12:
  %30 = phi i64 [%27, %$7] ; # N
  %31 = phi i64 [%28, %$7] ; # Y
  br label %$14
$13:
  %32 = phi i64 [%27, %$7] ; # N
  %33 = phi i64 [%28, %$7] ; # Y
; # (let Sign (sign? Y) (setq Y (save (pos Y))) (cond ((gt0 N) (while...
; # (sign? Y)
  %34 = and i64 %33, 8
  %35 = icmp ne i64 %34, 0
; # (pos Y)
  %36 = and i64 %33, -9
; # (save (pos Y))
  %37 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %38 = load i64, i64* %37
  %39 = alloca i64, i64 2, align 16
  %40 = ptrtoint i64* %39 to i64
  %41 = inttoptr i64 %40 to i64*
  store i64 %36, i64* %41
  %42 = add i64 %40, 8
  %43 = inttoptr i64 %42 to i64*
  store i64 %38, i64* %43
  %44 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %40, i64* %44
; # (cond ((gt0 N) (while (and (big? Y) (>= N 64)) (setq Y (val (big ...
; # (gt0 N)
  %45 = icmp sgt i64 %32, 0
  br i1 %45, label %$17, label %$16
$17:
  %46 = phi i64 [%32, %$13] ; # N
  %47 = phi i64 [%36, %$13] ; # Y
; # (while (and (big? Y) (>= N 64)) (setq Y (val (big Y))) (unless (d...
  br label %$18
$18:
  %48 = phi i64 [%46, %$17], [%67, %$24] ; # N
  %49 = phi i64 [%47, %$17], [%68, %$24] ; # Y
; # (and (big? Y) (>= N 64))
; # (big? Y)
  %50 = and i64 %49, 4
  %51 = icmp ne i64 %50, 0
  br i1 %51, label %$20, label %$19
$20:
  %52 = phi i64 [%48, %$18] ; # N
  %53 = phi i64 [%49, %$18] ; # Y
; # (>= N 64)
  %54 = icmp uge i64 %52, 64
  br label %$19
$19:
  %55 = phi i64 [%48, %$18], [%52, %$20] ; # N
  %56 = phi i64 [%49, %$18], [%53, %$20] ; # Y
  %57 = phi i1 [0, %$18], [%54, %$20] ; # ->
  br i1 %57, label %$21, label %$22
$21:
  %58 = phi i64 [%55, %$19] ; # N
  %59 = phi i64 [%56, %$19] ; # Y
; # (big Y)
  %60 = add i64 %59, 4
; # (val (big Y))
  %61 = inttoptr i64 %60 to i64*
  %62 = load i64, i64* %61
; # (unless (dec 'N 64) (goto 9))
; # (dec 'N 64)
  %63 = sub i64 %58, 64
  %64 = icmp ne i64 %63, 0
  br i1 %64, label %$24, label %$23
$23:
  %65 = phi i64 [%63, %$21] ; # N
  %66 = phi i64 [%62, %$21] ; # Y
; # (goto 9)
  br label %$-9
$24:
  %67 = phi i64 [%63, %$21] ; # N
  %68 = phi i64 [%62, %$21] ; # Y
  br label %$18
$22:
  %69 = phi i64 [%55, %$19] ; # N
  %70 = phi i64 [%56, %$19] ; # Y
; # (shru Y)
  %71 = call i64 @shru(i64 %70)
; # (safe (shru Y))
  %72 = inttoptr i64 %40 to i64*
  store i64 %71, i64* %72
; # (while (dec 'N) (setq Y (half Y)))
  br label %$25
$25:
  %73 = phi i64 [%69, %$22], [%77, %$26] ; # N
  %74 = phi i64 [%71, %$22], [%79, %$26] ; # Y
; # (dec 'N)
  %75 = sub i64 %73, 1
  %76 = icmp ne i64 %75, 0
  br i1 %76, label %$26, label %$27
$26:
  %77 = phi i64 [%75, %$25] ; # N
  %78 = phi i64 [%74, %$25] ; # Y
; # (half Y)
  %79 = call i64 @half(i64 %78)
  br label %$25
$27:
  %80 = phi i64 [%75, %$25] ; # N
  %81 = phi i64 [%74, %$25] ; # Y
  br label %$15
$16:
  %82 = phi i64 [%32, %$13] ; # N
  %83 = phi i64 [%36, %$13] ; # Y
; # (while (>= -64 N) (setq Y (safe (consNum 0 Y))) (unless (inc 'N 6...
  br label %$28
$28:
  %84 = phi i64 [%82, %$16], [%95, %$32] ; # N
  %85 = phi i64 [%83, %$16], [%96, %$32] ; # Y
; # (>= -64 N)
  %86 = icmp uge i64 -64, %84
  br i1 %86, label %$29, label %$30
$29:
  %87 = phi i64 [%84, %$28] ; # N
  %88 = phi i64 [%85, %$28] ; # Y
; # (consNum 0 Y)
  %89 = call i64 @consNum(i64 0, i64 %88)
; # (safe (consNum 0 Y))
  %90 = inttoptr i64 %40 to i64*
  store i64 %89, i64* %90
; # (unless (inc 'N 64) (goto 9))
; # (inc 'N 64)
  %91 = add i64 %87, 64
  %92 = icmp ne i64 %91, 0
  br i1 %92, label %$32, label %$31
$31:
  %93 = phi i64 [%91, %$29] ; # N
  %94 = phi i64 [%89, %$29] ; # Y
; # (goto 9)
  br label %$-9
$32:
  %95 = phi i64 [%91, %$29] ; # N
  %96 = phi i64 [%89, %$29] ; # Y
  br label %$28
$30:
  %97 = phi i64 [%84, %$28] ; # N
  %98 = phi i64 [%85, %$28] ; # Y
; # (shlu Y)
  %99 = call i64 @shlu(i64 %98)
; # (safe (shlu Y))
  %100 = inttoptr i64 %40 to i64*
  store i64 %99, i64* %100
; # (while (inc 'N) (setq Y (safe (twice Y))))
  br label %$33
$33:
  %101 = phi i64 [%97, %$30], [%105, %$34] ; # N
  %102 = phi i64 [%99, %$30], [%107, %$34] ; # Y
; # (inc 'N)
  %103 = add i64 %101, 1
  %104 = icmp ne i64 %103, 0
  br i1 %104, label %$34, label %$35
$34:
  %105 = phi i64 [%103, %$33] ; # N
  %106 = phi i64 [%102, %$33] ; # Y
; # (twice Y)
  %107 = call i64 @twice(i64 %106)
; # (safe (twice Y))
  %108 = inttoptr i64 %40 to i64*
  store i64 %107, i64* %108
  br label %$33
$35:
  %109 = phi i64 [%103, %$33] ; # N
  %110 = phi i64 [%102, %$33] ; # Y
  br label %$15
$15:
  %111 = phi i64 [%80, %$27], [%109, %$35] ; # N
  %112 = phi i64 [%81, %$27], [%110, %$35] ; # Y
; # (: 9 (if Sign (neg Y) Y))
  br label %$-9
$-9:
  %113 = phi i64 [%65, %$23], [%93, %$31], [%111, %$15] ; # N
  %114 = phi i64 [%66, %$23], [%94, %$31], [%112, %$15] ; # Y
; # (if Sign (neg Y) Y)
  br i1 %35, label %$36, label %$37
$36:
  %115 = phi i64 [%113, %$-9] ; # N
  %116 = phi i64 [%114, %$-9] ; # Y
; # (neg Y)
  %117 = icmp eq i64 %116, 2
  br i1 %117, label %$39, label %$40
$39:
  br label %$41
$40:
  %118 = xor i64 %116, 8
  br label %$41
$41:
  %119 = phi i64 [%116, %$39], [%118, %$40] ; # ->
  br label %$38
$37:
  %120 = phi i64 [%113, %$-9] ; # N
  %121 = phi i64 [%114, %$-9] ; # Y
  br label %$38
$38:
  %122 = phi i64 [%115, %$41], [%120, %$37] ; # N
  %123 = phi i64 [%116, %$41], [%121, %$37] ; # Y
  %124 = phi i64 [%119, %$41], [%121, %$37] ; # ->
; # (drop *Safe)
  %125 = inttoptr i64 %40 to i64*
  %126 = getelementptr i64, i64* %125, i32 1
  %127 = load i64, i64* %126
  %128 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %127, i64* %128
  br label %$14
$14:
  %129 = phi i64 [%30, %$12], [%122, %$38] ; # N
  %130 = phi i64 [%31, %$12], [%123, %$38] ; # Y
  %131 = phi i64 [%31, %$12], [%124, %$38] ; # ->
  ret i64 %131
}

define i64 @_Rev(i64) align 8 {
$1:
; # (let (X (cdr Exe) C (evCnt Exe X) N (evCnt Exe (cdr X)) R 0) (loo...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (evCnt Exe X)
  %4 = call i64 @evCnt(i64 %0, i64 %3)
; # (cdr X)
  %5 = inttoptr i64 %3 to i64*
  %6 = getelementptr i64, i64* %5, i32 1
  %7 = load i64, i64* %6
; # (evCnt Exe (cdr X))
  %8 = call i64 @evCnt(i64 %0, i64 %7)
; # (loop (setq R (+ R R (& N 1)) N (shr N 1)) (? (=0 (dec 'C))))
  br label %$2
$2:
  %9 = phi i64 [%4, %$1], [%18, %$3] ; # C
  %10 = phi i64 [%8, %$1], [%19, %$3] ; # N
  %11 = phi i64 [0, %$1], [%20, %$3] ; # R
; # (& N 1)
  %12 = and i64 %10, 1
; # (+ R R (& N 1))
  %13 = add i64 %11, %11
  %14 = add i64 %13, %12
; # (shr N 1)
  %15 = lshr i64 %10, 1
; # (? (=0 (dec 'C)))
; # (dec 'C)
  %16 = sub i64 %9, 1
; # (=0 (dec 'C))
  %17 = icmp eq i64 %16, 0
  br i1 %17, label %$4, label %$3
$3:
  %18 = phi i64 [%16, %$2] ; # C
  %19 = phi i64 [%15, %$2] ; # N
  %20 = phi i64 [%14, %$2] ; # R
  br label %$2
$4:
  %21 = phi i64 [%16, %$2] ; # C
  %22 = phi i64 [%15, %$2] ; # N
  %23 = phi i64 [%14, %$2] ; # R
  %24 = phi i64 [0, %$2] ; # ->
; # (cnt R)
  %25 = shl i64 %23, 4
  %26 = or i64 %25, 2
  ret i64 %26
}

define i64 @_Lt0(i64) align 8 {
$1:
; # (if (and (num? (eval (cadr Exe))) (sign? @)) @ $Nil)
; # (and (num? (eval (cadr Exe))) (sign? @))
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$5, label %$4
$5:
  br label %$3
$4:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$7, label %$6
$7:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$3
$6:
  %12 = call i64 @evList(i64 %5)
  br label %$3
$3:
  %13 = phi i64 [%5, %$5], [%11, %$7], [%12, %$6] ; # ->
; # (num? (eval (cadr Exe)))
  %14 = and i64 %13, 6
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$8, label %$2
$8:
; # (sign? @)
  %16 = and i64 %13, 8
  %17 = icmp ne i64 %16, 0
  br label %$2
$2:
  %18 = phi i1 [0, %$3], [%17, %$8] ; # ->
  br i1 %18, label %$9, label %$10
$9:
  br label %$11
$10:
  br label %$11
$11:
  %19 = phi i64 [%13, %$9], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$10] ; # ->
  ret i64 %19
}

define i64 @_Le0(i64) align 8 {
$1:
; # (if (and (num? (eval (cadr Exe))) (or (== @ ZERO) (sign? @))) @ $...
; # (and (num? (eval (cadr Exe))) (or (== @ ZERO) (sign? @)))
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$5, label %$4
$5:
  br label %$3
$4:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$7, label %$6
$7:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$3
$6:
  %12 = call i64 @evList(i64 %5)
  br label %$3
$3:
  %13 = phi i64 [%5, %$5], [%11, %$7], [%12, %$6] ; # ->
; # (num? (eval (cadr Exe)))
  %14 = and i64 %13, 6
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$8, label %$2
$8:
; # (or (== @ ZERO) (sign? @))
; # (== @ ZERO)
  %16 = icmp eq i64 %13, 2
  br i1 %16, label %$9, label %$10
$10:
; # (sign? @)
  %17 = and i64 %13, 8
  %18 = icmp ne i64 %17, 0
  br label %$9
$9:
  %19 = phi i1 [1, %$8], [%18, %$10] ; # ->
  br label %$2
$2:
  %20 = phi i1 [0, %$3], [%19, %$9] ; # ->
  br i1 %20, label %$11, label %$12
$11:
  br label %$13
$12:
  br label %$13
$13:
  %21 = phi i64 [%13, %$11], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$12] ; # ->
  ret i64 %21
}

define i64 @_Ge0(i64) align 8 {
$1:
; # (if (and (num? (eval (cadr Exe))) (not (sign? @))) @ $Nil)
; # (and (num? (eval (cadr Exe))) (not (sign? @)))
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$5, label %$4
$5:
  br label %$3
$4:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$7, label %$6
$7:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$3
$6:
  %12 = call i64 @evList(i64 %5)
  br label %$3
$3:
  %13 = phi i64 [%5, %$5], [%11, %$7], [%12, %$6] ; # ->
; # (num? (eval (cadr Exe)))
  %14 = and i64 %13, 6
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$8, label %$2
$8:
; # (sign? @)
  %16 = and i64 %13, 8
  %17 = icmp ne i64 %16, 0
; # (not (sign? @))
  %18 = icmp eq i1 %17, 0
  br label %$2
$2:
  %19 = phi i1 [0, %$3], [%18, %$8] ; # ->
  br i1 %19, label %$9, label %$10
$9:
  br label %$11
$10:
  br label %$11
$11:
  %20 = phi i64 [%13, %$9], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$10] ; # ->
  ret i64 %20
}

define i64 @_Gt0(i64) align 8 {
$1:
; # (if (and (num? (eval (cadr Exe))) (<> @ ZERO) (not (sign? @))) @ ...
; # (and (num? (eval (cadr Exe))) (<> @ ZERO) (not (sign? @)))
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$5, label %$4
$5:
  br label %$3
$4:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$7, label %$6
$7:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$3
$6:
  %12 = call i64 @evList(i64 %5)
  br label %$3
$3:
  %13 = phi i64 [%5, %$5], [%11, %$7], [%12, %$6] ; # ->
; # (num? (eval (cadr Exe)))
  %14 = and i64 %13, 6
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$8, label %$2
$8:
; # (<> @ ZERO)
  %16 = icmp ne i64 %13, 2
  br i1 %16, label %$9, label %$2
$9:
; # (sign? @)
  %17 = and i64 %13, 8
  %18 = icmp ne i64 %17, 0
; # (not (sign? @))
  %19 = icmp eq i1 %18, 0
  br label %$2
$2:
  %20 = phi i1 [0, %$3], [0, %$8], [%19, %$9] ; # ->
  br i1 %20, label %$10, label %$11
$10:
  br label %$12
$11:
  br label %$12
$12:
  %21 = phi i64 [%13, %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$11] ; # ->
  ret i64 %21
}

define i64 @_Abs(i64) align 8 {
$1:
; # (if (nil? (eval (cadr Exe))) @ (pos (needNum Exe @)))
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (nil? (eval (cadr Exe)))
  %14 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %14, label %$7, label %$8
$7:
  br label %$9
$8:
; # (needNum Exe @)
  %15 = and i64 %13, 6
  %16 = icmp ne i64 %15, 0
  br i1 %16, label %$11, label %$10
$10:
  call void @numErr(i64 %0, i64 %13)
  unreachable
$11:
; # (pos (needNum Exe @))
  %17 = and i64 %13, -9
  br label %$9
$9:
  %18 = phi i64 [%13, %$7], [%17, %$11] ; # ->
  ret i64 %18
}

define i64 @_BitQ(i64) align 8 {
$1:
; # (let (X (cdr Exe) N (save (pos (needNum Exe (eval (++ X)))))) (lo...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (needNum Exe (eval (++ X)))
  %16 = and i64 %15, 6
  %17 = icmp ne i64 %16, 0
  br i1 %17, label %$8, label %$7
$7:
  call void @numErr(i64 %0, i64 %15)
  unreachable
$8:
; # (pos (needNum Exe (eval (++ X))))
  %18 = and i64 %15, -9
; # (save (pos (needNum Exe (eval (++ X)))))
  %19 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %20 = load i64, i64* %19
  %21 = alloca i64, i64 2, align 16
  %22 = ptrtoint i64* %21 to i64
  %23 = inttoptr i64 %22 to i64*
  store i64 %18, i64* %23
  %24 = add i64 %22, 8
  %25 = inttoptr i64 %24 to i64*
  store i64 %20, i64* %25
  %26 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %22, i64* %26
; # (loop (? (atom X) N) (let Y (eval (++ X)) (? (nil? Y) Y) (setq Y ...
  br label %$9
$9:
  %27 = phi i64 [%7, %$8], [%116, %$31] ; # X
; # (? (atom X) N)
; # (atom X)
  %28 = and i64 %27, 15
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %$12, label %$10
$12:
  %30 = phi i64 [%27, %$9] ; # X
  br label %$11
$10:
  %31 = phi i64 [%27, %$9] ; # X
; # (let Y (eval (++ X)) (? (nil? Y) Y) (setq Y (pos (needNum Exe Y))...
; # (++ X)
  %32 = inttoptr i64 %31 to i64*
  %33 = load i64, i64* %32
  %34 = getelementptr i64, i64* %32, i32 1
  %35 = load i64, i64* %34
; # (eval (++ X))
  %36 = and i64 %33, 6
  %37 = icmp ne i64 %36, 0
  br i1 %37, label %$15, label %$14
$15:
  br label %$13
$14:
  %38 = and i64 %33, 8
  %39 = icmp ne i64 %38, 0
  br i1 %39, label %$17, label %$16
$17:
  %40 = inttoptr i64 %33 to i64*
  %41 = load i64, i64* %40
  br label %$13
$16:
  %42 = call i64 @evList(i64 %33)
  br label %$13
$13:
  %43 = phi i64 [%33, %$15], [%41, %$17], [%42, %$16] ; # ->
; # (? (nil? Y) Y)
; # (nil? Y)
  %44 = icmp eq i64 %43, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %44, label %$19, label %$18
$19:
  %45 = phi i64 [%35, %$13] ; # X
  %46 = phi i64 [%43, %$13] ; # Y
  br label %$11
$18:
  %47 = phi i64 [%35, %$13] ; # X
  %48 = phi i64 [%43, %$13] ; # Y
; # (needNum Exe Y)
  %49 = and i64 %48, 6
  %50 = icmp ne i64 %49, 0
  br i1 %50, label %$21, label %$20
$20:
  call void @numErr(i64 %0, i64 %48)
  unreachable
$21:
; # (pos (needNum Exe Y))
  %51 = and i64 %48, -9
; # (let Z N (while (big? Z) (unless (big? Y) (ret $Nil)) (let A (val...
; # (while (big? Z) (unless (big? Y) (ret $Nil)) (let A (val (dig Z))...
  br label %$22
$22:
  %52 = phi i64 [%47, %$21], [%87, %$28] ; # X
  %53 = phi i64 [%51, %$21], [%92, %$28] ; # Y
  %54 = phi i64 [%18, %$21], [%95, %$28] ; # Z
; # (big? Z)
  %55 = and i64 %54, 4
  %56 = icmp ne i64 %55, 0
  br i1 %56, label %$23, label %$24
$23:
  %57 = phi i64 [%52, %$22] ; # X
  %58 = phi i64 [%53, %$22] ; # Y
  %59 = phi i64 [%54, %$22] ; # Z
; # (unless (big? Y) (ret $Nil))
; # (big? Y)
  %60 = and i64 %58, 4
  %61 = icmp ne i64 %60, 0
  br i1 %61, label %$26, label %$25
$25:
  %62 = phi i64 [%57, %$23] ; # X
  %63 = phi i64 [%58, %$23] ; # Y
  %64 = phi i64 [%59, %$23] ; # Z
; # (ret $Nil)
; # (drop *Safe)
  %65 = inttoptr i64 %22 to i64*
  %66 = getelementptr i64, i64* %65, i32 1
  %67 = load i64, i64* %66
  %68 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %67, i64* %68
  ret i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
$26:
  %69 = phi i64 [%57, %$23] ; # X
  %70 = phi i64 [%58, %$23] ; # Y
  %71 = phi i64 [%59, %$23] ; # Z
; # (let A (val (dig Z)) (unless (== A (& A (val (dig Y)))) (ret $Nil...
; # (dig Z)
  %72 = add i64 %71, -4
; # (val (dig Z))
  %73 = inttoptr i64 %72 to i64*
  %74 = load i64, i64* %73
; # (unless (== A (& A (val (dig Y)))) (ret $Nil))
; # (dig Y)
  %75 = add i64 %70, -4
; # (val (dig Y))
  %76 = inttoptr i64 %75 to i64*
  %77 = load i64, i64* %76
; # (& A (val (dig Y)))
  %78 = and i64 %74, %77
; # (== A (& A (val (dig Y))))
  %79 = icmp eq i64 %74, %78
  br i1 %79, label %$28, label %$27
$27:
  %80 = phi i64 [%69, %$26] ; # X
  %81 = phi i64 [%70, %$26] ; # Y
  %82 = phi i64 [%71, %$26] ; # Z
; # (ret $Nil)
; # (drop *Safe)
  %83 = inttoptr i64 %22 to i64*
  %84 = getelementptr i64, i64* %83, i32 1
  %85 = load i64, i64* %84
  %86 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %85, i64* %86
  ret i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
$28:
  %87 = phi i64 [%69, %$26] ; # X
  %88 = phi i64 [%70, %$26] ; # Y
  %89 = phi i64 [%71, %$26] ; # Z
; # (big Y)
  %90 = add i64 %88, 4
; # (val (big Y))
  %91 = inttoptr i64 %90 to i64*
  %92 = load i64, i64* %91
; # (big Z)
  %93 = add i64 %89, 4
; # (val (big Z))
  %94 = inttoptr i64 %93 to i64*
  %95 = load i64, i64* %94
  br label %$22
$24:
  %96 = phi i64 [%52, %$22] ; # X
  %97 = phi i64 [%53, %$22] ; # Y
  %98 = phi i64 [%54, %$22] ; # Z
; # (when (big? Y) (setq Z (int Z) Y (val (dig Y))))
; # (big? Y)
  %99 = and i64 %97, 4
  %100 = icmp ne i64 %99, 0
  br i1 %100, label %$29, label %$30
$29:
  %101 = phi i64 [%96, %$24] ; # X
  %102 = phi i64 [%97, %$24] ; # Y
  %103 = phi i64 [%98, %$24] ; # Z
; # (int Z)
  %104 = lshr i64 %103, 4
; # (dig Y)
  %105 = add i64 %102, -4
; # (val (dig Y))
  %106 = inttoptr i64 %105 to i64*
  %107 = load i64, i64* %106
  br label %$30
$30:
  %108 = phi i64 [%96, %$24], [%101, %$29] ; # X
  %109 = phi i64 [%97, %$24], [%107, %$29] ; # Y
  %110 = phi i64 [%98, %$24], [%104, %$29] ; # Z
; # (? (<> Z (& Y Z)) $Nil)
; # (& Y Z)
  %111 = and i64 %109, %110
; # (<> Z (& Y Z))
  %112 = icmp ne i64 %110, %111
  br i1 %112, label %$32, label %$31
$32:
  %113 = phi i64 [%108, %$30] ; # X
  %114 = phi i64 [%109, %$30] ; # Y
  %115 = phi i64 [%110, %$30] ; # Z
  br label %$11
$31:
  %116 = phi i64 [%108, %$30] ; # X
  %117 = phi i64 [%109, %$30] ; # Y
  %118 = phi i64 [%110, %$30] ; # Z
  br label %$9
$11:
  %119 = phi i64 [%30, %$12], [%45, %$19], [%113, %$32] ; # X
  %120 = phi i64 [%18, %$12], [%46, %$19], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$32] ; # ->
; # (drop *Safe)
  %121 = inttoptr i64 %22 to i64*
  %122 = getelementptr i64, i64* %121, i32 1
  %123 = load i64, i64* %122
  %124 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %123, i64* %124
  ret i64 %120
}

define i64 @_BitAnd(i64) align 8 {
$1:
; # (let X (cdr Exe) (if (nil? (eval (car X))) @ (save -ZERO (let R (...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (if (nil? (eval (car X))) @ (save -ZERO (let R (link (push (pos (...
; # (car X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (car X))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (nil? (eval (car X)))
  %14 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %14, label %$7, label %$8
$7:
  %15 = phi i64 [%3, %$2] ; # X
  br label %$9
$8:
  %16 = phi i64 [%3, %$2] ; # X
; # (save -ZERO (let R (link (push (pos (needNum Exe @)) NIL)) (loop ...
  %17 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %18 = load i64, i64* %17
  %19 = alloca i64, i64 2, align 16
  %20 = ptrtoint i64* %19 to i64
  %21 = inttoptr i64 %20 to i64*
  store i64 10, i64* %21
  %22 = add i64 %20, 8
  %23 = inttoptr i64 %22 to i64*
  store i64 %18, i64* %23
  %24 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %20, i64* %24
; # (let R (link (push (pos (needNum Exe @)) NIL)) (loop (? (atom (sh...
; # (needNum Exe @)
  %25 = and i64 %13, 6
  %26 = icmp ne i64 %25, 0
  br i1 %26, label %$11, label %$10
$10:
  call void @numErr(i64 %0, i64 %13)
  unreachable
$11:
; # (pos (needNum Exe @))
  %27 = and i64 %13, -9
; # (push (pos (needNum Exe @)) NIL)
  %28 = alloca i64, i64 2, align 16
  %29 = ptrtoint i64* %28 to i64
  %30 = inttoptr i64 %29 to i64*
  store i64 %27, i64* %30
; # (link (push (pos (needNum Exe @)) NIL))
  %31 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %32 = load i64, i64* %31
  %33 = inttoptr i64 %29 to i64*
  %34 = getelementptr i64, i64* %33, i32 1
  store i64 %32, i64* %34
  %35 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %29, i64* %35
; # (loop (? (atom (shift X)) (val R)) (? (nil? (eval (car X))) @) (s...
  br label %$12
$12:
  %36 = phi i64 [%16, %$11], [%58, %$24] ; # X
; # (? (atom (shift X)) (val R))
; # (shift X)
  %37 = inttoptr i64 %36 to i64*
  %38 = getelementptr i64, i64* %37, i32 1
  %39 = load i64, i64* %38
; # (atom (shift X))
  %40 = and i64 %39, 15
  %41 = icmp ne i64 %40, 0
  br i1 %41, label %$15, label %$13
$15:
  %42 = phi i64 [%39, %$12] ; # X
; # (val R)
  %43 = inttoptr i64 %29 to i64*
  %44 = load i64, i64* %43
  br label %$14
$13:
  %45 = phi i64 [%39, %$12] ; # X
; # (? (nil? (eval (car X))) @)
; # (car X)
  %46 = inttoptr i64 %45 to i64*
  %47 = load i64, i64* %46
; # (eval (car X))
  %48 = and i64 %47, 6
  %49 = icmp ne i64 %48, 0
  br i1 %49, label %$18, label %$17
$18:
  br label %$16
$17:
  %50 = and i64 %47, 8
  %51 = icmp ne i64 %50, 0
  br i1 %51, label %$20, label %$19
$20:
  %52 = inttoptr i64 %47 to i64*
  %53 = load i64, i64* %52
  br label %$16
$19:
  %54 = call i64 @evList(i64 %47)
  br label %$16
$16:
  %55 = phi i64 [%47, %$18], [%53, %$20], [%54, %$19] ; # ->
; # (nil? (eval (car X)))
  %56 = icmp eq i64 %55, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %56, label %$22, label %$21
$22:
  %57 = phi i64 [%45, %$16] ; # X
  br label %$14
$21:
  %58 = phi i64 [%45, %$16] ; # X
; # (needNum Exe @)
  %59 = and i64 %55, 6
  %60 = icmp ne i64 %59, 0
  br i1 %60, label %$24, label %$23
$23:
  call void @numErr(i64 %0, i64 %55)
  unreachable
$24:
; # (safe (needNum Exe @))
  %61 = inttoptr i64 %20 to i64*
  store i64 %55, i64* %61
; # (set R (andu (val R) (pos @)))
; # (val R)
  %62 = inttoptr i64 %29 to i64*
  %63 = load i64, i64* %62
; # (pos @)
  %64 = and i64 %55, -9
; # (andu (val R) (pos @))
  %65 = call i64 @andu(i64 %63, i64 %64)
  %66 = inttoptr i64 %29 to i64*
  store i64 %65, i64* %66
  br label %$12
$14:
  %67 = phi i64 [%42, %$15], [%57, %$22] ; # X
  %68 = phi i64 [%44, %$15], [%55, %$22] ; # ->
; # drop
  %69 = inttoptr i64 %20 to i64*
  %70 = getelementptr i64, i64* %69, i32 1
  %71 = load i64, i64* %70
  %72 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %71, i64* %72
  br label %$9
$9:
  %73 = phi i64 [%15, %$7], [%67, %$14] ; # X
  %74 = phi i64 [%13, %$7], [%68, %$14] ; # ->
  ret i64 %74
}

define i64 @_BitOr(i64) align 8 {
$1:
; # (let X (cdr Exe) (if (nil? (eval (car X))) @ (save -ZERO (let R (...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (if (nil? (eval (car X))) @ (save -ZERO (let R (link (push (pos (...
; # (car X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (car X))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (nil? (eval (car X)))
  %14 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %14, label %$7, label %$8
$7:
  %15 = phi i64 [%3, %$2] ; # X
  br label %$9
$8:
  %16 = phi i64 [%3, %$2] ; # X
; # (save -ZERO (let R (link (push (pos (needNum Exe @)) NIL)) (loop ...
  %17 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %18 = load i64, i64* %17
  %19 = alloca i64, i64 2, align 16
  %20 = ptrtoint i64* %19 to i64
  %21 = inttoptr i64 %20 to i64*
  store i64 10, i64* %21
  %22 = add i64 %20, 8
  %23 = inttoptr i64 %22 to i64*
  store i64 %18, i64* %23
  %24 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %20, i64* %24
; # (let R (link (push (pos (needNum Exe @)) NIL)) (loop (? (atom (sh...
; # (needNum Exe @)
  %25 = and i64 %13, 6
  %26 = icmp ne i64 %25, 0
  br i1 %26, label %$11, label %$10
$10:
  call void @numErr(i64 %0, i64 %13)
  unreachable
$11:
; # (pos (needNum Exe @))
  %27 = and i64 %13, -9
; # (push (pos (needNum Exe @)) NIL)
  %28 = alloca i64, i64 2, align 16
  %29 = ptrtoint i64* %28 to i64
  %30 = inttoptr i64 %29 to i64*
  store i64 %27, i64* %30
; # (link (push (pos (needNum Exe @)) NIL))
  %31 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %32 = load i64, i64* %31
  %33 = inttoptr i64 %29 to i64*
  %34 = getelementptr i64, i64* %33, i32 1
  store i64 %32, i64* %34
  %35 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %29, i64* %35
; # (loop (? (atom (shift X)) (val R)) (? (nil? (eval (car X))) @) (s...
  br label %$12
$12:
  %36 = phi i64 [%16, %$11], [%58, %$24] ; # X
; # (? (atom (shift X)) (val R))
; # (shift X)
  %37 = inttoptr i64 %36 to i64*
  %38 = getelementptr i64, i64* %37, i32 1
  %39 = load i64, i64* %38
; # (atom (shift X))
  %40 = and i64 %39, 15
  %41 = icmp ne i64 %40, 0
  br i1 %41, label %$15, label %$13
$15:
  %42 = phi i64 [%39, %$12] ; # X
; # (val R)
  %43 = inttoptr i64 %29 to i64*
  %44 = load i64, i64* %43
  br label %$14
$13:
  %45 = phi i64 [%39, %$12] ; # X
; # (? (nil? (eval (car X))) @)
; # (car X)
  %46 = inttoptr i64 %45 to i64*
  %47 = load i64, i64* %46
; # (eval (car X))
  %48 = and i64 %47, 6
  %49 = icmp ne i64 %48, 0
  br i1 %49, label %$18, label %$17
$18:
  br label %$16
$17:
  %50 = and i64 %47, 8
  %51 = icmp ne i64 %50, 0
  br i1 %51, label %$20, label %$19
$20:
  %52 = inttoptr i64 %47 to i64*
  %53 = load i64, i64* %52
  br label %$16
$19:
  %54 = call i64 @evList(i64 %47)
  br label %$16
$16:
  %55 = phi i64 [%47, %$18], [%53, %$20], [%54, %$19] ; # ->
; # (nil? (eval (car X)))
  %56 = icmp eq i64 %55, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %56, label %$22, label %$21
$22:
  %57 = phi i64 [%45, %$16] ; # X
  br label %$14
$21:
  %58 = phi i64 [%45, %$16] ; # X
; # (needNum Exe @)
  %59 = and i64 %55, 6
  %60 = icmp ne i64 %59, 0
  br i1 %60, label %$24, label %$23
$23:
  call void @numErr(i64 %0, i64 %55)
  unreachable
$24:
; # (safe (needNum Exe @))
  %61 = inttoptr i64 %20 to i64*
  store i64 %55, i64* %61
; # (set R (oru (val R) (pos @)))
; # (val R)
  %62 = inttoptr i64 %29 to i64*
  %63 = load i64, i64* %62
; # (pos @)
  %64 = and i64 %55, -9
; # (oru (val R) (pos @))
  %65 = call i64 @oru(i64 %63, i64 %64)
  %66 = inttoptr i64 %29 to i64*
  store i64 %65, i64* %66
  br label %$12
$14:
  %67 = phi i64 [%42, %$15], [%57, %$22] ; # X
  %68 = phi i64 [%44, %$15], [%55, %$22] ; # ->
; # drop
  %69 = inttoptr i64 %20 to i64*
  %70 = getelementptr i64, i64* %69, i32 1
  %71 = load i64, i64* %70
  %72 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %71, i64* %72
  br label %$9
$9:
  %73 = phi i64 [%15, %$7], [%67, %$14] ; # X
  %74 = phi i64 [%13, %$7], [%68, %$14] ; # ->
  ret i64 %74
}

define i64 @_BitXor(i64) align 8 {
$1:
; # (let X (cdr Exe) (if (nil? (eval (car X))) @ (save -ZERO (let R (...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (if (nil? (eval (car X))) @ (save -ZERO (let R (link (push (pos (...
; # (car X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (car X))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (nil? (eval (car X)))
  %14 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %14, label %$7, label %$8
$7:
  %15 = phi i64 [%3, %$2] ; # X
  br label %$9
$8:
  %16 = phi i64 [%3, %$2] ; # X
; # (save -ZERO (let R (link (push (pos (needNum Exe @)) NIL)) (loop ...
  %17 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %18 = load i64, i64* %17
  %19 = alloca i64, i64 2, align 16
  %20 = ptrtoint i64* %19 to i64
  %21 = inttoptr i64 %20 to i64*
  store i64 10, i64* %21
  %22 = add i64 %20, 8
  %23 = inttoptr i64 %22 to i64*
  store i64 %18, i64* %23
  %24 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %20, i64* %24
; # (let R (link (push (pos (needNum Exe @)) NIL)) (loop (? (atom (sh...
; # (needNum Exe @)
  %25 = and i64 %13, 6
  %26 = icmp ne i64 %25, 0
  br i1 %26, label %$11, label %$10
$10:
  call void @numErr(i64 %0, i64 %13)
  unreachable
$11:
; # (pos (needNum Exe @))
  %27 = and i64 %13, -9
; # (push (pos (needNum Exe @)) NIL)
  %28 = alloca i64, i64 2, align 16
  %29 = ptrtoint i64* %28 to i64
  %30 = inttoptr i64 %29 to i64*
  store i64 %27, i64* %30
; # (link (push (pos (needNum Exe @)) NIL))
  %31 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %32 = load i64, i64* %31
  %33 = inttoptr i64 %29 to i64*
  %34 = getelementptr i64, i64* %33, i32 1
  store i64 %32, i64* %34
  %35 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %29, i64* %35
; # (loop (? (atom (shift X)) (val R)) (? (nil? (eval (car X))) @) (s...
  br label %$12
$12:
  %36 = phi i64 [%16, %$11], [%58, %$24] ; # X
; # (? (atom (shift X)) (val R))
; # (shift X)
  %37 = inttoptr i64 %36 to i64*
  %38 = getelementptr i64, i64* %37, i32 1
  %39 = load i64, i64* %38
; # (atom (shift X))
  %40 = and i64 %39, 15
  %41 = icmp ne i64 %40, 0
  br i1 %41, label %$15, label %$13
$15:
  %42 = phi i64 [%39, %$12] ; # X
; # (val R)
  %43 = inttoptr i64 %29 to i64*
  %44 = load i64, i64* %43
  br label %$14
$13:
  %45 = phi i64 [%39, %$12] ; # X
; # (? (nil? (eval (car X))) @)
; # (car X)
  %46 = inttoptr i64 %45 to i64*
  %47 = load i64, i64* %46
; # (eval (car X))
  %48 = and i64 %47, 6
  %49 = icmp ne i64 %48, 0
  br i1 %49, label %$18, label %$17
$18:
  br label %$16
$17:
  %50 = and i64 %47, 8
  %51 = icmp ne i64 %50, 0
  br i1 %51, label %$20, label %$19
$20:
  %52 = inttoptr i64 %47 to i64*
  %53 = load i64, i64* %52
  br label %$16
$19:
  %54 = call i64 @evList(i64 %47)
  br label %$16
$16:
  %55 = phi i64 [%47, %$18], [%53, %$20], [%54, %$19] ; # ->
; # (nil? (eval (car X)))
  %56 = icmp eq i64 %55, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %56, label %$22, label %$21
$22:
  %57 = phi i64 [%45, %$16] ; # X
  br label %$14
$21:
  %58 = phi i64 [%45, %$16] ; # X
; # (needNum Exe @)
  %59 = and i64 %55, 6
  %60 = icmp ne i64 %59, 0
  br i1 %60, label %$24, label %$23
$23:
  call void @numErr(i64 %0, i64 %55)
  unreachable
$24:
; # (safe (needNum Exe @))
  %61 = inttoptr i64 %20 to i64*
  store i64 %55, i64* %61
; # (set R (xoru (val R) (pos @)))
; # (val R)
  %62 = inttoptr i64 %29 to i64*
  %63 = load i64, i64* %62
; # (pos @)
  %64 = and i64 %55, -9
; # (xoru (val R) (pos @))
  %65 = call i64 @xoru(i64 %63, i64 %64)
  %66 = inttoptr i64 %29 to i64*
  store i64 %65, i64* %66
  br label %$12
$14:
  %67 = phi i64 [%42, %$15], [%57, %$22] ; # X
  %68 = phi i64 [%44, %$15], [%55, %$22] ; # ->
; # drop
  %69 = inttoptr i64 %20 to i64*
  %70 = getelementptr i64, i64* %69, i32 1
  %71 = load i64, i64* %70
  %72 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %71, i64* %72
  br label %$9
$9:
  %73 = phi i64 [%15, %$7], [%67, %$14] ; # X
  %74 = phi i64 [%13, %$7], [%68, %$14] ; # ->
  ret i64 %74
}

define i64 @_Sqrt(i64) align 8 {
$1:
; # (let X (cdr Exe) (if (nil? (eval (car X))) @ (when (sign? (needNu...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (if (nil? (eval (car X))) @ (when (sign? (needNum Exe @)) (argErr...
; # (car X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (car X))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (nil? (eval (car X)))
  %14 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %14, label %$7, label %$8
$7:
  br label %$9
$8:
; # (when (sign? (needNum Exe @)) (argErr Exe @))
; # (needNum Exe @)
  %15 = and i64 %13, 6
  %16 = icmp ne i64 %15, 0
  br i1 %16, label %$11, label %$10
$10:
  call void @numErr(i64 %0, i64 %13)
  unreachable
$11:
; # (sign? (needNum Exe @))
  %17 = and i64 %13, 8
  %18 = icmp ne i64 %17, 0
  br i1 %18, label %$12, label %$13
$12:
; # (argErr Exe @)
  call void @argErr(i64 %0, i64 %13)
  unreachable
$13:
; # (let (Y (save @) Z (save (eval (cadr X)))) (when (num? Z) (setq Y...
; # (save @)
  %19 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %20 = load i64, i64* %19
  %21 = alloca i64, i64 2, align 16
  %22 = ptrtoint i64* %21 to i64
  %23 = inttoptr i64 %22 to i64*
  store i64 %13, i64* %23
  %24 = add i64 %22, 8
  %25 = inttoptr i64 %24 to i64*
  store i64 %20, i64* %25
  %26 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %22, i64* %26
; # (cadr X)
  %27 = inttoptr i64 %3 to i64*
  %28 = getelementptr i64, i64* %27, i32 1
  %29 = load i64, i64* %28
  %30 = inttoptr i64 %29 to i64*
  %31 = load i64, i64* %30
; # (eval (cadr X))
  %32 = and i64 %31, 6
  %33 = icmp ne i64 %32, 0
  br i1 %33, label %$16, label %$15
$16:
  br label %$14
$15:
  %34 = and i64 %31, 8
  %35 = icmp ne i64 %34, 0
  br i1 %35, label %$18, label %$17
$18:
  %36 = inttoptr i64 %31 to i64*
  %37 = load i64, i64* %36
  br label %$14
$17:
  %38 = call i64 @evList(i64 %31)
  br label %$14
$14:
  %39 = phi i64 [%31, %$16], [%37, %$18], [%38, %$17] ; # ->
; # (save (eval (cadr X)))
  %40 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %41 = load i64, i64* %40
  %42 = alloca i64, i64 2, align 16
  %43 = ptrtoint i64* %42 to i64
  %44 = inttoptr i64 %43 to i64*
  store i64 %39, i64* %44
  %45 = add i64 %43, 8
  %46 = inttoptr i64 %45 to i64*
  store i64 %41, i64* %46
  %47 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %43, i64* %47
; # (when (num? Z) (setq Y (safe (mulu Y Z))))
; # (num? Z)
  %48 = and i64 %39, 6
  %49 = icmp ne i64 %48, 0
  br i1 %49, label %$19, label %$20
$19:
  %50 = phi i64 [%13, %$14] ; # Y
; # (mulu Y Z)
  %51 = call i64 @mulu(i64 %50, i64 %39)
; # (safe (mulu Y Z))
  %52 = inttoptr i64 %22 to i64*
  store i64 %51, i64* %52
  br label %$20
$20:
  %53 = phi i64 [%13, %$14], [%51, %$19] ; # Y
; # (prog1 (if (cnt? Y) (let (M (hex "400000000000000") R 0) (setq Y ...
; # (if (cnt? Y) (let (M (hex "400000000000000") R 0) (setq Y (int Y)...
; # (cnt? Y)
  %54 = and i64 %53, 2
  %55 = icmp ne i64 %54, 0
  br i1 %55, label %$21, label %$22
$21:
  %56 = phi i64 [%53, %$20] ; # Y
; # (let (M (hex "400000000000000") R 0) (setq Y (int Y)) (loop (let ...
; # (int Y)
  %57 = lshr i64 %56, 4
; # (loop (let N (+ R M) (when (>= Y N) (dec 'Y N) (setq R (+ N M))))...
  br label %$24
$24:
  %58 = phi i64 [%57, %$21], [%74, %$27] ; # Y
  %59 = phi i64 [288230376151711744, %$21], [%75, %$27] ; # M
  %60 = phi i64 [0, %$21], [%76, %$27] ; # R
; # (let N (+ R M) (when (>= Y N) (dec 'Y N) (setq R (+ N M))))
; # (+ R M)
  %61 = add i64 %60, %59
; # (when (>= Y N) (dec 'Y N) (setq R (+ N M)))
; # (>= Y N)
  %62 = icmp uge i64 %58, %61
  br i1 %62, label %$25, label %$26
$25:
  %63 = phi i64 [%58, %$24] ; # Y
  %64 = phi i64 [%59, %$24] ; # M
  %65 = phi i64 [%60, %$24] ; # R
; # (dec 'Y N)
  %66 = sub i64 %63, %61
; # (+ N M)
  %67 = add i64 %61, %64
  br label %$26
$26:
  %68 = phi i64 [%58, %$24], [%66, %$25] ; # Y
  %69 = phi i64 [%59, %$24], [%64, %$25] ; # M
  %70 = phi i64 [%60, %$24], [%67, %$25] ; # R
; # (shr R 1)
  %71 = lshr i64 %70, 1
; # (? (=0 (setq M (shr M 2))))
; # (shr M 2)
  %72 = lshr i64 %69, 2
; # (=0 (setq M (shr M 2)))
  %73 = icmp eq i64 %72, 0
  br i1 %73, label %$28, label %$27
$27:
  %74 = phi i64 [%68, %$26] ; # Y
  %75 = phi i64 [%72, %$26] ; # M
  %76 = phi i64 [%71, %$26] ; # R
  br label %$24
$28:
  %77 = phi i64 [%68, %$26] ; # Y
  %78 = phi i64 [%72, %$26] ; # M
  %79 = phi i64 [%71, %$26] ; # R
  %80 = phi i64 [0, %$26] ; # ->
; # (or (nil? Z) (>= R Y) (inc 'R))
; # (nil? Z)
  %81 = icmp eq i64 %39, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %81, label %$29, label %$30
$30:
  %82 = phi i64 [%77, %$28] ; # Y
  %83 = phi i64 [%78, %$28] ; # M
  %84 = phi i64 [%79, %$28] ; # R
; # (>= R Y)
  %85 = icmp uge i64 %84, %82
  br i1 %85, label %$29, label %$31
$31:
  %86 = phi i64 [%82, %$30] ; # Y
  %87 = phi i64 [%83, %$30] ; # M
  %88 = phi i64 [%84, %$30] ; # R
; # (inc 'R)
  %89 = add i64 %88, 1
  %90 = icmp ne i64 %89, 0
  br label %$29
$29:
  %91 = phi i64 [%77, %$28], [%82, %$30], [%86, %$31] ; # Y
  %92 = phi i64 [%78, %$28], [%83, %$30], [%87, %$31] ; # M
  %93 = phi i64 [%79, %$28], [%84, %$30], [%89, %$31] ; # R
  %94 = phi i1 [1, %$28], [1, %$30], [%90, %$31] ; # ->
; # (cnt R)
  %95 = shl i64 %93, 4
  %96 = or i64 %95, 2
  br label %$23
$22:
  %97 = phi i64 [%53, %$20] ; # Y
; # (let (M (consNum 0 ONE) M* (link (push M NIL)) R (link (push ZERO...
; # (consNum 0 ONE)
  %98 = call i64 @consNum(i64 0, i64 18)
; # (push M NIL)
  %99 = alloca i64, i64 2, align 16
  %100 = ptrtoint i64* %99 to i64
  %101 = inttoptr i64 %100 to i64*
  store i64 %98, i64* %101
; # (link (push M NIL))
  %102 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %103 = load i64, i64* %102
  %104 = inttoptr i64 %100 to i64*
  %105 = getelementptr i64, i64* %104, i32 1
  store i64 %103, i64* %105
  %106 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %100, i64* %106
; # (push ZERO NIL)
  %107 = alloca i64, i64 2, align 16
  %108 = ptrtoint i64* %107 to i64
  %109 = inttoptr i64 %108 to i64*
  store i64 2, i64* %109
; # (link (push ZERO NIL))
  %110 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %111 = load i64, i64* %110
  %112 = inttoptr i64 %108 to i64*
  %113 = getelementptr i64, i64* %112, i32 1
  store i64 %111, i64* %113
  %114 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %108, i64* %114
; # (dig Y)
  %115 = add i64 %97, -4
; # (val (dig Y))
  %116 = inttoptr i64 %115 to i64*
  %117 = load i64, i64* %116
; # (boxNum (val (dig Y)))
  %118 = call i64 @boxNum(i64 %117)
; # (push C NIL)
  %119 = alloca i64, i64 2, align 16
  %120 = ptrtoint i64* %119 to i64
  %121 = inttoptr i64 %120 to i64*
  store i64 %118, i64* %121
; # (link (push C NIL))
  %122 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %123 = load i64, i64* %122
  %124 = inttoptr i64 %120 to i64*
  %125 = getelementptr i64, i64* %124, i32 1
  store i64 %123, i64* %125
  %126 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %120, i64* %126
; # (while (big? (setq Y (val (big Y)))) (setq C (set (big C) (boxNum...
  br label %$32
$32:
  %127 = phi i64 [%97, %$22], [%136, %$33] ; # Y
  %128 = phi i64 [%98, %$22], [%146, %$33] ; # M
  %129 = phi i64 [%108, %$22], [%138, %$33] ; # R
  %130 = phi i64 [%118, %$22], [%144, %$33] ; # C
; # (big Y)
  %131 = add i64 %127, 4
; # (val (big Y))
  %132 = inttoptr i64 %131 to i64*
  %133 = load i64, i64* %132
; # (big? (setq Y (val (big Y))))
  %134 = and i64 %133, 4
  %135 = icmp ne i64 %134, 0
  br i1 %135, label %$33, label %$34
$33:
  %136 = phi i64 [%133, %$32] ; # Y
  %137 = phi i64 [%128, %$32] ; # M
  %138 = phi i64 [%129, %$32] ; # R
  %139 = phi i64 [%130, %$32] ; # C
; # (set (big C) (boxNum (val (dig Y))))
; # (big C)
  %140 = add i64 %139, 4
; # (dig Y)
  %141 = add i64 %136, -4
; # (val (dig Y))
  %142 = inttoptr i64 %141 to i64*
  %143 = load i64, i64* %142
; # (boxNum (val (dig Y)))
  %144 = call i64 @boxNum(i64 %143)
  %145 = inttoptr i64 %140 to i64*
  store i64 %144, i64* %145
; # (set M* (consNum 0 M))
; # (consNum 0 M)
  %146 = call i64 @consNum(i64 0, i64 %137)
  %147 = inttoptr i64 %100 to i64*
  store i64 %146, i64* %147
  br label %$32
$34:
  %148 = phi i64 [%133, %$32] ; # Y
  %149 = phi i64 [%128, %$32] ; # M
  %150 = phi i64 [%129, %$32] ; # R
  %151 = phi i64 [%130, %$32] ; # C
; # (set (big C) Y)
; # (big C)
  %152 = add i64 %151, 4
  %153 = inttoptr i64 %152 to i64*
  store i64 %148, i64* %153
; # (val C*)
  %154 = inttoptr i64 %120 to i64*
  %155 = load i64, i64* %154
; # (safe (val C*))
  %156 = inttoptr i64 %22 to i64*
  store i64 %155, i64* %156
; # (while (le0 (cmpu M Y)) (twiceBig M) (twiceBig M))
  br label %$35
$35:
  %157 = phi i64 [%155, %$34], [%163, %$36] ; # Y
  %158 = phi i64 [%149, %$34], [%164, %$36] ; # M
  %159 = phi i64 [%150, %$34], [%165, %$36] ; # R
  %160 = phi i64 [%151, %$34], [%166, %$36] ; # C
; # (cmpu M Y)
  %161 = call i64 @cmpu(i64 %158, i64 %157)
; # (le0 (cmpu M Y))
  %162 = icmp sle i64 %161, 0
  br i1 %162, label %$36, label %$37
$36:
  %163 = phi i64 [%157, %$35] ; # Y
  %164 = phi i64 [%158, %$35] ; # M
  %165 = phi i64 [%159, %$35] ; # R
  %166 = phi i64 [%160, %$35] ; # C
; # (twiceBig M)
  %167 = call i64 @twiceBig(i64 %164)
; # (twiceBig M)
  %168 = call i64 @twiceBig(i64 %164)
  br label %$35
$37:
  %169 = phi i64 [%157, %$35] ; # Y
  %170 = phi i64 [%158, %$35] ; # M
  %171 = phi i64 [%159, %$35] ; # R
  %172 = phi i64 [%160, %$35] ; # C
; # (loop (let N (set C* (addu (val R) M)) (when (ge0 (cmpu Y N)) (se...
  br label %$38
$38:
  %173 = phi i64 [%169, %$37], [%203, %$41] ; # Y
  %174 = phi i64 [%170, %$37], [%204, %$41] ; # M
  %175 = phi i64 [%171, %$37], [%205, %$41] ; # R
  %176 = phi i64 [%172, %$37], [%206, %$41] ; # C
; # (let N (set C* (addu (val R) M)) (when (ge0 (cmpu Y N)) (setq Y (...
; # (set C* (addu (val R) M))
; # (val R)
  %177 = inttoptr i64 %175 to i64*
  %178 = load i64, i64* %177
; # (addu (val R) M)
  %179 = call i64 @addu(i64 %178, i64 %174)
  %180 = inttoptr i64 %120 to i64*
  store i64 %179, i64* %180
; # (when (ge0 (cmpu Y N)) (setq Y (safe (subu Y N))) (set R (addu N ...
; # (cmpu Y N)
  %181 = call i64 @cmpu(i64 %173, i64 %179)
; # (ge0 (cmpu Y N))
  %182 = icmp sge i64 %181, 0
  br i1 %182, label %$39, label %$40
$39:
  %183 = phi i64 [%173, %$38] ; # Y
  %184 = phi i64 [%174, %$38] ; # M
  %185 = phi i64 [%175, %$38] ; # R
  %186 = phi i64 [%176, %$38] ; # C
; # (subu Y N)
  %187 = call i64 @subu(i64 %183, i64 %179)
; # (safe (subu Y N))
  %188 = inttoptr i64 %22 to i64*
  store i64 %187, i64* %188
; # (set R (addu N M))
; # (addu N M)
  %189 = call i64 @addu(i64 %179, i64 %184)
  %190 = inttoptr i64 %185 to i64*
  store i64 %189, i64* %190
  br label %$40
$40:
  %191 = phi i64 [%173, %$38], [%187, %$39] ; # Y
  %192 = phi i64 [%174, %$38], [%184, %$39] ; # M
  %193 = phi i64 [%175, %$38], [%185, %$39] ; # R
  %194 = phi i64 [%176, %$38], [%186, %$39] ; # C
; # (set R (half (val R)))
; # (val R)
  %195 = inttoptr i64 %193 to i64*
  %196 = load i64, i64* %195
; # (half (val R))
  %197 = call i64 @half(i64 %196)
  %198 = inttoptr i64 %193 to i64*
  store i64 %197, i64* %198
; # (? (== ZERO (setq M (set M* (half (half M))))))
; # (set M* (half (half M)))
; # (half M)
  %199 = call i64 @half(i64 %192)
; # (half (half M))
  %200 = call i64 @half(i64 %199)
  %201 = inttoptr i64 %100 to i64*
  store i64 %200, i64* %201
; # (== ZERO (setq M (set M* (half (half M)))))
  %202 = icmp eq i64 2, %200
  br i1 %202, label %$42, label %$41
$41:
  %203 = phi i64 [%191, %$40] ; # Y
  %204 = phi i64 [%200, %$40] ; # M
  %205 = phi i64 [%193, %$40] ; # R
  %206 = phi i64 [%194, %$40] ; # C
  br label %$38
$42:
  %207 = phi i64 [%191, %$40] ; # Y
  %208 = phi i64 [%200, %$40] ; # M
  %209 = phi i64 [%193, %$40] ; # R
  %210 = phi i64 [%194, %$40] ; # C
  %211 = phi i64 [0, %$40] ; # ->
; # (val R)
  %212 = inttoptr i64 %209 to i64*
  %213 = load i64, i64* %212
; # (if (or (nil? Z) (ge0 (cmpu R Y))) R (addu R ONE))
; # (or (nil? Z) (ge0 (cmpu R Y)))
; # (nil? Z)
  %214 = icmp eq i64 %39, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %214, label %$43, label %$44
$44:
  %215 = phi i64 [%207, %$42] ; # Y
  %216 = phi i64 [%208, %$42] ; # M
  %217 = phi i64 [%213, %$42] ; # R
  %218 = phi i64 [%210, %$42] ; # C
; # (cmpu R Y)
  %219 = call i64 @cmpu(i64 %217, i64 %215)
; # (ge0 (cmpu R Y))
  %220 = icmp sge i64 %219, 0
  br label %$43
$43:
  %221 = phi i64 [%207, %$42], [%215, %$44] ; # Y
  %222 = phi i64 [%208, %$42], [%216, %$44] ; # M
  %223 = phi i64 [%213, %$42], [%217, %$44] ; # R
  %224 = phi i64 [%210, %$42], [%218, %$44] ; # C
  %225 = phi i1 [1, %$42], [%220, %$44] ; # ->
  br i1 %225, label %$45, label %$46
$45:
  %226 = phi i64 [%221, %$43] ; # Y
  %227 = phi i64 [%222, %$43] ; # M
  %228 = phi i64 [%223, %$43] ; # R
  %229 = phi i64 [%224, %$43] ; # C
  br label %$47
$46:
  %230 = phi i64 [%221, %$43] ; # Y
  %231 = phi i64 [%222, %$43] ; # M
  %232 = phi i64 [%223, %$43] ; # R
  %233 = phi i64 [%224, %$43] ; # C
; # (addu R ONE)
  %234 = call i64 @addu(i64 %232, i64 18)
  br label %$47
$47:
  %235 = phi i64 [%226, %$45], [%230, %$46] ; # Y
  %236 = phi i64 [%227, %$45], [%231, %$46] ; # M
  %237 = phi i64 [%228, %$45], [%232, %$46] ; # R
  %238 = phi i64 [%229, %$45], [%233, %$46] ; # C
  %239 = phi i64 [%228, %$45], [%234, %$46] ; # ->
  br label %$23
$23:
  %240 = phi i64 [%91, %$29], [%235, %$47] ; # Y
  %241 = phi i64 [%96, %$29], [%239, %$47] ; # ->
; # (drop *Safe)
  %242 = inttoptr i64 %22 to i64*
  %243 = getelementptr i64, i64* %242, i32 1
  %244 = load i64, i64* %243
  %245 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %244, i64* %245
  br label %$9
$9:
  %246 = phi i64 [%13, %$7], [%241, %$23] ; # ->
  ret i64 %246
}

define i64 @initSeed(i64) align 8 {
$1:
; # (let C 0 (while (pair X) (inc 'C (initSeed (++ X)))) (unless (nil...
; # (while (pair X) (inc 'C (initSeed (++ X))))
  br label %$2
$2:
  %1 = phi i64 [%0, %$1], [%10, %$3] ; # X
  %2 = phi i64 [0, %$1], [%12, %$3] ; # C
; # (pair X)
  %3 = and i64 %1, 15
  %4 = icmp eq i64 %3, 0
  br i1 %4, label %$3, label %$4
$3:
  %5 = phi i64 [%1, %$2] ; # X
  %6 = phi i64 [%2, %$2] ; # C
; # (++ X)
  %7 = inttoptr i64 %5 to i64*
  %8 = load i64, i64* %7
  %9 = getelementptr i64, i64* %7, i32 1
  %10 = load i64, i64* %9
; # (initSeed (++ X))
  %11 = call i64 @initSeed(i64 %8)
; # (inc 'C (initSeed (++ X)))
  %12 = add i64 %6, %11
  br label %$2
$4:
  %13 = phi i64 [%1, %$2] ; # X
  %14 = phi i64 [%2, %$2] ; # C
; # (unless (nil? X) (unless (num? X) (setq X (name (& (val (tail X))...
; # (nil? X)
  %15 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %15, label %$6, label %$5
$5:
  %16 = phi i64 [%13, %$4] ; # X
  %17 = phi i64 [%14, %$4] ; # C
; # (unless (num? X) (setq X (name (& (val (tail X)) -9))))
; # (num? X)
  %18 = and i64 %16, 6
  %19 = icmp ne i64 %18, 0
  br i1 %19, label %$8, label %$7
$7:
  %20 = phi i64 [%16, %$5] ; # X
  %21 = phi i64 [%17, %$5] ; # C
; # (tail X)
  %22 = add i64 %20, -8
; # (val (tail X))
  %23 = inttoptr i64 %22 to i64*
  %24 = load i64, i64* %23
; # (& (val (tail X)) -9)
  %25 = and i64 %24, -9
; # (name (& (val (tail X)) -9))
  br label %$9
$9:
  %26 = phi i64 [%25, %$7], [%32, %$10] ; # Tail
  %27 = and i64 %26, 6
  %28 = icmp ne i64 %27, 0
  br i1 %28, label %$11, label %$10
$10:
  %29 = phi i64 [%26, %$9] ; # Tail
  %30 = inttoptr i64 %29 to i64*
  %31 = getelementptr i64, i64* %30, i32 1
  %32 = load i64, i64* %31
  br label %$9
$11:
  %33 = phi i64 [%26, %$9] ; # Tail
  br label %$8
$8:
  %34 = phi i64 [%16, %$5], [%33, %$11] ; # X
  %35 = phi i64 [%17, %$5], [%21, %$11] ; # C
; # (if (cnt? X) (inc 'C (shr X 3)) (when (sign? X) (inc 'C) (setq X ...
; # (cnt? X)
  %36 = and i64 %34, 2
  %37 = icmp ne i64 %36, 0
  br i1 %37, label %$12, label %$13
$12:
  %38 = phi i64 [%34, %$8] ; # X
  %39 = phi i64 [%35, %$8] ; # C
; # (shr X 3)
  %40 = lshr i64 %38, 3
; # (inc 'C (shr X 3))
  %41 = add i64 %39, %40
  br label %$14
$13:
  %42 = phi i64 [%34, %$8] ; # X
  %43 = phi i64 [%35, %$8] ; # C
; # (when (sign? X) (inc 'C) (setq X (pos X)))
; # (sign? X)
  %44 = and i64 %42, 8
  %45 = icmp ne i64 %44, 0
  br i1 %45, label %$15, label %$16
$15:
  %46 = phi i64 [%42, %$13] ; # X
  %47 = phi i64 [%43, %$13] ; # C
; # (inc 'C)
  %48 = add i64 %47, 1
; # (pos X)
  %49 = and i64 %46, -9
  br label %$16
$16:
  %50 = phi i64 [%42, %$13], [%49, %$15] ; # X
  %51 = phi i64 [%43, %$13], [%48, %$15] ; # C
; # (loop (inc 'C (val (dig X))) (? (cnt? (setq X (val (big X))))))
  br label %$17
$17:
  %52 = phi i64 [%50, %$16], [%63, %$18] ; # X
  %53 = phi i64 [%51, %$16], [%64, %$18] ; # C
; # (dig X)
  %54 = add i64 %52, -4
; # (val (dig X))
  %55 = inttoptr i64 %54 to i64*
  %56 = load i64, i64* %55
; # (inc 'C (val (dig X)))
  %57 = add i64 %53, %56
; # (? (cnt? (setq X (val (big X)))))
; # (big X)
  %58 = add i64 %52, 4
; # (val (big X))
  %59 = inttoptr i64 %58 to i64*
  %60 = load i64, i64* %59
; # (cnt? (setq X (val (big X))))
  %61 = and i64 %60, 2
  %62 = icmp ne i64 %61, 0
  br i1 %62, label %$19, label %$18
$18:
  %63 = phi i64 [%60, %$17] ; # X
  %64 = phi i64 [%57, %$17] ; # C
  br label %$17
$19:
  %65 = phi i64 [%60, %$17] ; # X
  %66 = phi i64 [%57, %$17] ; # C
  %67 = phi i64 [0, %$17] ; # ->
; # (int X)
  %68 = lshr i64 %65, 4
; # (inc 'C (int X))
  %69 = add i64 %66, %68
  br label %$14
$14:
  %70 = phi i64 [%38, %$12], [%65, %$19] ; # X
  %71 = phi i64 [%41, %$12], [%69, %$19] ; # C
  %72 = phi i64 [%41, %$12], [%69, %$19] ; # ->
  br label %$6
$6:
  %73 = phi i64 [%13, %$4], [%70, %$14] ; # X
  %74 = phi i64 [%14, %$4], [%71, %$14] ; # C
  ret i64 %74
}

define i64 @_Seed(i64) align 8 {
$1:
; # (let N (mul 6364136223846793005 (initSeed (eval (cadr Exe)))) (se...
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (initSeed (eval (cadr Exe)))
  %14 = call i64 @initSeed(i64 %13)
; # (mul 6364136223846793005 (initSeed (eval (cadr Exe))))
  %15 = zext i64 %14 to i128
  %16 = mul i128 6364136223846793005, %15
  %17 = lshr i128 %16, 64
  %18 = trunc i128 %17 to i64
  %19 = trunc i128 %16 to i64
; # (set $SeedL N $SeedH @@@)
  store i64 %19, i64* @$SeedL
  store i64 %18, i64* @$SeedH
; # (- 32 3)
; # (shr N (- 32 3))
  %20 = lshr i64 %19, 29
; # (& (shr N (- 32 3)) -8)
  %21 = and i64 %20, -8
; # (| (& (shr N (- 32 3)) -8) 2)
  %22 = or i64 %21, 2
  ret i64 %22
}

define i64 @_Hash(i64) align 8 {
$1:
; # (let (N (initSeed (eval (cadr Exe))) C 64 R 0) (loop (when (& (x|...
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (initSeed (eval (cadr Exe)))
  %14 = call i64 @initSeed(i64 %13)
; # (loop (when (& (x| N R) 1) (setq R (x| R (hex "14002")))) (setq N...
  br label %$7
$7:
  %15 = phi i64 [%14, %$2], [%32, %$10] ; # N
  %16 = phi i64 [64, %$2], [%33, %$10] ; # C
  %17 = phi i64 [0, %$2], [%34, %$10] ; # R
; # (when (& (x| N R) 1) (setq R (x| R (hex "14002"))))
; # (x| N R)
  %18 = xor i64 %15, %17
; # (& (x| N R) 1)
  %19 = and i64 %18, 1
  %20 = icmp ne i64 %19, 0
  br i1 %20, label %$8, label %$9
$8:
  %21 = phi i64 [%15, %$7] ; # N
  %22 = phi i64 [%16, %$7] ; # C
  %23 = phi i64 [%17, %$7] ; # R
; # (x| R (hex "14002"))
  %24 = xor i64 %23, 81922
  br label %$9
$9:
  %25 = phi i64 [%15, %$7], [%21, %$8] ; # N
  %26 = phi i64 [%16, %$7], [%22, %$8] ; # C
  %27 = phi i64 [%17, %$7], [%24, %$8] ; # R
; # (shr N 1)
  %28 = lshr i64 %25, 1
; # (shr R 1)
  %29 = lshr i64 %27, 1
; # (? (=0 (dec 'C)))
; # (dec 'C)
  %30 = sub i64 %26, 1
; # (=0 (dec 'C))
  %31 = icmp eq i64 %30, 0
  br i1 %31, label %$11, label %$10
$10:
  %32 = phi i64 [%28, %$9] ; # N
  %33 = phi i64 [%30, %$9] ; # C
  %34 = phi i64 [%29, %$9] ; # R
  br label %$7
$11:
  %35 = phi i64 [%28, %$9] ; # N
  %36 = phi i64 [%30, %$9] ; # C
  %37 = phi i64 [%29, %$9] ; # R
  %38 = phi i64 [0, %$9] ; # ->
; # (inc R)
  %39 = add i64 %37, 1
; # (cnt (inc R))
  %40 = shl i64 %39, 4
  %41 = or i64 %40, 2
  ret i64 %41
}

define i64 @_Rand(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (eval (++ X)) N (add (mul 6364136223846793005...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (val $SeedL)
  %16 = load i64, i64* @$SeedL
; # (mul 6364136223846793005 (val $SeedL))
  %17 = zext i64 %16 to i128
  %18 = mul i128 6364136223846793005, %17
  %19 = lshr i128 %18, 64
  %20 = trunc i128 %19 to i64
  %21 = trunc i128 %18 to i64
; # (add (mul 6364136223846793005 (val $SeedL)) 1)
  %22 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %21, i64 1)
  %23 = extractvalue {i64, i1} %22, 1
  %24 = extractvalue {i64, i1} %22, 0
; # (set $SeedL N $SeedH (+ @@@ @@))
  store i64 %24, i64* @$SeedL
; # (+ @@@ @@)
  %25 = zext i1 %23 to i64
  %26 = add i64 %20, %25
  store i64 %26, i64* @$SeedH
; # (cond ((nil? Y) (| (& (shr N (- 32 3)) -8) 2)) ((t? Y) (add N N) ...
; # (nil? Y)
  %27 = icmp eq i64 %15, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %27, label %$9, label %$8
$9:
  %28 = phi i64 [%15, %$2] ; # Y
  %29 = phi i64 [%24, %$2] ; # N
; # (- 32 3)
; # (shr N (- 32 3))
  %30 = lshr i64 %29, 29
; # (& (shr N (- 32 3)) -8)
  %31 = and i64 %30, -8
; # (| (& (shr N (- 32 3)) -8) 2)
  %32 = or i64 %31, 2
  br label %$7
$8:
  %33 = phi i64 [%15, %$2] ; # Y
  %34 = phi i64 [%24, %$2] ; # N
; # (t? Y)
  %35 = icmp eq i64 %33, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %35, label %$11, label %$10
$11:
  %36 = phi i64 [%33, %$8] ; # Y
  %37 = phi i64 [%34, %$8] ; # N
; # (add N N)
  %38 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %37, i64 %37)
  %39 = extractvalue {i64, i1} %38, 1
  %40 = extractvalue {i64, i1} %38, 0
; # (if @@ Y $Nil)
  br i1 %39, label %$12, label %$13
$12:
  %41 = phi i64 [%36, %$11] ; # Y
  %42 = phi i64 [%37, %$11] ; # N
  br label %$14
$13:
  %43 = phi i64 [%36, %$11] ; # Y
  %44 = phi i64 [%37, %$11] ; # N
  br label %$14
$14:
  %45 = phi i64 [%41, %$12], [%43, %$13] ; # Y
  %46 = phi i64 [%42, %$12], [%44, %$13] ; # N
  %47 = phi i64 [%41, %$12], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$13] ; # ->
  br label %$7
$10:
  %48 = phi i64 [%33, %$8] ; # Y
  %49 = phi i64 [%34, %$8] ; # N
; # (when (sign? (needCnt Exe Y)) (argErr Exe Y))
; # (needCnt Exe Y)
  %50 = and i64 %48, 2
  %51 = icmp ne i64 %50, 0
  br i1 %51, label %$16, label %$15
$15:
  call void @cntErr(i64 %0, i64 %48)
  unreachable
$16:
; # (sign? (needCnt Exe Y))
  %52 = and i64 %48, 8
  %53 = icmp ne i64 %52, 0
  br i1 %53, label %$17, label %$18
$17:
  %54 = phi i64 [%48, %$16] ; # Y
  %55 = phi i64 [%49, %$16] ; # N
; # (argErr Exe Y)
  call void @argErr(i64 %0, i64 %54)
  unreachable
$18:
  %56 = phi i64 [%48, %$16] ; # Y
  %57 = phi i64 [%49, %$16] ; # N
; # (let A (int Y) (when (sign? (needCnt Exe (setq Y (eval (car X))))...
; # (int Y)
  %58 = lshr i64 %56, 4
; # (when (sign? (needCnt Exe (setq Y (eval (car X))))) (argErr Exe Y...
; # (car X)
  %59 = inttoptr i64 %7 to i64*
  %60 = load i64, i64* %59
; # (eval (car X))
  %61 = and i64 %60, 6
  %62 = icmp ne i64 %61, 0
  br i1 %62, label %$21, label %$20
$21:
  br label %$19
$20:
  %63 = and i64 %60, 8
  %64 = icmp ne i64 %63, 0
  br i1 %64, label %$23, label %$22
$23:
  %65 = inttoptr i64 %60 to i64*
  %66 = load i64, i64* %65
  br label %$19
$22:
  %67 = call i64 @evList(i64 %60)
  br label %$19
$19:
  %68 = phi i64 [%60, %$21], [%66, %$23], [%67, %$22] ; # ->
; # (needCnt Exe (setq Y (eval (car X))))
  %69 = and i64 %68, 2
  %70 = icmp ne i64 %69, 0
  br i1 %70, label %$25, label %$24
$24:
  call void @cntErr(i64 %0, i64 %68)
  unreachable
$25:
; # (sign? (needCnt Exe (setq Y (eval (car X)))))
  %71 = and i64 %68, 8
  %72 = icmp ne i64 %71, 0
  br i1 %72, label %$26, label %$27
$26:
  %73 = phi i64 [%68, %$25] ; # Y
  %74 = phi i64 [%57, %$25] ; # N
; # (argErr Exe Y)
  call void @argErr(i64 %0, i64 %73)
  unreachable
$27:
  %75 = phi i64 [%68, %$25] ; # Y
  %76 = phi i64 [%57, %$25] ; # N
; # (let B (inc (int Y)) (when (>= A B) (argErr Exe Y)) (setq N (+ (%...
; # (int Y)
  %77 = lshr i64 %75, 4
; # (inc (int Y))
  %78 = add i64 %77, 1
; # (when (>= A B) (argErr Exe Y))
; # (>= A B)
  %79 = icmp uge i64 %58, %78
  br i1 %79, label %$28, label %$29
$28:
  %80 = phi i64 [%75, %$27] ; # Y
  %81 = phi i64 [%76, %$27] ; # N
; # (argErr Exe Y)
  call void @argErr(i64 %0, i64 %80)
  unreachable
$29:
  %82 = phi i64 [%75, %$27] ; # Y
  %83 = phi i64 [%76, %$27] ; # N
; # (val $SeedH)
  %84 = load i64, i64* @$SeedH
; # (val $SeedL)
  %85 = load i64, i64* @$SeedL
; # (shr (val $SeedH) (val $SeedL) 32)
  %86 = call i64 @llvm.fshr.i64(i64 %84, i64 %85, i64 32)
; # (- B A)
  %87 = sub i64 %78, %58
; # (% (shr (val $SeedH) (val $SeedL) 32) (- B A))
  %88 = urem i64 %86, %87
; # (+ (% (shr (val $SeedH) (val $SeedL) 32) (- B A)) A)
  %89 = add i64 %88, %58
; # (if (lt0 N) (sign (cnt (- N))) (cnt N))
; # (lt0 N)
  %90 = icmp slt i64 %89, 0
  br i1 %90, label %$30, label %$31
$30:
  %91 = phi i64 [%82, %$29] ; # Y
  %92 = phi i64 [%89, %$29] ; # N
; # (- N)
  %93 = sub i64 0, %92
; # (cnt (- N))
  %94 = shl i64 %93, 4
  %95 = or i64 %94, 2
; # (sign (cnt (- N)))
  %96 = or i64 %95, 8
  br label %$32
$31:
  %97 = phi i64 [%82, %$29] ; # Y
  %98 = phi i64 [%89, %$29] ; # N
; # (cnt N)
  %99 = shl i64 %98, 4
  %100 = or i64 %99, 2
  br label %$32
$32:
  %101 = phi i64 [%91, %$30], [%97, %$31] ; # Y
  %102 = phi i64 [%92, %$30], [%98, %$31] ; # N
  %103 = phi i64 [%96, %$30], [%100, %$31] ; # ->
  br label %$7
$7:
  %104 = phi i64 [%28, %$9], [%45, %$14], [%101, %$32] ; # Y
  %105 = phi i64 [%29, %$9], [%46, %$14], [%102, %$32] ; # N
  %106 = phi i64 [%32, %$9], [%47, %$14], [%103, %$32] ; # ->
  ret i64 %106
}

define i64 @bufSize(i64) align 8 {
$1:
; # (let N 1 (while (big? Nm) (inc 'N 8) (setq Nm (val (big Nm)))) (s...
; # (while (big? Nm) (inc 'N 8) (setq Nm (val (big Nm))))
  br label %$2
$2:
  %1 = phi i64 [%0, %$1], [%10, %$3] ; # Nm
  %2 = phi i64 [1, %$1], [%7, %$3] ; # N
; # (big? Nm)
  %3 = and i64 %1, 4
  %4 = icmp ne i64 %3, 0
  br i1 %4, label %$3, label %$4
$3:
  %5 = phi i64 [%1, %$2] ; # Nm
  %6 = phi i64 [%2, %$2] ; # N
; # (inc 'N 8)
  %7 = add i64 %6, 8
; # (big Nm)
  %8 = add i64 %5, 4
; # (val (big Nm))
  %9 = inttoptr i64 %8 to i64*
  %10 = load i64, i64* %9
  br label %$2
$4:
  %11 = phi i64 [%1, %$2] ; # Nm
  %12 = phi i64 [%2, %$2] ; # N
; # (int Nm)
  %13 = lshr i64 %11, 4
; # (while Nm (inc 'N) (setq Nm (shr Nm 8)))
  br label %$5
$5:
  %14 = phi i64 [%13, %$4], [%20, %$6] ; # Nm
  %15 = phi i64 [%12, %$4], [%19, %$6] ; # N
  %16 = icmp ne i64 %14, 0
  br i1 %16, label %$6, label %$7
$6:
  %17 = phi i64 [%14, %$5] ; # Nm
  %18 = phi i64 [%15, %$5] ; # N
; # (inc 'N)
  %19 = add i64 %18, 1
; # (shr Nm 8)
  %20 = lshr i64 %17, 8
  br label %$5
$7:
  %21 = phi i64 [%14, %$5] ; # Nm
  %22 = phi i64 [%15, %$5] ; # N
  ret i64 %22
}

define i64 @pathSize(i64) align 8 {
$1:
; # (let (Len (bufSize Nm) N (if (cnt? Nm) (int @) (val (dig @))) B (...
; # (bufSize Nm)
  %1 = call i64 @bufSize(i64 %0)
; # (if (cnt? Nm) (int @) (val (dig @)))
; # (cnt? Nm)
  %2 = and i64 %0, 2
  %3 = icmp ne i64 %2, 0
  br i1 %3, label %$2, label %$3
$2:
; # (int @)
  %4 = lshr i64 %0, 4
  br label %$4
$3:
; # (dig @)
  %5 = add i64 %0, -4
; # (val (dig @))
  %6 = inttoptr i64 %5 to i64*
  %7 = load i64, i64* %6
  br label %$4
$4:
  %8 = phi i64 [%4, %$2], [%7, %$3] ; # ->
; # (i8 N)
  %9 = trunc i64 %8 to i8
; # (cond ((or (== B (char "@")) (and (== B (char "+")) (== (i8 (shr ...
; # (or (== B (char "@")) (and (== B (char "+")) (== (i8 (shr N 8)) (...
; # (== B (char "@"))
  %10 = icmp eq i8 %9, 64
  br i1 %10, label %$6, label %$7
$7:
; # (and (== B (char "+")) (== (i8 (shr N 8)) (char "@")))
; # (== B (char "+"))
  %11 = icmp eq i8 %9, 43
  br i1 %11, label %$9, label %$8
$9:
; # (shr N 8)
  %12 = lshr i64 %8, 8
; # (i8 (shr N 8))
  %13 = trunc i64 %12 to i8
; # (== (i8 (shr N 8)) (char "@"))
  %14 = icmp eq i8 %13, 64
  br label %$8
$8:
  %15 = phi i1 [0, %$7], [%14, %$9] ; # ->
  br label %$6
$6:
  %16 = phi i1 [1, %$4], [%15, %$8] ; # ->
  br i1 %16, label %$11, label %$10
$11:
; # (val $PilLen)
  %17 = load i64, i64* @$PilLen
; # (dec Len)
  %18 = sub i64 %1, 1
; # (+ (val $PilLen) (dec Len))
  %19 = add i64 %17, %18
  br label %$5
$10:
; # (or (== B (char "~")) (and (== B (char "+")) (== (i8 (shr N 8)) (...
; # (== B (char "~"))
  %20 = icmp eq i8 %9, 126
  br i1 %20, label %$12, label %$13
$13:
; # (and (== B (char "+")) (== (i8 (shr N 8)) (char "~")))
; # (== B (char "+"))
  %21 = icmp eq i8 %9, 43
  br i1 %21, label %$15, label %$14
$15:
; # (shr N 8)
  %22 = lshr i64 %8, 8
; # (i8 (shr N 8))
  %23 = trunc i64 %22 to i8
; # (== (i8 (shr N 8)) (char "~"))
  %24 = icmp eq i8 %23, 126
  br label %$14
$14:
  %25 = phi i1 [0, %$13], [%24, %$15] ; # ->
  br label %$12
$12:
  %26 = phi i1 [1, %$10], [%25, %$14] ; # ->
  br i1 %26, label %$17, label %$16
$17:
; # (val $UsrLen)
  %27 = load i64, i64* @$UsrLen
; # (dec Len)
  %28 = sub i64 %1, 1
; # (+ (val $UsrLen) (dec Len))
  %29 = add i64 %27, %28
  br label %$5
$16:
  br label %$5
$5:
  %30 = phi i64 [%19, %$11], [%29, %$17], [%1, %$16] ; # ->
  ret i64 %30
}

define i8* @bufString(i64, i8*) align 8 {
$1:
; # (let Q (push 0 Nm) (prog1 P (while (set P (symByte Q)) (inc 'P)))...
; # (push 0 Nm)
  %2 = alloca i64, i64 2, align 16
  store i64 0, i64* %2
  %3 = getelementptr i64, i64* %2, i32 1
  store i64 %0, i64* %3
; # (prog1 P (while (set P (symByte Q)) (inc 'P)))
; # (while (set P (symByte Q)) (inc 'P))
  br label %$2
$2:
  %4 = phi i8* [%1, %$1], [%8, %$3] ; # P
; # (set P (symByte Q))
; # (symByte Q)
  %5 = call i8 @symByte(i64* %2)
  store i8 %5, i8* %4
  %6 = icmp ne i8 %5, 0
  br i1 %6, label %$3, label %$4
$3:
  %7 = phi i8* [%4, %$2] ; # P
; # (inc 'P)
  %8 = getelementptr i8, i8* %7, i32 1
  br label %$2
$4:
  %9 = phi i8* [%4, %$2] ; # P
  ret i8* %1
}

define i8* @pathString(i64, i8*) align 8 {
$1:
; # (let (Q (push 0 Nm) B (symByte Q)) (prog1 P (when (== B (char "+"...
; # (push 0 Nm)
  %2 = alloca i64, i64 2, align 16
  store i64 0, i64* %2
  %3 = getelementptr i64, i64* %2, i32 1
  store i64 %0, i64* %3
; # (symByte Q)
  %4 = call i8 @symByte(i64* %2)
; # (prog1 P (when (== B (char "+")) (set P B) (inc 'P) (setq B (symB...
; # (when (== B (char "+")) (set P B) (inc 'P) (setq B (symByte Q)))
; # (== B (char "+"))
  %5 = icmp eq i8 %4, 43
  br i1 %5, label %$2, label %$3
$2:
  %6 = phi i8* [%1, %$1] ; # P
  %7 = phi i8 [%4, %$1] ; # B
; # (set P B)
  store i8 %7, i8* %6
; # (inc 'P)
  %8 = getelementptr i8, i8* %6, i32 1
; # (symByte Q)
  %9 = call i8 @symByte(i64* %2)
  br label %$3
$3:
  %10 = phi i8* [%1, %$1], [%8, %$2] ; # P
  %11 = phi i8 [%4, %$1], [%9, %$2] ; # B
; # (case B ((char "@") (when (val $PilLen) (memcpy P (val $PilHome) ...
  switch i8 %11, label %$4 [
    i8 64, label %$6
    i8 126, label %$7
  ]
$6:
  %12 = phi i8* [%10, %$3] ; # P
  %13 = phi i8 [%11, %$3] ; # B
; # (when (val $PilLen) (memcpy P (val $PilHome) @) (inc 'P @))
; # (val $PilLen)
  %14 = load i64, i64* @$PilLen
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$8, label %$9
$8:
  %16 = phi i8* [%12, %$6] ; # P
  %17 = phi i8 [%13, %$6] ; # B
; # (val $PilHome)
  %18 = load i8*, i8** @$PilHome
; # (memcpy P (val $PilHome) @)
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* %16, i8* %18, i64 %14, i1 0)
; # (inc 'P @)
  %19 = getelementptr i8, i8* %16, i64 %14
  br label %$9
$9:
  %20 = phi i8* [%12, %$6], [%19, %$8] ; # P
  %21 = phi i8 [%13, %$6], [%17, %$8] ; # B
  br label %$5
$7:
  %22 = phi i8* [%10, %$3] ; # P
  %23 = phi i8 [%11, %$3] ; # B
; # (when (val $UsrLen) (memcpy P (val $UsrHome) @) (inc 'P @))
; # (val $UsrLen)
  %24 = load i64, i64* @$UsrLen
  %25 = icmp ne i64 %24, 0
  br i1 %25, label %$10, label %$11
$10:
  %26 = phi i8* [%22, %$7] ; # P
  %27 = phi i8 [%23, %$7] ; # B
; # (val $UsrHome)
  %28 = load i8*, i8** @$UsrHome
; # (memcpy P (val $UsrHome) @)
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* %26, i8* %28, i64 %24, i1 0)
; # (inc 'P @)
  %29 = getelementptr i8, i8* %26, i64 %24
  br label %$11
$11:
  %30 = phi i8* [%22, %$7], [%29, %$10] ; # P
  %31 = phi i8 [%23, %$7], [%27, %$10] ; # B
  br label %$5
$4:
  %32 = phi i8* [%10, %$3] ; # P
  %33 = phi i8 [%11, %$3] ; # B
; # (set P B)
  store i8 %33, i8* %32
; # (inc 'P)
  %34 = getelementptr i8, i8* %32, i32 1
  br label %$5
$5:
  %35 = phi i8* [%20, %$9], [%30, %$11], [%34, %$4] ; # P
  %36 = phi i8 [%21, %$9], [%31, %$11], [%33, %$4] ; # B
; # (while (set P (symByte Q)) (inc 'P))
  br label %$12
$12:
  %37 = phi i8* [%35, %$5], [%43, %$13] ; # P
  %38 = phi i8 [%36, %$5], [%42, %$13] ; # B
; # (set P (symByte Q))
; # (symByte Q)
  %39 = call i8 @symByte(i64* %2)
  store i8 %39, i8* %37
  %40 = icmp ne i8 %39, 0
  br i1 %40, label %$13, label %$14
$13:
  %41 = phi i8* [%37, %$12] ; # P
  %42 = phi i8 [%38, %$12] ; # B
; # (inc 'P)
  %43 = getelementptr i8, i8* %41, i32 1
  br label %$12
$14:
  %44 = phi i8* [%37, %$12] ; # P
  %45 = phi i8 [%38, %$12] ; # B
  ret i8* %1
}

define i64 @mkChar(i32) align 8 {
$1:
; # (cond ((>= 127 C) (i64 C)) ((== TOP C) (hex "FF")) ((> (hex "800"...
; # (>= 127 C)
  %1 = icmp sge i32 127, %0
  br i1 %1, label %$4, label %$3
$4:
; # (i64 C)
  %2 = sext i32 %0 to i64
  br label %$2
$3:
; # (== TOP C)
  %3 = icmp eq i32 1114112, %0
  br i1 %3, label %$6, label %$5
$6:
  br label %$2
$5:
; # (> (hex "800") C)
  %4 = icmp sgt i32 2048, %0
  br i1 %4, label %$8, label %$7
$8:
; # (shr C 6)
  %5 = lshr i32 %0, 6
; # (& (shr C 6) (hex "1F"))
  %6 = and i32 %5, 31
; # (| (hex "C0") (& (shr C 6) (hex "1F")))
  %7 = or i32 192, %6
; # (& C (hex "3F"))
  %8 = and i32 %0, 63
; # (| (hex "80") (& C (hex "3F")))
  %9 = or i32 128, %8
; # (shl (| (hex "80") (& C (hex "3F"))) 8)
  %10 = shl i32 %9, 8
; # (| (| (hex "C0") (& (shr C 6) (hex "1F"))) (shl (| (hex "80") (& ...
  %11 = or i32 %7, %10
; # (i64 (| (| (hex "C0") (& (shr C 6) (hex "1F"))) (shl (| (hex "80"...
  %12 = sext i32 %11 to i64
  br label %$2
$7:
; # (> (hex "10000") C)
  %13 = icmp sgt i32 65536, %0
  br i1 %13, label %$10, label %$9
$10:
; # (shr C 12)
  %14 = lshr i32 %0, 12
; # (& (shr C 12) (hex "0F"))
  %15 = and i32 %14, 15
; # (| (hex "E0") (& (shr C 12) (hex "0F")))
  %16 = or i32 224, %15
; # (shr C 6)
  %17 = lshr i32 %0, 6
; # (& (shr C 6) (hex "3F"))
  %18 = and i32 %17, 63
; # (| (hex "80") (& (shr C 6) (hex "3F")))
  %19 = or i32 128, %18
; # (shl (| (hex "80") (& (shr C 6) (hex "3F"))) 8)
  %20 = shl i32 %19, 8
; # (| (| (hex "E0") (& (shr C 12) (hex "0F"))) (shl (| (hex "80") (&...
  %21 = or i32 %16, %20
; # (& C (hex "3F"))
  %22 = and i32 %0, 63
; # (| (hex "80") (& C (hex "3F")))
  %23 = or i32 128, %22
; # (shl (| (hex "80") (& C (hex "3F"))) 16)
  %24 = shl i32 %23, 16
; # (| (| (| (hex "E0") (& (shr C 12) (hex "0F"))) (shl (| (hex "80")...
  %25 = or i32 %21, %24
; # (i64 (| (| (| (hex "E0") (& (shr C 12) (hex "0F"))) (shl (| (hex ...
  %26 = sext i32 %25 to i64
  br label %$2
$9:
; # (shr C 18)
  %27 = lshr i32 %0, 18
; # (& (shr C 18) (hex "07"))
  %28 = and i32 %27, 7
; # (| (hex "F0") (& (shr C 18) (hex "07")))
  %29 = or i32 240, %28
; # (shr C 12)
  %30 = lshr i32 %0, 12
; # (& (shr C 12) (hex "3F"))
  %31 = and i32 %30, 63
; # (| (hex "80") (& (shr C 12) (hex "3F")))
  %32 = or i32 128, %31
; # (shl (| (hex "80") (& (shr C 12) (hex "3F"))) 8)
  %33 = shl i32 %32, 8
; # (| (| (hex "F0") (& (shr C 18) (hex "07"))) (shl (| (hex "80") (&...
  %34 = or i32 %29, %33
; # (shr C 6)
  %35 = lshr i32 %0, 6
; # (& (shr C 6) (hex "3F"))
  %36 = and i32 %35, 63
; # (| (hex "80") (& (shr C 6) (hex "3F")))
  %37 = or i32 128, %36
; # (shl (| (hex "80") (& (shr C 6) (hex "3F"))) 16)
  %38 = shl i32 %37, 16
; # (| (| (| (hex "F0") (& (shr C 18) (hex "07"))) (shl (| (hex "80")...
  %39 = or i32 %34, %38
; # (i64 (| (| (| (hex "F0") (& (shr C 18) (hex "07"))) (shl (| (hex ...
  %40 = sext i32 %39 to i64
; # (i64 C)
  %41 = sext i32 %0 to i64
; # (& (i64 C) (hex "3F"))
  %42 = and i64 %41, 63
; # (| (hex "80") (& (i64 C) (hex "3F")))
  %43 = or i64 128, %42
; # (shl (| (hex "80") (& (i64 C) (hex "3F"))) 24)
  %44 = shl i64 %43, 24
; # (| (i64 (| (| (| (hex "F0") (& (shr C 18) (hex "07"))) (shl (| (h...
  %45 = or i64 %40, %44
  br label %$2
$2:
  %46 = phi i64 [%2, %$4], [255, %$6], [%12, %$8], [%26, %$10], [%45, %$9] ; # ->
; # (cnt (cond ((>= 127 C) (i64 C)) ((== TOP C) (hex "FF")) ((> (hex ...
  %47 = shl i64 %46, 4
  %48 = or i64 %47, 2
; # (consStr (cnt (cond ((>= 127 C) (i64 C)) ((== TOP C) (hex "FF")) ...
  %49 = call i64 @consStr(i64 %48)
  ret i64 %49
}

define i64 @mkStr(i8*) align 8 {
$1:
; # (if Str (let P (push 4 NIL ZERO NIL) (link (ofs P 2) T) (while (v...
  %1 = icmp ne i8* %0, null
  br i1 %1, label %$2, label %$3
$2:
  %2 = phi i8* [%0, %$1] ; # Str
; # (let P (push 4 NIL ZERO NIL) (link (ofs P 2) T) (while (val Str) ...
; # (push 4 NIL ZERO NIL)
  %3 = alloca i64, i64 4, align 16
  store i64 4, i64* %3
  %4 = getelementptr i64, i64* %3, i32 2
  store i64 2, i64* %4
; # (ofs P 2)
  %5 = getelementptr i64, i64* %3, i32 2
; # (link (ofs P 2) T)
  %6 = ptrtoint i64* %5 to i64
  %7 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %8 = load i64, i64* %7
  %9 = inttoptr i64 %6 to i64*
  %10 = getelementptr i64, i64* %9, i32 1
  store i64 %8, i64* %10
  %11 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %6, i64* %11
; # (while (val Str) (byteSym @ P) (inc 'Str))
  br label %$5
$5:
  %12 = phi i8* [%2, %$2], [%16, %$6] ; # Str
; # (val Str)
  %13 = load i8, i8* %12
  %14 = icmp ne i8 %13, 0
  br i1 %14, label %$6, label %$7
$6:
  %15 = phi i8* [%12, %$5] ; # Str
; # (byteSym @ P)
  call void @byteSym(i8 %13, i64* %3)
; # (inc 'Str)
  %16 = getelementptr i8, i8* %15, i32 1
  br label %$5
$7:
  %17 = phi i8* [%12, %$5] ; # Str
; # (val 3 P)
  %18 = getelementptr i64, i64* %3, i32 2
  %19 = load i64, i64* %18
; # (consStr (val 3 P))
  %20 = call i64 @consStr(i64 %19)
; # (drop *Safe)
  %21 = inttoptr i64 %6 to i64*
  %22 = getelementptr i64, i64* %21, i32 1
  %23 = load i64, i64* %22
  %24 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %23, i64* %24
  br label %$4
$3:
  %25 = phi i8* [%0, %$1] ; # Str
  br label %$4
$4:
  %26 = phi i8* [%17, %$7], [%25, %$3] ; # Str
  %27 = phi i64 [%20, %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$3] ; # ->
  ret i64 %27
}

define i64 @mkStrE(i8*, i8*) align 8 {
$1:
; # (let P (push 4 NIL ZERO NIL) (link (ofs P 2) T) (loop (? (== Str ...
; # (push 4 NIL ZERO NIL)
  %2 = alloca i64, i64 4, align 16
  store i64 4, i64* %2
  %3 = getelementptr i64, i64* %2, i32 2
  store i64 2, i64* %3
; # (ofs P 2)
  %4 = getelementptr i64, i64* %2, i32 2
; # (link (ofs P 2) T)
  %5 = ptrtoint i64* %4 to i64
  %6 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %7 = load i64, i64* %6
  %8 = inttoptr i64 %5 to i64*
  %9 = getelementptr i64, i64* %8, i32 1
  store i64 %7, i64* %9
  %10 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %5, i64* %10
; # (loop (? (== Str End)) (? (=0 (val Str))) (byteSym @ P) (inc 'Str...
  br label %$2
$2:
  %11 = phi i8* [%0, %$1], [%17, %$5] ; # Str
; # (? (== Str End))
; # (== Str End)
  %12 = icmp eq i8* %11, %1
  br i1 %12, label %$4, label %$3
$3:
  %13 = phi i8* [%11, %$2] ; # Str
; # (? (=0 (val Str)))
; # (val Str)
  %14 = load i8, i8* %13
; # (=0 (val Str))
  %15 = icmp eq i8 %14, 0
  br i1 %15, label %$4, label %$5
$5:
  %16 = phi i8* [%13, %$3] ; # Str
; # (byteSym @ P)
  call void @byteSym(i8 %14, i64* %2)
; # (inc 'Str)
  %17 = getelementptr i8, i8* %16, i32 1
  br label %$2
$4:
  %18 = phi i8* [%11, %$2], [%13, %$3] ; # Str
  %19 = phi i64 [0, %$2], [0, %$3] ; # ->
; # (val 3 P)
  %20 = getelementptr i64, i64* %2, i32 2
  %21 = load i64, i64* %20
; # (consStr (val 3 P))
  %22 = call i64 @consStr(i64 %21)
; # (drop *Safe)
  %23 = inttoptr i64 %5 to i64*
  %24 = getelementptr i64, i64* %23, i32 1
  %25 = load i64, i64* %24
  %26 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %25, i64* %26
  ret i64 %22
}

define i8 @firstByte(i64) align 8 {
$1:
; # (cond ((nil? Sym) 0) ((sym? (val (tail Sym))) 0) ((cnt? (name @))...
; # (nil? Sym)
  %1 = icmp eq i64 %0, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %1, label %$4, label %$3
$4:
  br label %$2
$3:
; # (tail Sym)
  %2 = add i64 %0, -8
; # (val (tail Sym))
  %3 = inttoptr i64 %2 to i64*
  %4 = load i64, i64* %3
; # (sym? (val (tail Sym)))
  %5 = and i64 %4, 8
  %6 = icmp ne i64 %5, 0
  br i1 %6, label %$6, label %$5
$6:
  br label %$2
$5:
; # (name @)
  br label %$7
$7:
  %7 = phi i64 [%4, %$5], [%13, %$8] ; # Tail
  %8 = and i64 %7, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$9, label %$8
$8:
  %10 = phi i64 [%7, %$7] ; # Tail
  %11 = inttoptr i64 %10 to i64*
  %12 = getelementptr i64, i64* %11, i32 1
  %13 = load i64, i64* %12
  br label %$7
$9:
  %14 = phi i64 [%7, %$7] ; # Tail
; # (cnt? (name @))
  %15 = and i64 %14, 2
  %16 = icmp ne i64 %15, 0
  br i1 %16, label %$11, label %$10
$11:
; # (int @)
  %17 = lshr i64 %14, 4
  br label %$2
$10:
; # (dig @)
  %18 = add i64 %14, -4
; # (val (dig @))
  %19 = inttoptr i64 %18 to i64*
  %20 = load i64, i64* %19
  br label %$2
$2:
  %21 = phi i64 [0, %$4], [0, %$6], [%17, %$11], [%20, %$10] ; # ->
; # (i8 (cond ((nil? Sym) 0) ((sym? (val (tail Sym))) 0) ((cnt? (name...
  %22 = trunc i64 %21 to i8
  ret i8 %22
}

define i32 @firstChar(i64) align 8 {
$1:
; # (cond ((nil? Sym) 0) ((sym? (val (tail Sym))) 0) (T (symChar (pus...
; # (nil? Sym)
  %1 = icmp eq i64 %0, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %1, label %$4, label %$3
$4:
  br label %$2
$3:
; # (tail Sym)
  %2 = add i64 %0, -8
; # (val (tail Sym))
  %3 = inttoptr i64 %2 to i64*
  %4 = load i64, i64* %3
; # (sym? (val (tail Sym)))
  %5 = and i64 %4, 8
  %6 = icmp ne i64 %5, 0
  br i1 %6, label %$6, label %$5
$6:
  br label %$2
$5:
; # (name @)
  br label %$7
$7:
  %7 = phi i64 [%4, %$5], [%13, %$8] ; # Tail
  %8 = and i64 %7, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$9, label %$8
$8:
  %10 = phi i64 [%7, %$7] ; # Tail
  %11 = inttoptr i64 %10 to i64*
  %12 = getelementptr i64, i64* %11, i32 1
  %13 = load i64, i64* %12
  br label %$7
$9:
  %14 = phi i64 [%7, %$7] ; # Tail
; # (push 0 (name @))
  %15 = alloca i64, i64 2, align 16
  store i64 0, i64* %15
  %16 = getelementptr i64, i64* %15, i32 1
  store i64 %14, i64* %16
; # (symChar (push 0 (name @)))
  %17 = call i32 @symChar(i64* %15)
  br label %$2
$2:
  %18 = phi i32 [0, %$4], [0, %$6], [%17, %$9] ; # ->
  ret i32 %18
}

define i1 @isBlank(i64) align 8 {
$1:
; # (or (nil? X) (and (symb? X) (not (sym? (val (tail X)))) (let P (p...
; # (nil? X)
  %1 = icmp eq i64 %0, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %1, label %$2, label %$3
$3:
; # (and (symb? X) (not (sym? (val (tail X)))) (let P (push 0 (name @...
; # (symb? X)
  %2 = xor i64 %0, 8
  %3 = and i64 %2, 14
  %4 = icmp eq i64 %3, 0
  br i1 %4, label %$5, label %$4
$5:
; # (tail X)
  %5 = add i64 %0, -8
; # (val (tail X))
  %6 = inttoptr i64 %5 to i64*
  %7 = load i64, i64* %6
; # (sym? (val (tail X)))
  %8 = and i64 %7, 8
  %9 = icmp ne i64 %8, 0
; # (not (sym? (val (tail X))))
  %10 = icmp eq i1 %9, 0
  br i1 %10, label %$6, label %$4
$6:
; # (let P (push 0 (name @)) (loop (? (=0 (symByte P)) YES) (? (> @ 3...
; # (name @)
  br label %$7
$7:
  %11 = phi i64 [%7, %$6], [%17, %$8] ; # Tail
  %12 = and i64 %11, 6
  %13 = icmp ne i64 %12, 0
  br i1 %13, label %$9, label %$8
$8:
  %14 = phi i64 [%11, %$7] ; # Tail
  %15 = inttoptr i64 %14 to i64*
  %16 = getelementptr i64, i64* %15, i32 1
  %17 = load i64, i64* %16
  br label %$7
$9:
  %18 = phi i64 [%11, %$7] ; # Tail
; # (push 0 (name @))
  %19 = alloca i64, i64 2, align 16
  store i64 0, i64* %19
  %20 = getelementptr i64, i64* %19, i32 1
  store i64 %18, i64* %20
; # (loop (? (=0 (symByte P)) YES) (? (> @ 32) NO))
  br label %$10
$10:
; # (? (=0 (symByte P)) YES)
; # (symByte P)
  %21 = call i8 @symByte(i64* %19)
; # (=0 (symByte P))
  %22 = icmp eq i8 %21, 0
  br i1 %22, label %$13, label %$11
$13:
  br label %$12
$11:
; # (? (> @ 32) NO)
; # (> @ 32)
  %23 = icmp ugt i8 %21, 32
  br i1 %23, label %$15, label %$14
$15:
  br label %$12
$14:
  br label %$10
$12:
  %24 = phi i1 [1, %$13], [0, %$15] ; # ->
  br label %$4
$4:
  %25 = phi i1 [0, %$3], [0, %$5], [%24, %$12] ; # ->
  br label %$2
$2:
  %26 = phi i1 [1, %$1], [%25, %$4] ; # ->
  ret i1 %26
}

define i64 @extNm(i32, i64) align 8 {
$1:
; # (& Obj (hex "FFFFF"))
  %2 = and i64 %1, 1048575
; # (& File (hex "FF"))
  %3 = and i32 %0, 255
; # (i64 (& File (hex "FF")))
  %4 = sext i32 %3 to i64
; # (shl (i64 (& File (hex "FF"))) 20)
  %5 = shl i64 %4, 20
; # (shr Obj 20)
  %6 = lshr i64 %1, 20
; # (& (setq Obj (shr Obj 20)) (hex "FFF"))
  %7 = and i64 %6, 4095
; # (shl (& (setq Obj (shr Obj 20)) (hex "FFF")) 28)
  %8 = shl i64 %7, 28
; # (shr File 8)
  %9 = lshr i32 %0, 8
; # (i64 (shr File 8))
  %10 = sext i32 %9 to i64
; # (shl (i64 (shr File 8)) 40)
  %11 = shl i64 %10, 40
; # (shr Obj 12)
  %12 = lshr i64 %6, 12
; # (shl (shr Obj 12) 48)
  %13 = shl i64 %12, 48
; # (| (shl (i64 (shr File 8)) 40) (shl (shr Obj 12) 48))
  %14 = or i64 %11, %13
; # (| (shl (& (setq Obj (shr Obj 20)) (hex "FFF")) 28) (| (shl (i64 ...
  %15 = or i64 %8, %14
; # (| (shl (i64 (& File (hex "FF"))) 20) (| (shl (& (setq Obj (shr O...
  %16 = or i64 %5, %15
; # (| (& Obj (hex "FFFFF")) (| (shl (i64 (& File (hex "FF"))) 20) (|...
  %17 = or i64 %2, %16
; # (cnt (| (& Obj (hex "FFFFF")) (| (shl (i64 (& File (hex "FF"))) 2...
  %18 = shl i64 %17, 4
  %19 = or i64 %18, 2
  ret i64 %19
}

define i32 @objFile(i64) align 8 {
$1:
; # (shr Name 24)
  %1 = lshr i64 %0, 24
; # (i32 (setq Name (shr Name 24)))
  %2 = trunc i64 %1 to i32
; # (& (i32 (setq Name (shr Name 24))) (hex "FF"))
  %3 = and i32 %2, 255
; # (shr Name 12)
  %4 = lshr i64 %1, 12
; # (i32 (shr Name 12))
  %5 = trunc i64 %4 to i32
; # (& (i32 (shr Name 12)) (hex "FF00"))
  %6 = and i32 %5, 65280
; # (| (& (i32 (setq Name (shr Name 24))) (hex "FF")) (& (i32 (shr Na...
  %7 = or i32 %3, %6
  ret i32 %7
}

define i64 @objId(i64) align 8 {
$1:
; # (shr Name 4)
  %1 = lshr i64 %0, 4
; # (& (setq Name (shr Name 4)) (hex "FFFFF"))
  %2 = and i64 %1, 1048575
; # (shr Name 8)
  %3 = lshr i64 %1, 8
; # (& (setq Name (shr Name 8)) (hex "FFF00000"))
  %4 = and i64 %3, 4293918720
; # (| (& (setq Name (shr Name 4)) (hex "FFFFF")) (& (setq Name (shr ...
  %5 = or i64 %2, %4
; # (shr Name 8)
  %6 = lshr i64 %3, 8
; # (& (shr Name 8) (hex "3FF00000000"))
  %7 = and i64 %6, 4393751543808
; # (| (| (& (setq Name (shr Name 4)) (hex "FFFFF")) (& (setq Name (s...
  %8 = or i64 %5, %7
  ret i64 %8
}

define void @packAO(i32, i64*) align 8 {
$1:
; # (when (> File 15) (packAO (shr File 4) P))
; # (> File 15)
  %2 = icmp sgt i32 %0, 15
  br i1 %2, label %$2, label %$3
$2:
; # (shr File 4)
  %3 = lshr i32 %0, 4
; # (packAO (shr File 4) P)
  call void @packAO(i32 %3, i64* %1)
  br label %$3
$3:
; # (i8 File)
  %4 = trunc i32 %0 to i8
; # (& (i8 File) 15)
  %5 = and i8 %4, 15
; # (+ (& (i8 File) 15) (char "@"))
  %6 = add i8 %5, 64
; # (byteSym (+ (& (i8 File) 15) (char "@")) P)
  call void @byteSym(i8 %6, i64* %1)
  ret void
}

define void @packOct(i64, i64*) align 8 {
$1:
; # (when (> Obj 7) (packOct (shr Obj 3) P))
; # (> Obj 7)
  %2 = icmp ugt i64 %0, 7
  br i1 %2, label %$2, label %$3
$2:
; # (shr Obj 3)
  %3 = lshr i64 %0, 3
; # (packOct (shr Obj 3) P)
  call void @packOct(i64 %3, i64* %1)
  br label %$3
$3:
; # (i8 Obj)
  %4 = trunc i64 %0 to i8
; # (& (i8 Obj) 7)
  %5 = and i8 %4, 7
; # (+ (& (i8 Obj) 7) (char "0"))
  %6 = add i8 %5, 48
; # (byteSym (+ (& (i8 Obj) 7) (char "0")) P)
  call void @byteSym(i8 %6, i64* %1)
  ret void
}

define void @packExtNm(i64, i64*) align 8 {
$1:
; # (when (objFile Name) (packAO @ P))
; # (objFile Name)
  %2 = call i32 @objFile(i64 %0)
  %3 = icmp ne i32 %2, 0
  br i1 %3, label %$2, label %$3
$2:
; # (packAO @ P)
  call void @packAO(i32 %2, i64* %1)
  br label %$3
$3:
; # (objId Name)
  %4 = call i64 @objId(i64 %0)
; # (packOct (objId Name) P)
  call void @packOct(i64 %4, i64* %1)
  ret void
}

define void @pack(i64, i64*) align 8 {
$1:
; # (when (pair X) (stkChk 0) (loop (pack (++ X) P) (? (atom X))))
; # (pair X)
  %2 = and i64 %0, 15
  %3 = icmp eq i64 %2, 0
  br i1 %3, label %$2, label %$3
$2:
  %4 = phi i64 [%0, %$1] ; # X
; # (stkChk 0)
  %5 = load i8*, i8** @$StkLimit
  %6 = call i8* @llvm.stacksave()
  %7 = icmp ugt i8* %5, %6
  br i1 %7, label %$4, label %$5
$4:
  call void @stkErr(i64 0)
  unreachable
$5:
; # (loop (pack (++ X) P) (? (atom X)))
  br label %$6
$6:
  %8 = phi i64 [%4, %$5], [%15, %$7] ; # X
; # (++ X)
  %9 = inttoptr i64 %8 to i64*
  %10 = load i64, i64* %9
  %11 = getelementptr i64, i64* %9, i32 1
  %12 = load i64, i64* %11
; # (pack (++ X) P)
  call void @pack(i64 %10, i64* %1)
; # (? (atom X))
; # (atom X)
  %13 = and i64 %12, 15
  %14 = icmp ne i64 %13, 0
  br i1 %14, label %$8, label %$7
$7:
  %15 = phi i64 [%12, %$6] ; # X
  br label %$6
$8:
  %16 = phi i64 [%12, %$6] ; # X
  %17 = phi i64 [0, %$6] ; # ->
  br label %$3
$3:
  %18 = phi i64 [%0, %$1], [%16, %$8] ; # X
; # (cond ((nil? X)) ((num? X) (fmtNum X 0 0 0 P)) ((sym? (val (tail ...
; # (nil? X)
  %19 = icmp eq i64 %18, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %19, label %$9, label %$10
$10:
  %20 = phi i64 [%18, %$3] ; # X
; # (num? X)
  %21 = and i64 %20, 6
  %22 = icmp ne i64 %21, 0
  br i1 %22, label %$12, label %$11
$12:
  %23 = phi i64 [%20, %$10] ; # X
; # (fmtNum X 0 0 0 P)
  %24 = call i64 @fmtNum(i64 %23, i64 0, i8 0, i8 0, i64* %1)
  br label %$9
$11:
  %25 = phi i64 [%20, %$10] ; # X
; # (tail X)
  %26 = add i64 %25, -8
; # (val (tail X))
  %27 = inttoptr i64 %26 to i64*
  %28 = load i64, i64* %27
; # (sym? (val (tail X)))
  %29 = and i64 %28, 8
  %30 = icmp ne i64 %29, 0
  br i1 %30, label %$14, label %$13
$14:
  %31 = phi i64 [%25, %$11] ; # X
; # (byteSym (char "{") P)
  call void @byteSym(i8 123, i64* %1)
; # (& @ -9)
  %32 = and i64 %28, -9
; # (name (& @ -9))
  br label %$15
$15:
  %33 = phi i64 [%32, %$14], [%39, %$16] ; # Tail
  %34 = and i64 %33, 6
  %35 = icmp ne i64 %34, 0
  br i1 %35, label %$17, label %$16
$16:
  %36 = phi i64 [%33, %$15] ; # Tail
  %37 = inttoptr i64 %36 to i64*
  %38 = getelementptr i64, i64* %37, i32 1
  %39 = load i64, i64* %38
  br label %$15
$17:
  %40 = phi i64 [%33, %$15] ; # Tail
; # (packExtNm (name (& @ -9)) P)
  call void @packExtNm(i64 %40, i64* %1)
; # (byteSym (char "}") P)
  call void @byteSym(i8 125, i64* %1)
  br label %$9
$13:
  %41 = phi i64 [%25, %$11] ; # X
; # (let Q (push 0 (name @)) (while (symByte Q) (byteSym @ P)))
; # (name @)
  br label %$18
$18:
  %42 = phi i64 [%28, %$13], [%48, %$19] ; # Tail
  %43 = and i64 %42, 6
  %44 = icmp ne i64 %43, 0
  br i1 %44, label %$20, label %$19
$19:
  %45 = phi i64 [%42, %$18] ; # Tail
  %46 = inttoptr i64 %45 to i64*
  %47 = getelementptr i64, i64* %46, i32 1
  %48 = load i64, i64* %47
  br label %$18
$20:
  %49 = phi i64 [%42, %$18] ; # Tail
; # (push 0 (name @))
  %50 = alloca i64, i64 2, align 16
  store i64 0, i64* %50
  %51 = getelementptr i64, i64* %50, i32 1
  store i64 %49, i64* %51
; # (while (symByte Q) (byteSym @ P))
  br label %$21
$21:
  %52 = phi i64 [%41, %$20], [%55, %$22] ; # X
; # (symByte Q)
  %53 = call i8 @symByte(i64* %50)
  %54 = icmp ne i8 %53, 0
  br i1 %54, label %$22, label %$23
$22:
  %55 = phi i64 [%52, %$21] ; # X
; # (byteSym @ P)
  call void @byteSym(i8 %53, i64* %1)
  br label %$21
$23:
  %56 = phi i64 [%52, %$21] ; # X
  br label %$9
$9:
  %57 = phi i64 [%18, %$3], [%23, %$12], [%31, %$17], [%56, %$23] ; # X
  ret void
}

define i64 @chopExtNm(i64) align 8 {
$1:
; # (let (R (link (push $Nil NIL)) N (objId Name)) (loop (let A (+ (&...
; # (push $Nil NIL)
  %1 = alloca i64, i64 2, align 16
  %2 = ptrtoint i64* %1 to i64
  %3 = inttoptr i64 %2 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %3
; # (link (push $Nil NIL))
  %4 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %5 = load i64, i64* %4
  %6 = inttoptr i64 %2 to i64*
  %7 = getelementptr i64, i64* %6, i32 1
  store i64 %5, i64* %7
  %8 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %2, i64* %8
; # (objId Name)
  %9 = call i64 @objId(i64 %0)
; # (loop (let A (+ (& N 7) (char "0")) (when (setq N (shr N 3)) (set...
  br label %$2
$2:
  %10 = phi i64 [%9, %$1], [%42, %$7] ; # N
; # (let A (+ (& N 7) (char "0")) (when (setq N (shr N 3)) (setq A (|...
; # (& N 7)
  %11 = and i64 %10, 7
; # (+ (& N 7) (char "0"))
  %12 = add i64 %11, 48
; # (when (setq N (shr N 3)) (setq A (| (shl A 8) (+ (& N 7) (char "0...
; # (shr N 3)
  %13 = lshr i64 %10, 3
  %14 = icmp ne i64 %13, 0
  br i1 %14, label %$3, label %$4
$3:
  %15 = phi i64 [%13, %$2] ; # N
  %16 = phi i64 [%12, %$2] ; # A
; # (shl A 8)
  %17 = shl i64 %16, 8
; # (& N 7)
  %18 = and i64 %15, 7
; # (+ (& N 7) (char "0"))
  %19 = add i64 %18, 48
; # (| (shl A 8) (+ (& N 7) (char "0")))
  %20 = or i64 %17, %19
; # (when (setq N (shr N 3)) (setq A (| (shl A 8) (+ (& N 7) (char "0...
; # (shr N 3)
  %21 = lshr i64 %15, 3
  %22 = icmp ne i64 %21, 0
  br i1 %22, label %$5, label %$6
$5:
  %23 = phi i64 [%21, %$3] ; # N
  %24 = phi i64 [%20, %$3] ; # A
; # (shl A 8)
  %25 = shl i64 %24, 8
; # (& N 7)
  %26 = and i64 %23, 7
; # (+ (& N 7) (char "0"))
  %27 = add i64 %26, 48
; # (| (shl A 8) (+ (& N 7) (char "0")))
  %28 = or i64 %25, %27
  br label %$6
$6:
  %29 = phi i64 [%21, %$3], [%23, %$5] ; # N
  %30 = phi i64 [%20, %$3], [%28, %$5] ; # A
  br label %$4
$4:
  %31 = phi i64 [%13, %$2], [%29, %$6] ; # N
  %32 = phi i64 [%12, %$2], [%30, %$6] ; # A
; # (set R (cons (consSym (cnt A) 0) (val R)))
; # (cnt A)
  %33 = shl i64 %32, 4
  %34 = or i64 %33, 2
; # (consSym (cnt A) 0)
  %35 = call i64 @consSym(i64 %34, i64 0)
; # (val R)
  %36 = inttoptr i64 %2 to i64*
  %37 = load i64, i64* %36
; # (cons (consSym (cnt A) 0) (val R))
  %38 = call i64 @cons(i64 %35, i64 %37)
  %39 = inttoptr i64 %2 to i64*
  store i64 %38, i64* %39
; # (? (=0 (setq N (shr N 3))))
; # (shr N 3)
  %40 = lshr i64 %31, 3
; # (=0 (setq N (shr N 3)))
  %41 = icmp eq i64 %40, 0
  br i1 %41, label %$8, label %$7
$7:
  %42 = phi i64 [%40, %$4] ; # N
  br label %$2
$8:
  %43 = phi i64 [%40, %$4] ; # N
  %44 = phi i64 [0, %$4] ; # ->
; # (when (setq N (objFile Name)) (let F (i32 0) (loop (setq F (| F (...
; # (objFile Name)
  %45 = call i32 @objFile(i64 %0)
  %46 = icmp ne i32 %45, 0
  br i1 %46, label %$9, label %$10
$9:
  %47 = phi i32 [%45, %$8] ; # N
; # (let F (i32 0) (loop (setq F (| F (+ (& N 15) (char "@")))) (? (=...
; # (i32 0)
; # (loop (setq F (| F (+ (& N 15) (char "@")))) (? (=0 (setq N (shr ...
  br label %$11
$11:
  %48 = phi i32 [%47, %$9], [%55, %$12] ; # N
  %49 = phi i32 [0, %$9], [%57, %$12] ; # F
; # (& N 15)
  %50 = and i32 %48, 15
; # (+ (& N 15) (char "@"))
  %51 = add i32 %50, 64
; # (| F (+ (& N 15) (char "@")))
  %52 = or i32 %49, %51
; # (? (=0 (setq N (shr N 4))))
; # (shr N 4)
  %53 = lshr i32 %48, 4
; # (=0 (setq N (shr N 4)))
  %54 = icmp eq i32 %53, 0
  br i1 %54, label %$13, label %$12
$12:
  %55 = phi i32 [%53, %$11] ; # N
  %56 = phi i32 [%52, %$11] ; # F
; # (shl F 8)
  %57 = shl i32 %56, 8
  br label %$11
$13:
  %58 = phi i32 [%53, %$11] ; # N
  %59 = phi i32 [%52, %$11] ; # F
  %60 = phi i64 [0, %$11] ; # ->
; # (set R (cons (consStr (cnt (i64 F))) (val R)))
; # (i64 F)
  %61 = sext i32 %59 to i64
; # (cnt (i64 F))
  %62 = shl i64 %61, 4
  %63 = or i64 %62, 2
; # (consStr (cnt (i64 F)))
  %64 = call i64 @consStr(i64 %63)
; # (val R)
  %65 = inttoptr i64 %2 to i64*
  %66 = load i64, i64* %65
; # (cons (consStr (cnt (i64 F))) (val R))
  %67 = call i64 @cons(i64 %64, i64 %66)
  %68 = inttoptr i64 %2 to i64*
  store i64 %67, i64* %68
  br label %$10
$10:
  %69 = phi i32 [%45, %$8], [%58, %$13] ; # N
; # (pop R)
  %70 = inttoptr i64 %2 to i64*
  %71 = load i64, i64* %70
  %72 = inttoptr i64 %2 to i64*
  %73 = getelementptr i64, i64* %72, i32 1
  %74 = load i64, i64* %73
  %75 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %74, i64* %75
  ret i64 %71
}

define i64 @cmpLong(i64, i64) align 8 {
$1:
; # (loop (? (sub (val (dig X)) (val (dig Y))) (if @@ -1 1)) (setq X ...
  br label %$2
$2:
  %2 = phi i64 [%0, %$1], [%60, %$18] ; # X
  %3 = phi i64 [%1, %$1], [%61, %$18] ; # Y
; # (? (sub (val (dig X)) (val (dig Y))) (if @@ -1 1))
; # (dig X)
  %4 = add i64 %2, -4
; # (val (dig X))
  %5 = inttoptr i64 %4 to i64*
  %6 = load i64, i64* %5
; # (dig Y)
  %7 = add i64 %3, -4
; # (val (dig Y))
  %8 = inttoptr i64 %7 to i64*
  %9 = load i64, i64* %8
; # (sub (val (dig X)) (val (dig Y)))
  %10 = call {i64, i1} @llvm.usub.with.overflow.i64(i64 %6, i64 %9)
  %11 = extractvalue {i64, i1} %10, 1
  %12 = extractvalue {i64, i1} %10, 0
  %13 = icmp ne i64 %12, 0
  br i1 %13, label %$5, label %$3
$5:
  %14 = phi i64 [%2, %$2] ; # X
  %15 = phi i64 [%3, %$2] ; # Y
; # (if @@ -1 1)
  br i1 %11, label %$6, label %$7
$6:
  %16 = phi i64 [%14, %$5] ; # X
  %17 = phi i64 [%15, %$5] ; # Y
  br label %$8
$7:
  %18 = phi i64 [%14, %$5] ; # X
  %19 = phi i64 [%15, %$5] ; # Y
  br label %$8
$8:
  %20 = phi i64 [%16, %$6], [%18, %$7] ; # X
  %21 = phi i64 [%17, %$6], [%19, %$7] ; # Y
  %22 = phi i64 [-1, %$6], [1, %$7] ; # ->
  br label %$4
$3:
  %23 = phi i64 [%2, %$2] ; # X
  %24 = phi i64 [%3, %$2] ; # Y
; # (big X)
  %25 = add i64 %23, 4
; # (val (big X))
  %26 = inttoptr i64 %25 to i64*
  %27 = load i64, i64* %26
; # (big Y)
  %28 = add i64 %24, 4
; # (val (big Y))
  %29 = inttoptr i64 %28 to i64*
  %30 = load i64, i64* %29
; # (? (cnt? X) (cond ((big? Y) -1) ((== Y X) 0) ((> Y X) -1) (T 1)))...
; # (cnt? X)
  %31 = and i64 %27, 2
  %32 = icmp ne i64 %31, 0
  br i1 %32, label %$10, label %$9
$10:
  %33 = phi i64 [%27, %$3] ; # X
  %34 = phi i64 [%30, %$3] ; # Y
; # (cond ((big? Y) -1) ((== Y X) 0) ((> Y X) -1) (T 1))
; # (big? Y)
  %35 = and i64 %34, 4
  %36 = icmp ne i64 %35, 0
  br i1 %36, label %$13, label %$12
$13:
  %37 = phi i64 [%33, %$10] ; # X
  %38 = phi i64 [%34, %$10] ; # Y
  br label %$11
$12:
  %39 = phi i64 [%33, %$10] ; # X
  %40 = phi i64 [%34, %$10] ; # Y
; # (== Y X)
  %41 = icmp eq i64 %40, %39
  br i1 %41, label %$15, label %$14
$15:
  %42 = phi i64 [%39, %$12] ; # X
  %43 = phi i64 [%40, %$12] ; # Y
  br label %$11
$14:
  %44 = phi i64 [%39, %$12] ; # X
  %45 = phi i64 [%40, %$12] ; # Y
; # (> Y X)
  %46 = icmp ugt i64 %45, %44
  br i1 %46, label %$17, label %$16
$17:
  %47 = phi i64 [%44, %$14] ; # X
  %48 = phi i64 [%45, %$14] ; # Y
  br label %$11
$16:
  %49 = phi i64 [%44, %$14] ; # X
  %50 = phi i64 [%45, %$14] ; # Y
  br label %$11
$11:
  %51 = phi i64 [%37, %$13], [%42, %$15], [%47, %$17], [%49, %$16] ; # X
  %52 = phi i64 [%38, %$13], [%43, %$15], [%48, %$17], [%50, %$16] ; # Y
  %53 = phi i64 [-1, %$13], [0, %$15], [-1, %$17], [1, %$16] ; # ->
  br label %$4
$9:
  %54 = phi i64 [%27, %$3] ; # X
  %55 = phi i64 [%30, %$3] ; # Y
; # (? (cnt? Y) 1)
; # (cnt? Y)
  %56 = and i64 %55, 2
  %57 = icmp ne i64 %56, 0
  br i1 %57, label %$19, label %$18
$19:
  %58 = phi i64 [%54, %$9] ; # X
  %59 = phi i64 [%55, %$9] ; # Y
  br label %$4
$18:
  %60 = phi i64 [%54, %$9] ; # X
  %61 = phi i64 [%55, %$9] ; # Y
  br label %$2
$4:
  %62 = phi i64 [%20, %$8], [%51, %$11], [%58, %$19] ; # X
  %63 = phi i64 [%21, %$8], [%52, %$11], [%59, %$19] ; # Y
  %64 = phi i64 [%22, %$8], [%53, %$11], [1, %$19] ; # ->
  ret i64 %64
}

define i64 @isIntern(i64, i64) align 8 {
$1:
; # (if (cnt? Name) (let X (car Tree) (loop (? (atom X) 0) (let (S (c...
; # (cnt? Name)
  %2 = and i64 %0, 2
  %3 = icmp ne i64 %2, 0
  br i1 %3, label %$2, label %$3
$2:
; # (let X (car Tree) (loop (? (atom X) 0) (let (S (car X) Nm (name (...
; # (car Tree)
  %4 = inttoptr i64 %1 to i64*
  %5 = load i64, i64* %4
; # (loop (? (atom X) 0) (let (S (car X) Nm (name (val (tail S)))) (?...
  br label %$5
$5:
  %6 = phi i64 [%5, %$2], [%42, %$16] ; # X
; # (? (atom X) 0)
; # (atom X)
  %7 = and i64 %6, 15
  %8 = icmp ne i64 %7, 0
  br i1 %8, label %$8, label %$6
$8:
  %9 = phi i64 [%6, %$5] ; # X
  br label %$7
$6:
  %10 = phi i64 [%6, %$5] ; # X
; # (let (S (car X) Nm (name (val (tail S)))) (? (== Name Nm) S) (set...
; # (car X)
  %11 = inttoptr i64 %10 to i64*
  %12 = load i64, i64* %11
; # (tail S)
  %13 = add i64 %12, -8
; # (val (tail S))
  %14 = inttoptr i64 %13 to i64*
  %15 = load i64, i64* %14
; # (name (val (tail S)))
  br label %$9
$9:
  %16 = phi i64 [%15, %$6], [%22, %$10] ; # Tail
  %17 = and i64 %16, 6
  %18 = icmp ne i64 %17, 0
  br i1 %18, label %$11, label %$10
$10:
  %19 = phi i64 [%16, %$9] ; # Tail
  %20 = inttoptr i64 %19 to i64*
  %21 = getelementptr i64, i64* %20, i32 1
  %22 = load i64, i64* %21
  br label %$9
$11:
  %23 = phi i64 [%16, %$9] ; # Tail
; # (? (== Name Nm) S)
; # (== Name Nm)
  %24 = icmp eq i64 %0, %23
  br i1 %24, label %$13, label %$12
$13:
  %25 = phi i64 [%10, %$11] ; # X
  br label %$7
$12:
  %26 = phi i64 [%10, %$11] ; # X
; # (if (> Name Nm) (cddr X) (cadr X))
; # (> Name Nm)
  %27 = icmp ugt i64 %0, %23
  br i1 %27, label %$14, label %$15
$14:
  %28 = phi i64 [%26, %$12] ; # X
; # (cddr X)
  %29 = inttoptr i64 %28 to i64*
  %30 = getelementptr i64, i64* %29, i32 1
  %31 = load i64, i64* %30
  %32 = inttoptr i64 %31 to i64*
  %33 = getelementptr i64, i64* %32, i32 1
  %34 = load i64, i64* %33
  br label %$16
$15:
  %35 = phi i64 [%26, %$12] ; # X
; # (cadr X)
  %36 = inttoptr i64 %35 to i64*
  %37 = getelementptr i64, i64* %36, i32 1
  %38 = load i64, i64* %37
  %39 = inttoptr i64 %38 to i64*
  %40 = load i64, i64* %39
  br label %$16
$16:
  %41 = phi i64 [%28, %$14], [%35, %$15] ; # X
  %42 = phi i64 [%34, %$14], [%40, %$15] ; # ->
  br label %$5
$7:
  %43 = phi i64 [%9, %$8], [%25, %$13] ; # X
  %44 = phi i64 [0, %$8], [%12, %$13] ; # ->
  br label %$4
$3:
; # (let X (cdr Tree) (loop (? (atom X) 0) (let (S (car X) Nm (name (...
; # (cdr Tree)
  %45 = inttoptr i64 %1 to i64*
  %46 = getelementptr i64, i64* %45, i32 1
  %47 = load i64, i64* %46
; # (loop (? (atom X) 0) (let (S (car X) Nm (name (val (tail S)))) (?...
  br label %$17
$17:
  %48 = phi i64 [%47, %$3], [%85, %$28] ; # X
; # (? (atom X) 0)
; # (atom X)
  %49 = and i64 %48, 15
  %50 = icmp ne i64 %49, 0
  br i1 %50, label %$20, label %$18
$20:
  %51 = phi i64 [%48, %$17] ; # X
  br label %$19
$18:
  %52 = phi i64 [%48, %$17] ; # X
; # (let (S (car X) Nm (name (val (tail S)))) (? (=0 (cmpLong Nm Name...
; # (car X)
  %53 = inttoptr i64 %52 to i64*
  %54 = load i64, i64* %53
; # (tail S)
  %55 = add i64 %54, -8
; # (val (tail S))
  %56 = inttoptr i64 %55 to i64*
  %57 = load i64, i64* %56
; # (name (val (tail S)))
  br label %$21
$21:
  %58 = phi i64 [%57, %$18], [%64, %$22] ; # Tail
  %59 = and i64 %58, 6
  %60 = icmp ne i64 %59, 0
  br i1 %60, label %$23, label %$22
$22:
  %61 = phi i64 [%58, %$21] ; # Tail
  %62 = inttoptr i64 %61 to i64*
  %63 = getelementptr i64, i64* %62, i32 1
  %64 = load i64, i64* %63
  br label %$21
$23:
  %65 = phi i64 [%58, %$21] ; # Tail
; # (? (=0 (cmpLong Nm Name)) S)
; # (cmpLong Nm Name)
  %66 = call i64 @cmpLong(i64 %65, i64 %0)
; # (=0 (cmpLong Nm Name))
  %67 = icmp eq i64 %66, 0
  br i1 %67, label %$25, label %$24
$25:
  %68 = phi i64 [%52, %$23] ; # X
  br label %$19
$24:
  %69 = phi i64 [%52, %$23] ; # X
; # (if (lt0 @) (cddr X) (cadr X))
; # (lt0 @)
  %70 = icmp slt i64 %66, 0
  br i1 %70, label %$26, label %$27
$26:
  %71 = phi i64 [%69, %$24] ; # X
; # (cddr X)
  %72 = inttoptr i64 %71 to i64*
  %73 = getelementptr i64, i64* %72, i32 1
  %74 = load i64, i64* %73
  %75 = inttoptr i64 %74 to i64*
  %76 = getelementptr i64, i64* %75, i32 1
  %77 = load i64, i64* %76
  br label %$28
$27:
  %78 = phi i64 [%69, %$24] ; # X
; # (cadr X)
  %79 = inttoptr i64 %78 to i64*
  %80 = getelementptr i64, i64* %79, i32 1
  %81 = load i64, i64* %80
  %82 = inttoptr i64 %81 to i64*
  %83 = load i64, i64* %82
  br label %$28
$28:
  %84 = phi i64 [%71, %$26], [%78, %$27] ; # X
  %85 = phi i64 [%77, %$26], [%83, %$27] ; # ->
  br label %$17
$19:
  %86 = phi i64 [%51, %$20], [%68, %$25] ; # X
  %87 = phi i64 [0, %$20], [%54, %$25] ; # ->
  br label %$4
$4:
  %88 = phi i64 [%44, %$7], [%87, %$19] ; # ->
  ret i64 %88
}

define i64 @isLstIntern(i64, i64) align 8 {
$1:
; # (loop (? (atom Lst) 0) (? (isIntern Name (cdar (car Lst))) @) (sh...
  br label %$2
$2:
  %2 = phi i64 [%1, %$1], [%20, %$6] ; # Lst
; # (? (atom Lst) 0)
; # (atom Lst)
  %3 = and i64 %2, 15
  %4 = icmp ne i64 %3, 0
  br i1 %4, label %$5, label %$3
$5:
  %5 = phi i64 [%2, %$2] ; # Lst
  br label %$4
$3:
  %6 = phi i64 [%2, %$2] ; # Lst
; # (? (isIntern Name (cdar (car Lst))) @)
; # (car Lst)
  %7 = inttoptr i64 %6 to i64*
  %8 = load i64, i64* %7
; # (cdar (car Lst))
  %9 = inttoptr i64 %8 to i64*
  %10 = load i64, i64* %9
  %11 = inttoptr i64 %10 to i64*
  %12 = getelementptr i64, i64* %11, i32 1
  %13 = load i64, i64* %12
; # (isIntern Name (cdar (car Lst)))
  %14 = call i64 @isIntern(i64 %0, i64 %13)
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$7, label %$6
$7:
  %16 = phi i64 [%6, %$3] ; # Lst
  br label %$4
$6:
  %17 = phi i64 [%6, %$3] ; # Lst
; # (shift Lst)
  %18 = inttoptr i64 %17 to i64*
  %19 = getelementptr i64, i64* %18, i32 1
  %20 = load i64, i64* %19
  br label %$2
$4:
  %21 = phi i64 [%5, %$5], [%16, %$7] ; # Lst
  %22 = phi i64 [0, %$5], [%14, %$7] ; # ->
  ret i64 %22
}

define i1 @findSym(i64, i64, i64) align 8 {
$1:
; # (loop (? (atom Lst) NO) (? (== Sym (isIntern Name (cdar (car Lst)...
  br label %$2
$2:
  %3 = phi i64 [%2, %$1], [%21, %$6] ; # Lst
; # (? (atom Lst) NO)
; # (atom Lst)
  %4 = and i64 %3, 15
  %5 = icmp ne i64 %4, 0
  br i1 %5, label %$5, label %$3
$5:
  %6 = phi i64 [%3, %$2] ; # Lst
  br label %$4
$3:
  %7 = phi i64 [%3, %$2] ; # Lst
; # (? (== Sym (isIntern Name (cdar (car Lst)))) YES)
; # (car Lst)
  %8 = inttoptr i64 %7 to i64*
  %9 = load i64, i64* %8
; # (cdar (car Lst))
  %10 = inttoptr i64 %9 to i64*
  %11 = load i64, i64* %10
  %12 = inttoptr i64 %11 to i64*
  %13 = getelementptr i64, i64* %12, i32 1
  %14 = load i64, i64* %13
; # (isIntern Name (cdar (car Lst)))
  %15 = call i64 @isIntern(i64 %1, i64 %14)
; # (== Sym (isIntern Name (cdar (car Lst))))
  %16 = icmp eq i64 %0, %15
  br i1 %16, label %$7, label %$6
$7:
  %17 = phi i64 [%7, %$3] ; # Lst
  br label %$4
$6:
  %18 = phi i64 [%7, %$3] ; # Lst
; # (shift Lst)
  %19 = inttoptr i64 %18 to i64*
  %20 = getelementptr i64, i64* %19, i32 1
  %21 = load i64, i64* %20
  br label %$2
$4:
  %22 = phi i64 [%6, %$5], [%17, %$7] ; # Lst
  %23 = phi i1 [0, %$5], [1, %$7] ; # ->
  ret i1 %23
}

define i64 @intern(i64, i64, i64, i64, i64, i1) align 8 {
$1:
; # (if (cnt? Name) (let X (car Tree) (if (pair X) (loop (let (S (car...
; # (cnt? Name)
  %6 = and i64 %2, 2
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$2, label %$3
$2:
; # (let X (car Tree) (if (pair X) (loop (let (S (car X) Nm (name (va...
; # (car Tree)
  %8 = inttoptr i64 %3 to i64*
  %9 = load i64, i64* %8
; # (if (pair X) (loop (let (S (car X) Nm (name (val (tail S)))) (? (...
; # (pair X)
  %10 = and i64 %9, 15
  %11 = icmp eq i64 %10, 0
  br i1 %11, label %$5, label %$6
$5:
  %12 = phi i64 [%9, %$2] ; # X
; # (loop (let (S (car X) Nm (name (val (tail S)))) (? (== Name Nm) (...
  br label %$8
$8:
  %13 = phi i64 [%12, %$5], [%126, %$18] ; # X
; # (let (S (car X) Nm (name (val (tail S)))) (? (== Name Nm) (if Rpl...
; # (car X)
  %14 = inttoptr i64 %13 to i64*
  %15 = load i64, i64* %14
; # (tail S)
  %16 = add i64 %15, -8
; # (val (tail S))
  %17 = inttoptr i64 %16 to i64*
  %18 = load i64, i64* %17
; # (name (val (tail S)))
  br label %$9
$9:
  %19 = phi i64 [%18, %$8], [%25, %$10] ; # Tail
  %20 = and i64 %19, 6
  %21 = icmp ne i64 %20, 0
  br i1 %21, label %$11, label %$10
$10:
  %22 = phi i64 [%19, %$9] ; # Tail
  %23 = inttoptr i64 %22 to i64*
  %24 = getelementptr i64, i64* %23, i32 1
  %25 = load i64, i64* %24
  br label %$9
$11:
  %26 = phi i64 [%19, %$9] ; # Tail
; # (? (== Name Nm) (if Rpl (set X Sym) S))
; # (== Name Nm)
  %27 = icmp eq i64 %2, %26
  br i1 %27, label %$14, label %$12
$14:
  %28 = phi i64 [%13, %$11] ; # X
; # (if Rpl (set X Sym) S)
  br i1 %5, label %$15, label %$16
$15:
  %29 = phi i64 [%28, %$14] ; # X
; # (set X Sym)
  %30 = inttoptr i64 %29 to i64*
  store i64 %0, i64* %30
  br label %$17
$16:
  %31 = phi i64 [%28, %$14] ; # X
  br label %$17
$17:
  %32 = phi i64 [%29, %$15], [%31, %$16] ; # X
  %33 = phi i64 [%0, %$15], [%15, %$16] ; # ->
  br label %$13
$12:
  %34 = phi i64 [%13, %$11] ; # X
; # (let Y (cdr X) (cond ((> Name Nm) (? (atom Y) (internRight Sym Va...
; # (cdr X)
  %35 = inttoptr i64 %34 to i64*
  %36 = getelementptr i64, i64* %35, i32 1
  %37 = load i64, i64* %36
; # (cond ((> Name Nm) (? (atom Y) (internRight Sym Val Name X More))...
; # (> Name Nm)
  %38 = icmp ugt i64 %2, %26
  br i1 %38, label %$20, label %$19
$20:
  %39 = phi i64 [%34, %$12] ; # X
  %40 = phi i64 [%37, %$12] ; # Y
; # (? (atom Y) (internRight Sym Val Name X More))
; # (atom Y)
  %41 = and i64 %40, 15
  %42 = icmp ne i64 %41, 0
  br i1 %42, label %$22, label %$21
$22:
  %43 = phi i64 [%39, %$20] ; # X
  %44 = phi i64 [%40, %$20] ; # Y
; # (internRight Sym Val Name X More)
  %45 = call i64 @isLstIntern(i64 %2, i64 %4)
  %46 = icmp ne i64 %45, 0
  br i1 %46, label %$23, label %$24
$23:
  %47 = phi i64 [%0, %$22] ; # Sym
  br label %$25
$24:
  %48 = phi i64 [%0, %$22] ; # Sym
  %49 = icmp ne i64 %48, 0
  br i1 %49, label %$27, label %$26
$26:
  %50 = phi i64 [%48, %$24] ; # Sym
  %51 = call i64 @consSym(i64 %2, i64 %1)
  br label %$27
$27:
  %52 = phi i64 [%48, %$24], [%51, %$26] ; # Sym
  %53 = call i64 @cons(i64 %52, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %54 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64 %53)
  %55 = inttoptr i64 %43 to i64*
  %56 = getelementptr i64, i64* %55, i32 1
  store i64 %54, i64* %56
  br label %$25
$25:
  %57 = phi i64 [%47, %$23], [%52, %$27] ; # Sym
  %58 = phi i64 [%45, %$23], [%52, %$27] ; # ->
  br label %$13
$21:
  %59 = phi i64 [%39, %$20] ; # X
  %60 = phi i64 [%40, %$20] ; # Y
; # (? (atom (setq Y (cdr (setq X Y)))) (intern2 Sym Val Name X More)...
; # (cdr (setq X Y))
  %61 = inttoptr i64 %60 to i64*
  %62 = getelementptr i64, i64* %61, i32 1
  %63 = load i64, i64* %62
; # (atom (setq Y (cdr (setq X Y))))
  %64 = and i64 %63, 15
  %65 = icmp ne i64 %64, 0
  br i1 %65, label %$29, label %$28
$29:
  %66 = phi i64 [%60, %$21] ; # X
  %67 = phi i64 [%63, %$21] ; # Y
; # (intern2 Sym Val Name X More)
  %68 = call i64 @isLstIntern(i64 %2, i64 %4)
  %69 = icmp ne i64 %68, 0
  br i1 %69, label %$30, label %$31
$30:
  %70 = phi i64 [%0, %$29] ; # Sym
  br label %$32
$31:
  %71 = phi i64 [%0, %$29] ; # Sym
  %72 = icmp ne i64 %71, 0
  br i1 %72, label %$34, label %$33
$33:
  %73 = phi i64 [%71, %$31] ; # Sym
  %74 = call i64 @consSym(i64 %2, i64 %1)
  br label %$34
$34:
  %75 = phi i64 [%71, %$31], [%74, %$33] ; # Sym
  %76 = call i64 @cons(i64 %75, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %77 = inttoptr i64 %66 to i64*
  %78 = getelementptr i64, i64* %77, i32 1
  store i64 %76, i64* %78
  br label %$32
$32:
  %79 = phi i64 [%70, %$30], [%75, %$34] ; # Sym
  %80 = phi i64 [%68, %$30], [%75, %$34] ; # ->
  br label %$13
$28:
  %81 = phi i64 [%60, %$21] ; # X
  %82 = phi i64 [%63, %$21] ; # Y
  br label %$18
$19:
  %83 = phi i64 [%34, %$12] ; # X
  %84 = phi i64 [%37, %$12] ; # Y
; # (? (atom Y) (internLeft Sym Val Name X More))
; # (atom Y)
  %85 = and i64 %84, 15
  %86 = icmp ne i64 %85, 0
  br i1 %86, label %$36, label %$35
$36:
  %87 = phi i64 [%83, %$19] ; # X
  %88 = phi i64 [%84, %$19] ; # Y
; # (internLeft Sym Val Name X More)
  %89 = call i64 @isLstIntern(i64 %2, i64 %4)
  %90 = icmp ne i64 %89, 0
  br i1 %90, label %$37, label %$38
$37:
  %91 = phi i64 [%0, %$36] ; # Sym
  br label %$39
$38:
  %92 = phi i64 [%0, %$36] ; # Sym
  %93 = icmp ne i64 %92, 0
  br i1 %93, label %$41, label %$40
$40:
  %94 = phi i64 [%92, %$38] ; # Sym
  %95 = call i64 @consSym(i64 %2, i64 %1)
  br label %$41
$41:
  %96 = phi i64 [%92, %$38], [%95, %$40] ; # Sym
  %97 = call i64 @cons(i64 %96, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %98 = call i64 @cons(i64 %97, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %99 = inttoptr i64 %87 to i64*
  %100 = getelementptr i64, i64* %99, i32 1
  store i64 %98, i64* %100
  br label %$39
$39:
  %101 = phi i64 [%91, %$37], [%96, %$41] ; # Sym
  %102 = phi i64 [%89, %$37], [%96, %$41] ; # ->
  br label %$13
$35:
  %103 = phi i64 [%83, %$19] ; # X
  %104 = phi i64 [%84, %$19] ; # Y
; # (? (atom (setq Y (car (setq X Y)))) (intern1 Sym Val Name X More)...
; # (car (setq X Y))
  %105 = inttoptr i64 %104 to i64*
  %106 = load i64, i64* %105
; # (atom (setq Y (car (setq X Y))))
  %107 = and i64 %106, 15
  %108 = icmp ne i64 %107, 0
  br i1 %108, label %$43, label %$42
$43:
  %109 = phi i64 [%104, %$35] ; # X
  %110 = phi i64 [%106, %$35] ; # Y
; # (intern1 Sym Val Name X More)
  %111 = call i64 @isLstIntern(i64 %2, i64 %4)
  %112 = icmp ne i64 %111, 0
  br i1 %112, label %$44, label %$45
$44:
  %113 = phi i64 [%0, %$43] ; # Sym
  br label %$46
$45:
  %114 = phi i64 [%0, %$43] ; # Sym
  %115 = icmp ne i64 %114, 0
  br i1 %115, label %$48, label %$47
$47:
  %116 = phi i64 [%114, %$45] ; # Sym
  %117 = call i64 @consSym(i64 %2, i64 %1)
  br label %$48
$48:
  %118 = phi i64 [%114, %$45], [%117, %$47] ; # Sym
  %119 = call i64 @cons(i64 %118, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %120 = inttoptr i64 %109 to i64*
  store i64 %119, i64* %120
  br label %$46
$46:
  %121 = phi i64 [%113, %$44], [%118, %$48] ; # Sym
  %122 = phi i64 [%111, %$44], [%118, %$48] ; # ->
  br label %$13
$42:
  %123 = phi i64 [%104, %$35] ; # X
  %124 = phi i64 [%106, %$35] ; # Y
  br label %$18
$18:
  %125 = phi i64 [%81, %$28], [%123, %$42] ; # X
  %126 = phi i64 [%82, %$28], [%124, %$42] ; # Y
  br label %$8
$13:
  %127 = phi i64 [%32, %$17], [%43, %$25], [%66, %$32], [%87, %$39], [%109, %$46] ; # X
  %128 = phi i64 [%33, %$17], [%58, %$25], [%80, %$32], [%102, %$39], [%122, %$46] ; # ->
  br label %$7
$6:
  %129 = phi i64 [%9, %$2] ; # X
; # (intern1 Sym Val Name Tree More)
  %130 = call i64 @isLstIntern(i64 %2, i64 %4)
  %131 = icmp ne i64 %130, 0
  br i1 %131, label %$49, label %$50
$49:
  %132 = phi i64 [%0, %$6] ; # Sym
  br label %$51
$50:
  %133 = phi i64 [%0, %$6] ; # Sym
  %134 = icmp ne i64 %133, 0
  br i1 %134, label %$53, label %$52
$52:
  %135 = phi i64 [%133, %$50] ; # Sym
  %136 = call i64 @consSym(i64 %2, i64 %1)
  br label %$53
$53:
  %137 = phi i64 [%133, %$50], [%136, %$52] ; # Sym
  %138 = call i64 @cons(i64 %137, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %139 = inttoptr i64 %3 to i64*
  store i64 %138, i64* %139
  br label %$51
$51:
  %140 = phi i64 [%132, %$49], [%137, %$53] ; # Sym
  %141 = phi i64 [%130, %$49], [%137, %$53] ; # ->
  br label %$7
$7:
  %142 = phi i64 [%127, %$13], [%129, %$51] ; # X
  %143 = phi i64 [%128, %$13], [%141, %$51] ; # ->
  br label %$4
$3:
; # (let X (cdr Tree) (if (pair X) (loop (let (S (car X) Nm (name (va...
; # (cdr Tree)
  %144 = inttoptr i64 %3 to i64*
  %145 = getelementptr i64, i64* %144, i32 1
  %146 = load i64, i64* %145
; # (if (pair X) (loop (let (S (car X) Nm (name (val (tail S)))) (? (...
; # (pair X)
  %147 = and i64 %146, 15
  %148 = icmp eq i64 %147, 0
  br i1 %148, label %$54, label %$55
$54:
  %149 = phi i64 [%146, %$3] ; # X
; # (loop (let (S (car X) Nm (name (val (tail S)))) (? (=0 (cmpLong N...
  br label %$57
$57:
  %150 = phi i64 [%149, %$54], [%264, %$67] ; # X
; # (let (S (car X) Nm (name (val (tail S)))) (? (=0 (cmpLong Nm Name...
; # (car X)
  %151 = inttoptr i64 %150 to i64*
  %152 = load i64, i64* %151
; # (tail S)
  %153 = add i64 %152, -8
; # (val (tail S))
  %154 = inttoptr i64 %153 to i64*
  %155 = load i64, i64* %154
; # (name (val (tail S)))
  br label %$58
$58:
  %156 = phi i64 [%155, %$57], [%162, %$59] ; # Tail
  %157 = and i64 %156, 6
  %158 = icmp ne i64 %157, 0
  br i1 %158, label %$60, label %$59
$59:
  %159 = phi i64 [%156, %$58] ; # Tail
  %160 = inttoptr i64 %159 to i64*
  %161 = getelementptr i64, i64* %160, i32 1
  %162 = load i64, i64* %161
  br label %$58
$60:
  %163 = phi i64 [%156, %$58] ; # Tail
; # (? (=0 (cmpLong Nm Name)) (if Rpl (set X Sym) S))
; # (cmpLong Nm Name)
  %164 = call i64 @cmpLong(i64 %163, i64 %2)
; # (=0 (cmpLong Nm Name))
  %165 = icmp eq i64 %164, 0
  br i1 %165, label %$63, label %$61
$63:
  %166 = phi i64 [%150, %$60] ; # X
; # (if Rpl (set X Sym) S)
  br i1 %5, label %$64, label %$65
$64:
  %167 = phi i64 [%166, %$63] ; # X
; # (set X Sym)
  %168 = inttoptr i64 %167 to i64*
  store i64 %0, i64* %168
  br label %$66
$65:
  %169 = phi i64 [%166, %$63] ; # X
  br label %$66
$66:
  %170 = phi i64 [%167, %$64], [%169, %$65] ; # X
  %171 = phi i64 [%0, %$64], [%152, %$65] ; # ->
  br label %$62
$61:
  %172 = phi i64 [%150, %$60] ; # X
; # (let Y (cdr X) (cond ((lt0 @) (? (atom Y) (internRight Sym Val Na...
; # (cdr X)
  %173 = inttoptr i64 %172 to i64*
  %174 = getelementptr i64, i64* %173, i32 1
  %175 = load i64, i64* %174
; # (cond ((lt0 @) (? (atom Y) (internRight Sym Val Name X More)) (? ...
; # (lt0 @)
  %176 = icmp slt i64 %164, 0
  br i1 %176, label %$69, label %$68
$69:
  %177 = phi i64 [%172, %$61] ; # X
  %178 = phi i64 [%175, %$61] ; # Y
; # (? (atom Y) (internRight Sym Val Name X More))
; # (atom Y)
  %179 = and i64 %178, 15
  %180 = icmp ne i64 %179, 0
  br i1 %180, label %$71, label %$70
$71:
  %181 = phi i64 [%177, %$69] ; # X
  %182 = phi i64 [%178, %$69] ; # Y
; # (internRight Sym Val Name X More)
  %183 = call i64 @isLstIntern(i64 %2, i64 %4)
  %184 = icmp ne i64 %183, 0
  br i1 %184, label %$72, label %$73
$72:
  %185 = phi i64 [%0, %$71] ; # Sym
  br label %$74
$73:
  %186 = phi i64 [%0, %$71] ; # Sym
  %187 = icmp ne i64 %186, 0
  br i1 %187, label %$76, label %$75
$75:
  %188 = phi i64 [%186, %$73] ; # Sym
  %189 = call i64 @consSym(i64 %2, i64 %1)
  br label %$76
$76:
  %190 = phi i64 [%186, %$73], [%189, %$75] ; # Sym
  %191 = call i64 @cons(i64 %190, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %192 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64 %191)
  %193 = inttoptr i64 %181 to i64*
  %194 = getelementptr i64, i64* %193, i32 1
  store i64 %192, i64* %194
  br label %$74
$74:
  %195 = phi i64 [%185, %$72], [%190, %$76] ; # Sym
  %196 = phi i64 [%183, %$72], [%190, %$76] ; # ->
  br label %$62
$70:
  %197 = phi i64 [%177, %$69] ; # X
  %198 = phi i64 [%178, %$69] ; # Y
; # (? (atom (setq Y (cdr (setq X Y)))) (intern2 Sym Val Name X More)...
; # (cdr (setq X Y))
  %199 = inttoptr i64 %198 to i64*
  %200 = getelementptr i64, i64* %199, i32 1
  %201 = load i64, i64* %200
; # (atom (setq Y (cdr (setq X Y))))
  %202 = and i64 %201, 15
  %203 = icmp ne i64 %202, 0
  br i1 %203, label %$78, label %$77
$78:
  %204 = phi i64 [%198, %$70] ; # X
  %205 = phi i64 [%201, %$70] ; # Y
; # (intern2 Sym Val Name X More)
  %206 = call i64 @isLstIntern(i64 %2, i64 %4)
  %207 = icmp ne i64 %206, 0
  br i1 %207, label %$79, label %$80
$79:
  %208 = phi i64 [%0, %$78] ; # Sym
  br label %$81
$80:
  %209 = phi i64 [%0, %$78] ; # Sym
  %210 = icmp ne i64 %209, 0
  br i1 %210, label %$83, label %$82
$82:
  %211 = phi i64 [%209, %$80] ; # Sym
  %212 = call i64 @consSym(i64 %2, i64 %1)
  br label %$83
$83:
  %213 = phi i64 [%209, %$80], [%212, %$82] ; # Sym
  %214 = call i64 @cons(i64 %213, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %215 = inttoptr i64 %204 to i64*
  %216 = getelementptr i64, i64* %215, i32 1
  store i64 %214, i64* %216
  br label %$81
$81:
  %217 = phi i64 [%208, %$79], [%213, %$83] ; # Sym
  %218 = phi i64 [%206, %$79], [%213, %$83] ; # ->
  br label %$62
$77:
  %219 = phi i64 [%198, %$70] ; # X
  %220 = phi i64 [%201, %$70] ; # Y
  br label %$67
$68:
  %221 = phi i64 [%172, %$61] ; # X
  %222 = phi i64 [%175, %$61] ; # Y
; # (? (atom Y) (internLeft Sym Val Name X More))
; # (atom Y)
  %223 = and i64 %222, 15
  %224 = icmp ne i64 %223, 0
  br i1 %224, label %$85, label %$84
$85:
  %225 = phi i64 [%221, %$68] ; # X
  %226 = phi i64 [%222, %$68] ; # Y
; # (internLeft Sym Val Name X More)
  %227 = call i64 @isLstIntern(i64 %2, i64 %4)
  %228 = icmp ne i64 %227, 0
  br i1 %228, label %$86, label %$87
$86:
  %229 = phi i64 [%0, %$85] ; # Sym
  br label %$88
$87:
  %230 = phi i64 [%0, %$85] ; # Sym
  %231 = icmp ne i64 %230, 0
  br i1 %231, label %$90, label %$89
$89:
  %232 = phi i64 [%230, %$87] ; # Sym
  %233 = call i64 @consSym(i64 %2, i64 %1)
  br label %$90
$90:
  %234 = phi i64 [%230, %$87], [%233, %$89] ; # Sym
  %235 = call i64 @cons(i64 %234, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %236 = call i64 @cons(i64 %235, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %237 = inttoptr i64 %225 to i64*
  %238 = getelementptr i64, i64* %237, i32 1
  store i64 %236, i64* %238
  br label %$88
$88:
  %239 = phi i64 [%229, %$86], [%234, %$90] ; # Sym
  %240 = phi i64 [%227, %$86], [%234, %$90] ; # ->
  br label %$62
$84:
  %241 = phi i64 [%221, %$68] ; # X
  %242 = phi i64 [%222, %$68] ; # Y
; # (? (atom (setq Y (car (setq X Y)))) (intern1 Sym Val Name X More)...
; # (car (setq X Y))
  %243 = inttoptr i64 %242 to i64*
  %244 = load i64, i64* %243
; # (atom (setq Y (car (setq X Y))))
  %245 = and i64 %244, 15
  %246 = icmp ne i64 %245, 0
  br i1 %246, label %$92, label %$91
$92:
  %247 = phi i64 [%242, %$84] ; # X
  %248 = phi i64 [%244, %$84] ; # Y
; # (intern1 Sym Val Name X More)
  %249 = call i64 @isLstIntern(i64 %2, i64 %4)
  %250 = icmp ne i64 %249, 0
  br i1 %250, label %$93, label %$94
$93:
  %251 = phi i64 [%0, %$92] ; # Sym
  br label %$95
$94:
  %252 = phi i64 [%0, %$92] ; # Sym
  %253 = icmp ne i64 %252, 0
  br i1 %253, label %$97, label %$96
$96:
  %254 = phi i64 [%252, %$94] ; # Sym
  %255 = call i64 @consSym(i64 %2, i64 %1)
  br label %$97
$97:
  %256 = phi i64 [%252, %$94], [%255, %$96] ; # Sym
  %257 = call i64 @cons(i64 %256, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %258 = inttoptr i64 %247 to i64*
  store i64 %257, i64* %258
  br label %$95
$95:
  %259 = phi i64 [%251, %$93], [%256, %$97] ; # Sym
  %260 = phi i64 [%249, %$93], [%256, %$97] ; # ->
  br label %$62
$91:
  %261 = phi i64 [%242, %$84] ; # X
  %262 = phi i64 [%244, %$84] ; # Y
  br label %$67
$67:
  %263 = phi i64 [%219, %$77], [%261, %$91] ; # X
  %264 = phi i64 [%220, %$77], [%262, %$91] ; # Y
  br label %$57
$62:
  %265 = phi i64 [%170, %$66], [%181, %$74], [%204, %$81], [%225, %$88], [%247, %$95] ; # X
  %266 = phi i64 [%171, %$66], [%196, %$74], [%218, %$81], [%240, %$88], [%260, %$95] ; # ->
  br label %$56
$55:
  %267 = phi i64 [%146, %$3] ; # X
; # (intern2 Sym Val Name Tree More)
  %268 = call i64 @isLstIntern(i64 %2, i64 %4)
  %269 = icmp ne i64 %268, 0
  br i1 %269, label %$98, label %$99
$98:
  %270 = phi i64 [%0, %$55] ; # Sym
  br label %$100
$99:
  %271 = phi i64 [%0, %$55] ; # Sym
  %272 = icmp ne i64 %271, 0
  br i1 %272, label %$102, label %$101
$101:
  %273 = phi i64 [%271, %$99] ; # Sym
  %274 = call i64 @consSym(i64 %2, i64 %1)
  br label %$102
$102:
  %275 = phi i64 [%271, %$99], [%274, %$101] ; # Sym
  %276 = call i64 @cons(i64 %275, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %277 = inttoptr i64 %3 to i64*
  %278 = getelementptr i64, i64* %277, i32 1
  store i64 %276, i64* %278
  br label %$100
$100:
  %279 = phi i64 [%270, %$98], [%275, %$102] ; # Sym
  %280 = phi i64 [%268, %$98], [%275, %$102] ; # ->
  br label %$56
$56:
  %281 = phi i64 [%265, %$62], [%267, %$100] ; # X
  %282 = phi i64 [%266, %$62], [%280, %$100] ; # ->
  br label %$4
$4:
  %283 = phi i64 [%143, %$7], [%282, %$56] ; # ->
  ret i64 %283
}

define i64 @requestSym(i64) align 8 {
$1:
; # (if (isIntern Name $PrivT) @ (let L (val $Intern) (intern 0 $Nil ...
; # (isIntern Name $PrivT)
  %1 = call i64 @isIntern(i64 %0, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 112) to i64))
  %2 = icmp ne i64 %1, 0
  br i1 %2, label %$2, label %$3
$2:
  br label %$4
$3:
; # (let L (val $Intern) (intern 0 $Nil Name (cdar (car L)) (cdr L) N...
; # (val $Intern)
  %3 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 0) to i64) to i64*
  %4 = load i64, i64* %3
; # (car L)
  %5 = inttoptr i64 %4 to i64*
  %6 = load i64, i64* %5
; # (cdar (car L))
  %7 = inttoptr i64 %6 to i64*
  %8 = load i64, i64* %7
  %9 = inttoptr i64 %8 to i64*
  %10 = getelementptr i64, i64* %9, i32 1
  %11 = load i64, i64* %10
; # (cdr L)
  %12 = inttoptr i64 %4 to i64*
  %13 = getelementptr i64, i64* %12, i32 1
  %14 = load i64, i64* %13
; # (intern 0 $Nil Name (cdar (car L)) (cdr L) NO)
  %15 = call i64 @intern(i64 0, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64 %0, i64 %11, i64 %14, i1 0)
  br label %$4
$4:
  %16 = phi i64 [%1, %$2], [%15, %$3] ; # ->
  ret i64 %16
}

define i64 @extern(i64) align 8 {
$1:
; # (need3)
  call void @need3()
; # (let (X (val $Extern) C 0 Sym T) (loop (inc 'C) (setq Sym (car X)...
; # (val $Extern)
  %1 = load i64, i64* @$Extern
; # (loop (inc 'C) (setq Sym (car X)) (let Nm (& (name (& (val (tail ...
  br label %$2
$2:
  %2 = phi i64 [%1, %$1], [%101, %$8] ; # X
  %3 = phi i64 [0, %$1], [%99, %$8] ; # C
; # (inc 'C)
  %4 = add i64 %3, 1
; # (car X)
  %5 = inttoptr i64 %2 to i64*
  %6 = load i64, i64* %5
; # (let Nm (& (name (& (val (tail Sym)) -9)) (hex "3FFFFFFFFFFFFFF7"...
; # (tail Sym)
  %7 = add i64 %6, -8
; # (val (tail Sym))
  %8 = inttoptr i64 %7 to i64*
  %9 = load i64, i64* %8
; # (& (val (tail Sym)) -9)
  %10 = and i64 %9, -9
; # (name (& (val (tail Sym)) -9))
  br label %$3
$3:
  %11 = phi i64 [%10, %$2], [%17, %$4] ; # Tail
  %12 = and i64 %11, 6
  %13 = icmp ne i64 %12, 0
  br i1 %13, label %$5, label %$4
$4:
  %14 = phi i64 [%11, %$3] ; # Tail
  %15 = inttoptr i64 %14 to i64*
  %16 = getelementptr i64, i64* %15, i32 1
  %17 = load i64, i64* %16
  br label %$3
$5:
  %18 = phi i64 [%11, %$3] ; # Tail
; # (& (name (& (val (tail Sym)) -9)) (hex "3FFFFFFFFFFFFFF7"))
  %19 = and i64 %18, 4611686018427387895
; # (? (== Nm Name))
; # (== Nm Name)
  %20 = icmp eq i64 %19, %0
  br i1 %20, label %$7, label %$6
$6:
  %21 = phi i64 [%2, %$5] ; # X
  %22 = phi i64 [%4, %$5] ; # C
  %23 = phi i64 [%6, %$5] ; # Sym
; # (let Y (cdr X) (cond ((> Name Nm) (? (atom Y) (set 2 X (cons $Nil...
; # (cdr X)
  %24 = inttoptr i64 %21 to i64*
  %25 = getelementptr i64, i64* %24, i32 1
  %26 = load i64, i64* %25
; # (cond ((> Name Nm) (? (atom Y) (set 2 X (cons $Nil (cons (setq Sy...
; # (> Name Nm)
  %27 = icmp ugt i64 %0, %19
  br i1 %27, label %$10, label %$9
$10:
  %28 = phi i64 [%21, %$6] ; # X
  %29 = phi i64 [%22, %$6] ; # C
  %30 = phi i64 [%23, %$6] ; # Sym
  %31 = phi i64 [%26, %$6] ; # Y
; # (? (atom Y) (set 2 X (cons $Nil (cons (setq Sym (consExt Name)) $...
; # (atom Y)
  %32 = and i64 %31, 15
  %33 = icmp ne i64 %32, 0
  br i1 %33, label %$12, label %$11
$12:
  %34 = phi i64 [%28, %$10] ; # X
  %35 = phi i64 [%29, %$10] ; # C
  %36 = phi i64 [%30, %$10] ; # Sym
  %37 = phi i64 [%31, %$10] ; # Y
; # (set 2 X (cons $Nil (cons (setq Sym (consExt Name)) $Nil)))
; # (consExt Name)
  %38 = call i64 @consExt(i64 %0)
; # (cons (setq Sym (consExt Name)) $Nil)
  %39 = call i64 @cons(i64 %38, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (cons $Nil (cons (setq Sym (consExt Name)) $Nil))
  %40 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64 %39)
  %41 = inttoptr i64 %34 to i64*
  %42 = getelementptr i64, i64* %41, i32 1
  store i64 %40, i64* %42
  br label %$7
$11:
  %43 = phi i64 [%28, %$10] ; # X
  %44 = phi i64 [%29, %$10] ; # C
  %45 = phi i64 [%30, %$10] ; # Sym
  %46 = phi i64 [%31, %$10] ; # Y
; # (? (atom (setq Y (cdr (setq X Y)))) (set 2 X (cons (setq Sym (con...
; # (cdr (setq X Y))
  %47 = inttoptr i64 %46 to i64*
  %48 = getelementptr i64, i64* %47, i32 1
  %49 = load i64, i64* %48
; # (atom (setq Y (cdr (setq X Y))))
  %50 = and i64 %49, 15
  %51 = icmp ne i64 %50, 0
  br i1 %51, label %$14, label %$13
$14:
  %52 = phi i64 [%46, %$11] ; # X
  %53 = phi i64 [%44, %$11] ; # C
  %54 = phi i64 [%45, %$11] ; # Sym
  %55 = phi i64 [%49, %$11] ; # Y
; # (set 2 X (cons (setq Sym (consExt Name)) $Nil))
; # (consExt Name)
  %56 = call i64 @consExt(i64 %0)
; # (cons (setq Sym (consExt Name)) $Nil)
  %57 = call i64 @cons(i64 %56, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %58 = inttoptr i64 %52 to i64*
  %59 = getelementptr i64, i64* %58, i32 1
  store i64 %57, i64* %59
  br label %$7
$13:
  %60 = phi i64 [%46, %$11] ; # X
  %61 = phi i64 [%44, %$11] ; # C
  %62 = phi i64 [%45, %$11] ; # Sym
  %63 = phi i64 [%49, %$11] ; # Y
  br label %$8
$9:
  %64 = phi i64 [%21, %$6] ; # X
  %65 = phi i64 [%22, %$6] ; # C
  %66 = phi i64 [%23, %$6] ; # Sym
  %67 = phi i64 [%26, %$6] ; # Y
; # (? (atom Y) (set 2 X (cons (cons (setq Sym (consExt Name)) $Nil) ...
; # (atom Y)
  %68 = and i64 %67, 15
  %69 = icmp ne i64 %68, 0
  br i1 %69, label %$16, label %$15
$16:
  %70 = phi i64 [%64, %$9] ; # X
  %71 = phi i64 [%65, %$9] ; # C
  %72 = phi i64 [%66, %$9] ; # Sym
  %73 = phi i64 [%67, %$9] ; # Y
; # (set 2 X (cons (cons (setq Sym (consExt Name)) $Nil) $Nil))
; # (consExt Name)
  %74 = call i64 @consExt(i64 %0)
; # (cons (setq Sym (consExt Name)) $Nil)
  %75 = call i64 @cons(i64 %74, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (cons (cons (setq Sym (consExt Name)) $Nil) $Nil)
  %76 = call i64 @cons(i64 %75, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %77 = inttoptr i64 %70 to i64*
  %78 = getelementptr i64, i64* %77, i32 1
  store i64 %76, i64* %78
  br label %$7
$15:
  %79 = phi i64 [%64, %$9] ; # X
  %80 = phi i64 [%65, %$9] ; # C
  %81 = phi i64 [%66, %$9] ; # Sym
  %82 = phi i64 [%67, %$9] ; # Y
; # (? (atom (setq Y (car (setq X Y)))) (set X (cons (setq Sym (consE...
; # (car (setq X Y))
  %83 = inttoptr i64 %82 to i64*
  %84 = load i64, i64* %83
; # (atom (setq Y (car (setq X Y))))
  %85 = and i64 %84, 15
  %86 = icmp ne i64 %85, 0
  br i1 %86, label %$18, label %$17
$18:
  %87 = phi i64 [%82, %$15] ; # X
  %88 = phi i64 [%80, %$15] ; # C
  %89 = phi i64 [%81, %$15] ; # Sym
  %90 = phi i64 [%84, %$15] ; # Y
; # (set X (cons (setq Sym (consExt Name)) $Nil))
; # (consExt Name)
  %91 = call i64 @consExt(i64 %0)
; # (cons (setq Sym (consExt Name)) $Nil)
  %92 = call i64 @cons(i64 %91, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %93 = inttoptr i64 %87 to i64*
  store i64 %92, i64* %93
  br label %$7
$17:
  %94 = phi i64 [%82, %$15] ; # X
  %95 = phi i64 [%80, %$15] ; # C
  %96 = phi i64 [%81, %$15] ; # Sym
  %97 = phi i64 [%84, %$15] ; # Y
  br label %$8
$8:
  %98 = phi i64 [%60, %$13], [%94, %$17] ; # X
  %99 = phi i64 [%61, %$13], [%95, %$17] ; # C
  %100 = phi i64 [%62, %$13], [%96, %$17] ; # Sym
  %101 = phi i64 [%63, %$13], [%97, %$17] ; # Y
  br label %$2
$7:
  %102 = phi i64 [%2, %$5], [%34, %$12], [%52, %$14], [%70, %$16], [%87, %$18] ; # X
  %103 = phi i64 [%4, %$5], [%35, %$12], [%53, %$14], [%71, %$16], [%88, %$18] ; # C
  %104 = phi i64 [%6, %$5], [%38, %$12], [%56, %$14], [%74, %$16], [%91, %$18] ; # Sym
  %105 = phi i64 [0, %$5], [%40, %$12], [%57, %$14], [%76, %$16], [%92, %$18] ; # ->
; # (shr C 1)
  %106 = lshr i64 %103, 1
; # (when (> (shl 1 C) (val $ExtCnt)) (setq X (val $Extern)) (let N (...
; # (shl 1 C)
  %107 = shl i64 1, %106
; # (val $ExtCnt)
  %108 = load i64, i64* @$ExtCnt
; # (> (shl 1 C) (val $ExtCnt))
  %109 = icmp ugt i64 %107, %108
  br i1 %109, label %$19, label %$20
$19:
  %110 = phi i64 [%102, %$7] ; # X
  %111 = phi i64 [%106, %$7] ; # C
  %112 = phi i64 [%104, %$7] ; # Sym
; # (val $Extern)
  %113 = load i64, i64* @$Extern
; # (let N (val $ExtSkip) (if (> (inc 'N) C) (set $ExtSkip 0) (set $E...
; # (val $ExtSkip)
  %114 = load i64, i64* @$ExtSkip
; # (if (> (inc 'N) C) (set $ExtSkip 0) (set $ExtSkip N) (loop (setq ...
; # (inc 'N)
  %115 = add i64 %114, 1
; # (> (inc 'N) C)
  %116 = icmp ugt i64 %115, %111
  br i1 %116, label %$21, label %$22
$21:
  %117 = phi i64 [%113, %$19] ; # X
  %118 = phi i64 [%111, %$19] ; # C
  %119 = phi i64 [%112, %$19] ; # Sym
  %120 = phi i64 [%115, %$19] ; # N
; # (set $ExtSkip 0)
  store i64 0, i64* @$ExtSkip
  br label %$23
$22:
  %121 = phi i64 [%113, %$19] ; # X
  %122 = phi i64 [%111, %$19] ; # C
  %123 = phi i64 [%112, %$19] ; # Sym
  %124 = phi i64 [%115, %$19] ; # N
; # (set $ExtSkip N)
  store i64 %124, i64* @$ExtSkip
; # (loop (setq X (if (> Name (& (name (& (val (tail (++ X))) -9)) (h...
  br label %$24
$24:
  %125 = phi i64 [%121, %$22], [%167, %$31] ; # X
  %126 = phi i64 [%122, %$22], [%168, %$31] ; # C
  %127 = phi i64 [%123, %$22], [%169, %$31] ; # Sym
  %128 = phi i64 [%124, %$22], [%170, %$31] ; # N
; # (if (> Name (& (name (& (val (tail (++ X))) -9)) (hex "3FFFFFFFFF...
; # (++ X)
  %129 = inttoptr i64 %125 to i64*
  %130 = load i64, i64* %129
  %131 = getelementptr i64, i64* %129, i32 1
  %132 = load i64, i64* %131
; # (tail (++ X))
  %133 = add i64 %130, -8
; # (val (tail (++ X)))
  %134 = inttoptr i64 %133 to i64*
  %135 = load i64, i64* %134
; # (& (val (tail (++ X))) -9)
  %136 = and i64 %135, -9
; # (name (& (val (tail (++ X))) -9))
  br label %$25
$25:
  %137 = phi i64 [%136, %$24], [%143, %$26] ; # Tail
  %138 = and i64 %137, 6
  %139 = icmp ne i64 %138, 0
  br i1 %139, label %$27, label %$26
$26:
  %140 = phi i64 [%137, %$25] ; # Tail
  %141 = inttoptr i64 %140 to i64*
  %142 = getelementptr i64, i64* %141, i32 1
  %143 = load i64, i64* %142
  br label %$25
$27:
  %144 = phi i64 [%137, %$25] ; # Tail
; # (& (name (& (val (tail (++ X))) -9)) (hex "3FFFFFFFFFFFFFF7"))
  %145 = and i64 %144, 4611686018427387895
; # (> Name (& (name (& (val (tail (++ X))) -9)) (hex "3FFFFFFFFFFFFF...
  %146 = icmp ugt i64 %0, %145
  br i1 %146, label %$28, label %$29
$28:
  %147 = phi i64 [%132, %$27] ; # X
  %148 = phi i64 [%126, %$27] ; # C
  %149 = phi i64 [%127, %$27] ; # Sym
  %150 = phi i64 [%128, %$27] ; # N
; # (cdr X)
  %151 = inttoptr i64 %147 to i64*
  %152 = getelementptr i64, i64* %151, i32 1
  %153 = load i64, i64* %152
  br label %$30
$29:
  %154 = phi i64 [%132, %$27] ; # X
  %155 = phi i64 [%126, %$27] ; # C
  %156 = phi i64 [%127, %$27] ; # Sym
  %157 = phi i64 [%128, %$27] ; # N
; # (car X)
  %158 = inttoptr i64 %154 to i64*
  %159 = load i64, i64* %158
  br label %$30
$30:
  %160 = phi i64 [%147, %$28], [%154, %$29] ; # X
  %161 = phi i64 [%148, %$28], [%155, %$29] ; # C
  %162 = phi i64 [%149, %$28], [%156, %$29] ; # Sym
  %163 = phi i64 [%150, %$28], [%157, %$29] ; # N
  %164 = phi i64 [%153, %$28], [%159, %$29] ; # ->
; # (? (=0 (dec 'C)))
; # (dec 'C)
  %165 = sub i64 %161, 1
; # (=0 (dec 'C))
  %166 = icmp eq i64 %165, 0
  br i1 %166, label %$32, label %$31
$31:
  %167 = phi i64 [%164, %$30] ; # X
  %168 = phi i64 [%165, %$30] ; # C
  %169 = phi i64 [%162, %$30] ; # Sym
  %170 = phi i64 [%163, %$30] ; # N
  br label %$24
$32:
  %171 = phi i64 [%164, %$30] ; # X
  %172 = phi i64 [%165, %$30] ; # C
  %173 = phi i64 [%162, %$30] ; # Sym
  %174 = phi i64 [%163, %$30] ; # N
  %175 = phi i64 [0, %$30] ; # ->
  br label %$23
$23:
  %176 = phi i64 [%117, %$21], [%171, %$32] ; # X
  %177 = phi i64 [%118, %$21], [%172, %$32] ; # C
  %178 = phi i64 [%119, %$21], [%173, %$32] ; # Sym
  %179 = phi i64 [%120, %$21], [%174, %$32] ; # N
  %180 = phi i64 [0, %$21], [%175, %$32] ; # ->
; # (loop (let (Nm (& (name (& (val (tail (car X))) -9)) (hex "3FFFFF...
  br label %$33
$33:
  %181 = phi i64 [%176, %$23], [%282, %$41] ; # X
  %182 = phi i64 [%177, %$23], [%283, %$41] ; # C
  %183 = phi i64 [%178, %$23], [%284, %$41] ; # Sym
; # (let (Nm (& (name (& (val (tail (car X))) -9)) (hex "3FFFFFFFFFFF...
; # (car X)
  %184 = inttoptr i64 %181 to i64*
  %185 = load i64, i64* %184
; # (tail (car X))
  %186 = add i64 %185, -8
; # (val (tail (car X)))
  %187 = inttoptr i64 %186 to i64*
  %188 = load i64, i64* %187
; # (& (val (tail (car X))) -9)
  %189 = and i64 %188, -9
; # (name (& (val (tail (car X))) -9))
  br label %$34
$34:
  %190 = phi i64 [%189, %$33], [%196, %$35] ; # Tail
  %191 = and i64 %190, 6
  %192 = icmp ne i64 %191, 0
  br i1 %192, label %$36, label %$35
$35:
  %193 = phi i64 [%190, %$34] ; # Tail
  %194 = inttoptr i64 %193 to i64*
  %195 = getelementptr i64, i64* %194, i32 1
  %196 = load i64, i64* %195
  br label %$34
$36:
  %197 = phi i64 [%190, %$34] ; # Tail
; # (& (name (& (val (tail (car X))) -9)) (hex "3FFFFFFFFFFFFFF7"))
  %198 = and i64 %197, 4611686018427387895
; # (cdr X)
  %199 = inttoptr i64 %181 to i64*
  %200 = getelementptr i64, i64* %199, i32 1
  %201 = load i64, i64* %200
; # (? (== Nm Name))
; # (== Nm Name)
  %202 = icmp eq i64 %198, %0
  br i1 %202, label %$38, label %$37
$37:
  %203 = phi i64 [%181, %$36] ; # X
  %204 = phi i64 [%182, %$36] ; # C
  %205 = phi i64 [%183, %$36] ; # Sym
; # (if (> Name Nm) (let Z (cdr Y) (? (atom (cdr Z))) (xchg Z X) (set...
; # (> Name Nm)
  %206 = icmp ugt i64 %0, %198
  br i1 %206, label %$39, label %$40
$39:
  %207 = phi i64 [%203, %$37] ; # X
  %208 = phi i64 [%204, %$37] ; # C
  %209 = phi i64 [%205, %$37] ; # Sym
; # (let Z (cdr Y) (? (atom (cdr Z))) (xchg Z X) (setq Z (cdr Z) X (c...
; # (cdr Y)
  %210 = inttoptr i64 %201 to i64*
  %211 = getelementptr i64, i64* %210, i32 1
  %212 = load i64, i64* %211
; # (? (atom (cdr Z)))
; # (cdr Z)
  %213 = inttoptr i64 %212 to i64*
  %214 = getelementptr i64, i64* %213, i32 1
  %215 = load i64, i64* %214
; # (atom (cdr Z))
  %216 = and i64 %215, 15
  %217 = icmp ne i64 %216, 0
  br i1 %217, label %$38, label %$42
$42:
  %218 = phi i64 [%207, %$39] ; # X
  %219 = phi i64 [%208, %$39] ; # C
  %220 = phi i64 [%209, %$39] ; # Sym
  %221 = phi i64 [%212, %$39] ; # Z
; # (xchg Z X)
  %222 = inttoptr i64 %221 to i64*
  %223 = load i64, i64* %222
  %224 = inttoptr i64 %218 to i64*
  %225 = load i64, i64* %224
  store i64 %225, i64* %222
  store i64 %223, i64* %224
; # (cdr Z)
  %226 = inttoptr i64 %221 to i64*
  %227 = getelementptr i64, i64* %226, i32 1
  %228 = load i64, i64* %227
; # (cdr Z)
  %229 = inttoptr i64 %228 to i64*
  %230 = getelementptr i64, i64* %229, i32 1
  %231 = load i64, i64* %230
; # (set 2 Z (val Z) Z (val Y) Y (cdr Y) 2 Y X)
; # (val Z)
  %232 = inttoptr i64 %228 to i64*
  %233 = load i64, i64* %232
  %234 = inttoptr i64 %228 to i64*
  %235 = getelementptr i64, i64* %234, i32 1
  store i64 %233, i64* %235
; # (val Y)
  %236 = inttoptr i64 %201 to i64*
  %237 = load i64, i64* %236
  %238 = inttoptr i64 %228 to i64*
  store i64 %237, i64* %238
; # (cdr Y)
  %239 = inttoptr i64 %201 to i64*
  %240 = getelementptr i64, i64* %239, i32 1
  %241 = load i64, i64* %240
  %242 = inttoptr i64 %201 to i64*
  store i64 %241, i64* %242
  %243 = inttoptr i64 %201 to i64*
  %244 = getelementptr i64, i64* %243, i32 1
  store i64 %231, i64* %244
  br label %$41
$40:
  %245 = phi i64 [%203, %$37] ; # X
  %246 = phi i64 [%204, %$37] ; # C
  %247 = phi i64 [%205, %$37] ; # Sym
; # (let Z (car Y) (? (atom (cdr Z))) (xchg Z X) (setq Z (cdr Z) X (v...
; # (car Y)
  %248 = inttoptr i64 %201 to i64*
  %249 = load i64, i64* %248
; # (? (atom (cdr Z)))
; # (cdr Z)
  %250 = inttoptr i64 %249 to i64*
  %251 = getelementptr i64, i64* %250, i32 1
  %252 = load i64, i64* %251
; # (atom (cdr Z))
  %253 = and i64 %252, 15
  %254 = icmp ne i64 %253, 0
  br i1 %254, label %$38, label %$43
$43:
  %255 = phi i64 [%245, %$40] ; # X
  %256 = phi i64 [%246, %$40] ; # C
  %257 = phi i64 [%247, %$40] ; # Sym
  %258 = phi i64 [%249, %$40] ; # Z
; # (xchg Z X)
  %259 = inttoptr i64 %258 to i64*
  %260 = load i64, i64* %259
  %261 = inttoptr i64 %255 to i64*
  %262 = load i64, i64* %261
  store i64 %262, i64* %259
  store i64 %260, i64* %261
; # (cdr Z)
  %263 = inttoptr i64 %258 to i64*
  %264 = getelementptr i64, i64* %263, i32 1
  %265 = load i64, i64* %264
; # (val Z)
  %266 = inttoptr i64 %265 to i64*
  %267 = load i64, i64* %266
; # (set Z (cdr Z) 2 Z (cdr Y) 2 Y (val Y) Y X)
; # (cdr Z)
  %268 = inttoptr i64 %265 to i64*
  %269 = getelementptr i64, i64* %268, i32 1
  %270 = load i64, i64* %269
  %271 = inttoptr i64 %265 to i64*
  store i64 %270, i64* %271
; # (cdr Y)
  %272 = inttoptr i64 %201 to i64*
  %273 = getelementptr i64, i64* %272, i32 1
  %274 = load i64, i64* %273
  %275 = inttoptr i64 %265 to i64*
  %276 = getelementptr i64, i64* %275, i32 1
  store i64 %274, i64* %276
; # (val Y)
  %277 = inttoptr i64 %201 to i64*
  %278 = load i64, i64* %277
  %279 = inttoptr i64 %201 to i64*
  %280 = getelementptr i64, i64* %279, i32 1
  store i64 %278, i64* %280
  %281 = inttoptr i64 %201 to i64*
  store i64 %267, i64* %281
  br label %$41
$41:
  %282 = phi i64 [%231, %$42], [%267, %$43] ; # X
  %283 = phi i64 [%219, %$42], [%256, %$43] ; # C
  %284 = phi i64 [%220, %$42], [%257, %$43] ; # Sym
  %285 = phi i64 [%231, %$42], [%267, %$43] ; # ->
  br label %$33
$38:
  %286 = phi i64 [%181, %$36], [%207, %$39], [%245, %$40] ; # X
  %287 = phi i64 [%182, %$36], [%208, %$39], [%246, %$40] ; # C
  %288 = phi i64 [%183, %$36], [%209, %$39], [%247, %$40] ; # Sym
  %289 = phi i64 [0, %$36], [0, %$39], [0, %$40] ; # ->
  br label %$20
$20:
  %290 = phi i64 [%102, %$7], [%286, %$38] ; # X
  %291 = phi i64 [%106, %$7], [%287, %$38] ; # C
  %292 = phi i64 [%104, %$7], [%288, %$38] ; # Sym
  ret i64 %292
}

define void @delNode(i64, i64) align 8 {
$1:
; # (let Y (cdr X) (cond ((atom (car Y)) (set P (cdr Y))) ((atom (cdr...
; # (cdr X)
  %2 = inttoptr i64 %0 to i64*
  %3 = getelementptr i64, i64* %2, i32 1
  %4 = load i64, i64* %3
; # (cond ((atom (car Y)) (set P (cdr Y))) ((atom (cdr Y)) (set P (ca...
; # (car Y)
  %5 = inttoptr i64 %4 to i64*
  %6 = load i64, i64* %5
; # (atom (car Y))
  %7 = and i64 %6, 15
  %8 = icmp ne i64 %7, 0
  br i1 %8, label %$4, label %$3
$4:
  %9 = phi i64 [%1, %$1] ; # P
  %10 = phi i64 [%4, %$1] ; # Y
; # (set P (cdr Y))
; # (cdr Y)
  %11 = inttoptr i64 %10 to i64*
  %12 = getelementptr i64, i64* %11, i32 1
  %13 = load i64, i64* %12
  %14 = inttoptr i64 %9 to i64*
  store i64 %13, i64* %14
  br label %$2
$3:
  %15 = phi i64 [%1, %$1] ; # P
  %16 = phi i64 [%4, %$1] ; # Y
; # (cdr Y)
  %17 = inttoptr i64 %16 to i64*
  %18 = getelementptr i64, i64* %17, i32 1
  %19 = load i64, i64* %18
; # (atom (cdr Y))
  %20 = and i64 %19, 15
  %21 = icmp ne i64 %20, 0
  br i1 %21, label %$6, label %$5
$6:
  %22 = phi i64 [%15, %$3] ; # P
  %23 = phi i64 [%16, %$3] ; # Y
; # (set P (car Y))
; # (car Y)
  %24 = inttoptr i64 %23 to i64*
  %25 = load i64, i64* %24
  %26 = inttoptr i64 %22 to i64*
  store i64 %25, i64* %26
  br label %$2
$5:
  %27 = phi i64 [%15, %$3] ; # P
  %28 = phi i64 [%16, %$3] ; # Y
; # (shift Y)
  %29 = inttoptr i64 %28 to i64*
  %30 = getelementptr i64, i64* %29, i32 1
  %31 = load i64, i64* %30
; # (cdr (shift Y))
  %32 = inttoptr i64 %31 to i64*
  %33 = getelementptr i64, i64* %32, i32 1
  %34 = load i64, i64* %33
; # (car (setq P (cdr (shift Y))))
  %35 = inttoptr i64 %34 to i64*
  %36 = load i64, i64* %35
; # (atom (car (setq P (cdr (shift Y)))))
  %37 = and i64 %36, 15
  %38 = icmp ne i64 %37, 0
  br i1 %38, label %$8, label %$7
$8:
  %39 = phi i64 [%34, %$5] ; # P
  %40 = phi i64 [%31, %$5] ; # Y
; # (set X (car Y) 2 (cdr X) (cdr P))
; # (car Y)
  %41 = inttoptr i64 %40 to i64*
  %42 = load i64, i64* %41
  %43 = inttoptr i64 %0 to i64*
  store i64 %42, i64* %43
; # (cdr X)
  %44 = inttoptr i64 %0 to i64*
  %45 = getelementptr i64, i64* %44, i32 1
  %46 = load i64, i64* %45
; # (cdr P)
  %47 = inttoptr i64 %39 to i64*
  %48 = getelementptr i64, i64* %47, i32 1
  %49 = load i64, i64* %48
  %50 = inttoptr i64 %46 to i64*
  %51 = getelementptr i64, i64* %50, i32 1
  store i64 %49, i64* %51
  br label %$2
$7:
  %52 = phi i64 [%34, %$5] ; # P
  %53 = phi i64 [%31, %$5] ; # Y
; # (car P)
  %54 = inttoptr i64 %52 to i64*
  %55 = load i64, i64* %54
; # (loop (let Z (cdr P) (? (atom (car Z)) (set X (car P) (cdr Y) (cd...
  br label %$9
$9:
  %56 = phi i64 [%55, %$7], [%80, %$10] ; # P
  %57 = phi i64 [%53, %$7], [%77, %$10] ; # Y
; # (let Z (cdr P) (? (atom (car Z)) (set X (car P) (cdr Y) (cdr Z)))...
; # (cdr P)
  %58 = inttoptr i64 %56 to i64*
  %59 = getelementptr i64, i64* %58, i32 1
  %60 = load i64, i64* %59
; # (? (atom (car Z)) (set X (car P) (cdr Y) (cdr Z)))
; # (car Z)
  %61 = inttoptr i64 %60 to i64*
  %62 = load i64, i64* %61
; # (atom (car Z))
  %63 = and i64 %62, 15
  %64 = icmp ne i64 %63, 0
  br i1 %64, label %$12, label %$10
$12:
  %65 = phi i64 [%56, %$9] ; # P
  %66 = phi i64 [%57, %$9] ; # Y
; # (set X (car P) (cdr Y) (cdr Z))
; # (car P)
  %67 = inttoptr i64 %65 to i64*
  %68 = load i64, i64* %67
  %69 = inttoptr i64 %0 to i64*
  store i64 %68, i64* %69
; # (cdr Y)
  %70 = inttoptr i64 %66 to i64*
  %71 = getelementptr i64, i64* %70, i32 1
  %72 = load i64, i64* %71
; # (cdr Z)
  %73 = inttoptr i64 %60 to i64*
  %74 = getelementptr i64, i64* %73, i32 1
  %75 = load i64, i64* %74
  %76 = inttoptr i64 %72 to i64*
  store i64 %75, i64* %76
  br label %$11
$10:
  %77 = phi i64 [%56, %$9] ; # P
  %78 = phi i64 [%57, %$9] ; # Y
; # (car Z)
  %79 = inttoptr i64 %60 to i64*
  %80 = load i64, i64* %79
  br label %$9
$11:
  %81 = phi i64 [%65, %$12] ; # P
  %82 = phi i64 [%66, %$12] ; # Y
  %83 = phi i64 [%75, %$12] ; # ->
  br label %$2
$2:
  %84 = phi i64 [%9, %$4], [%22, %$6], [%39, %$8], [%81, %$11] ; # P
  %85 = phi i64 [%10, %$4], [%23, %$6], [%40, %$8], [%82, %$11] ; # Y
  %86 = phi i64 [%13, %$4], [%25, %$6], [%49, %$8], [%83, %$11] ; # ->
  ret void
}

define void @unintern(i64, i64, i64) align 8 {
$1:
; # (if (cnt? Name) (loop (let X (car P) (? (atom X)) (let (S (car X)...
; # (cnt? Name)
  %3 = and i64 %1, 2
  %4 = icmp ne i64 %3, 0
  br i1 %4, label %$2, label %$3
$2:
  %5 = phi i64 [%2, %$1] ; # P
; # (loop (let X (car P) (? (atom X)) (let (S (car X) Nm (name (val (...
  br label %$5
$5:
  %6 = phi i64 [%5, %$2], [%51, %$18] ; # P
; # (let X (car P) (? (atom X)) (let (S (car X) Nm (name (val (tail S...
; # (car P)
  %7 = inttoptr i64 %6 to i64*
  %8 = load i64, i64* %7
; # (? (atom X))
; # (atom X)
  %9 = and i64 %8, 15
  %10 = icmp ne i64 %9, 0
  br i1 %10, label %$7, label %$6
$6:
  %11 = phi i64 [%6, %$5] ; # P
  %12 = phi i64 [%8, %$5] ; # X
; # (let (S (car X) Nm (name (val (tail S)))) (? (== Name Nm) (when (...
; # (car X)
  %13 = inttoptr i64 %12 to i64*
  %14 = load i64, i64* %13
; # (tail S)
  %15 = add i64 %14, -8
; # (val (tail S))
  %16 = inttoptr i64 %15 to i64*
  %17 = load i64, i64* %16
; # (name (val (tail S)))
  br label %$8
$8:
  %18 = phi i64 [%17, %$6], [%24, %$9] ; # Tail
  %19 = and i64 %18, 6
  %20 = icmp ne i64 %19, 0
  br i1 %20, label %$10, label %$9
$9:
  %21 = phi i64 [%18, %$8] ; # Tail
  %22 = inttoptr i64 %21 to i64*
  %23 = getelementptr i64, i64* %22, i32 1
  %24 = load i64, i64* %23
  br label %$8
$10:
  %25 = phi i64 [%18, %$8] ; # Tail
; # (? (== Name Nm) (when (== S Sym) (delNode X P)))
; # (== Name Nm)
  %26 = icmp eq i64 %1, %25
  br i1 %26, label %$12, label %$11
$12:
  %27 = phi i64 [%11, %$10] ; # P
  %28 = phi i64 [%12, %$10] ; # X
; # (when (== S Sym) (delNode X P))
; # (== S Sym)
  %29 = icmp eq i64 %14, %0
  br i1 %29, label %$13, label %$14
$13:
  %30 = phi i64 [%27, %$12] ; # P
  %31 = phi i64 [%28, %$12] ; # X
; # (delNode X P)
  call void @delNode(i64 %31, i64 %30)
  br label %$14
$14:
  %32 = phi i64 [%27, %$12], [%30, %$13] ; # P
  %33 = phi i64 [%28, %$12], [%31, %$13] ; # X
  br label %$7
$11:
  %34 = phi i64 [%11, %$10] ; # P
  %35 = phi i64 [%12, %$10] ; # X
; # (? (atom (shift X)))
; # (shift X)
  %36 = inttoptr i64 %35 to i64*
  %37 = getelementptr i64, i64* %36, i32 1
  %38 = load i64, i64* %37
; # (atom (shift X))
  %39 = and i64 %38, 15
  %40 = icmp ne i64 %39, 0
  br i1 %40, label %$7, label %$15
$15:
  %41 = phi i64 [%34, %$11] ; # P
  %42 = phi i64 [%38, %$11] ; # X
; # (if (> Name Nm) (ofs X 1) X)
; # (> Name Nm)
  %43 = icmp ugt i64 %1, %25
  br i1 %43, label %$16, label %$17
$16:
  %44 = phi i64 [%41, %$15] ; # P
  %45 = phi i64 [%42, %$15] ; # X
; # (ofs X 1)
  %46 = add i64 %45, 8
  br label %$18
$17:
  %47 = phi i64 [%41, %$15] ; # P
  %48 = phi i64 [%42, %$15] ; # X
  br label %$18
$18:
  %49 = phi i64 [%44, %$16], [%47, %$17] ; # P
  %50 = phi i64 [%45, %$16], [%48, %$17] ; # X
  %51 = phi i64 [%46, %$16], [%48, %$17] ; # ->
  br label %$5
$7:
  %52 = phi i64 [%6, %$5], [%32, %$14], [%34, %$11] ; # P
  br label %$4
$3:
  %53 = phi i64 [%2, %$1] ; # P
; # (ofs P 1)
  %54 = add i64 %53, 8
; # (loop (let X (car P) (? (atom X)) (let (S (car X) Nm (name (val (...
  br label %$19
$19:
  %55 = phi i64 [%54, %$3], [%101, %$32] ; # P
; # (let X (car P) (? (atom X)) (let (S (car X) Nm (name (val (tail S...
; # (car P)
  %56 = inttoptr i64 %55 to i64*
  %57 = load i64, i64* %56
; # (? (atom X))
; # (atom X)
  %58 = and i64 %57, 15
  %59 = icmp ne i64 %58, 0
  br i1 %59, label %$21, label %$20
$20:
  %60 = phi i64 [%55, %$19] ; # P
  %61 = phi i64 [%57, %$19] ; # X
; # (let (S (car X) Nm (name (val (tail S))) I (cmpLong Nm Name)) (? ...
; # (car X)
  %62 = inttoptr i64 %61 to i64*
  %63 = load i64, i64* %62
; # (tail S)
  %64 = add i64 %63, -8
; # (val (tail S))
  %65 = inttoptr i64 %64 to i64*
  %66 = load i64, i64* %65
; # (name (val (tail S)))
  br label %$22
$22:
  %67 = phi i64 [%66, %$20], [%73, %$23] ; # Tail
  %68 = and i64 %67, 6
  %69 = icmp ne i64 %68, 0
  br i1 %69, label %$24, label %$23
$23:
  %70 = phi i64 [%67, %$22] ; # Tail
  %71 = inttoptr i64 %70 to i64*
  %72 = getelementptr i64, i64* %71, i32 1
  %73 = load i64, i64* %72
  br label %$22
$24:
  %74 = phi i64 [%67, %$22] ; # Tail
; # (cmpLong Nm Name)
  %75 = call i64 @cmpLong(i64 %74, i64 %1)
; # (? (=0 I) (when (== S Sym) (delNode X P)))
; # (=0 I)
  %76 = icmp eq i64 %75, 0
  br i1 %76, label %$26, label %$25
$26:
  %77 = phi i64 [%60, %$24] ; # P
  %78 = phi i64 [%61, %$24] ; # X
; # (when (== S Sym) (delNode X P))
; # (== S Sym)
  %79 = icmp eq i64 %63, %0
  br i1 %79, label %$27, label %$28
$27:
  %80 = phi i64 [%77, %$26] ; # P
  %81 = phi i64 [%78, %$26] ; # X
; # (delNode X P)
  call void @delNode(i64 %81, i64 %80)
  br label %$28
$28:
  %82 = phi i64 [%77, %$26], [%80, %$27] ; # P
  %83 = phi i64 [%78, %$26], [%81, %$27] ; # X
  br label %$21
$25:
  %84 = phi i64 [%60, %$24] ; # P
  %85 = phi i64 [%61, %$24] ; # X
; # (? (atom (shift X)))
; # (shift X)
  %86 = inttoptr i64 %85 to i64*
  %87 = getelementptr i64, i64* %86, i32 1
  %88 = load i64, i64* %87
; # (atom (shift X))
  %89 = and i64 %88, 15
  %90 = icmp ne i64 %89, 0
  br i1 %90, label %$21, label %$29
$29:
  %91 = phi i64 [%84, %$25] ; # P
  %92 = phi i64 [%88, %$25] ; # X
; # (if (lt0 I) (ofs X 1) X)
; # (lt0 I)
  %93 = icmp slt i64 %75, 0
  br i1 %93, label %$30, label %$31
$30:
  %94 = phi i64 [%91, %$29] ; # P
  %95 = phi i64 [%92, %$29] ; # X
; # (ofs X 1)
  %96 = add i64 %95, 8
  br label %$32
$31:
  %97 = phi i64 [%91, %$29] ; # P
  %98 = phi i64 [%92, %$29] ; # X
  br label %$32
$32:
  %99 = phi i64 [%94, %$30], [%97, %$31] ; # P
  %100 = phi i64 [%95, %$30], [%98, %$31] ; # X
  %101 = phi i64 [%96, %$30], [%98, %$31] ; # ->
  br label %$19
$21:
  %102 = phi i64 [%55, %$19], [%82, %$28], [%84, %$25] ; # P
  br label %$4
$4:
  %103 = phi i64 [%52, %$7], [%102, %$21] ; # P
  ret void
}

define i64 @_Name(i64) align 8 {
$1:
; # (let Tail (val (tail (needSymb Exe (eval (cadr Exe))))) (if (sym?...
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (needSymb Exe (eval (cadr Exe)))
  %14 = xor i64 %13, 8
  %15 = and i64 %14, 14
  %16 = icmp eq i64 %15, 0
  br i1 %16, label %$8, label %$7
$7:
  call void @symErr(i64 %0, i64 %13)
  unreachable
$8:
; # (tail (needSymb Exe (eval (cadr Exe))))
  %17 = add i64 %13, -8
; # (val (tail (needSymb Exe (eval (cadr Exe)))))
  %18 = inttoptr i64 %17 to i64*
  %19 = load i64, i64* %18
; # (if (sym? Tail) (let P (push 4 NIL ZERO NIL) (link (ofs P 2) T) (...
; # (sym? Tail)
  %20 = and i64 %19, 8
  %21 = icmp ne i64 %20, 0
  br i1 %21, label %$9, label %$10
$9:
; # (let P (push 4 NIL ZERO NIL) (link (ofs P 2) T) (packExtNm (name ...
; # (push 4 NIL ZERO NIL)
  %22 = alloca i64, i64 4, align 16
  store i64 4, i64* %22
  %23 = getelementptr i64, i64* %22, i32 2
  store i64 2, i64* %23
; # (ofs P 2)
  %24 = getelementptr i64, i64* %22, i32 2
; # (link (ofs P 2) T)
  %25 = ptrtoint i64* %24 to i64
  %26 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %27 = load i64, i64* %26
  %28 = inttoptr i64 %25 to i64*
  %29 = getelementptr i64, i64* %28, i32 1
  store i64 %27, i64* %29
  %30 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %25, i64* %30
; # (& Tail -9)
  %31 = and i64 %19, -9
; # (name (& Tail -9))
  br label %$12
$12:
  %32 = phi i64 [%31, %$9], [%38, %$13] ; # Tail
  %33 = and i64 %32, 6
  %34 = icmp ne i64 %33, 0
  br i1 %34, label %$14, label %$13
$13:
  %35 = phi i64 [%32, %$12] ; # Tail
  %36 = inttoptr i64 %35 to i64*
  %37 = getelementptr i64, i64* %36, i32 1
  %38 = load i64, i64* %37
  br label %$12
$14:
  %39 = phi i64 [%32, %$12] ; # Tail
; # (packExtNm (name (& Tail -9)) P)
  call void @packExtNm(i64 %39, i64* %22)
; # (val 3 P)
  %40 = getelementptr i64, i64* %22, i32 2
  %41 = load i64, i64* %40
; # (consStr (val 3 P))
  %42 = call i64 @consStr(i64 %41)
; # (drop *Safe)
  %43 = inttoptr i64 %25 to i64*
  %44 = getelementptr i64, i64* %43, i32 1
  %45 = load i64, i64* %44
  %46 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %45, i64* %46
  br label %$11
$10:
; # (name Tail)
  br label %$15
$15:
  %47 = phi i64 [%19, %$10], [%53, %$16] ; # Tail
  %48 = and i64 %47, 6
  %49 = icmp ne i64 %48, 0
  br i1 %49, label %$17, label %$16
$16:
  %50 = phi i64 [%47, %$15] ; # Tail
  %51 = inttoptr i64 %50 to i64*
  %52 = getelementptr i64, i64* %51, i32 1
  %53 = load i64, i64* %52
  br label %$15
$17:
  %54 = phi i64 [%47, %$15] ; # Tail
; # (consStr (name Tail))
  %55 = call i64 @consStr(i64 %54)
  br label %$11
$11:
  %56 = phi i64 [%42, %$14], [%55, %$17] ; # ->
  ret i64 %56
}

define i64 @_Nsp(i64) align 8 {
$1:
; # (let Sym (needSymb Exe (eval (cadr Exe))) (if (sym? (val (tail Sy...
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (needSymb Exe (eval (cadr Exe)))
  %14 = xor i64 %13, 8
  %15 = and i64 %14, 14
  %16 = icmp eq i64 %15, 0
  br i1 %16, label %$8, label %$7
$7:
  call void @symErr(i64 %0, i64 %13)
  unreachable
$8:
; # (if (sym? (val (tail Sym))) $Nil (let Nm (name @) (if (== Sym (is...
; # (tail Sym)
  %17 = add i64 %13, -8
; # (val (tail Sym))
  %18 = inttoptr i64 %17 to i64*
  %19 = load i64, i64* %18
; # (sym? (val (tail Sym)))
  %20 = and i64 %19, 8
  %21 = icmp ne i64 %20, 0
  br i1 %21, label %$9, label %$10
$9:
  br label %$11
$10:
; # (let Nm (name @) (if (== Sym (isIntern Nm $PrivT)) $priv (let Lst...
; # (name @)
  br label %$12
$12:
  %22 = phi i64 [%19, %$10], [%28, %$13] ; # Tail
  %23 = and i64 %22, 6
  %24 = icmp ne i64 %23, 0
  br i1 %24, label %$14, label %$13
$13:
  %25 = phi i64 [%22, %$12] ; # Tail
  %26 = inttoptr i64 %25 to i64*
  %27 = getelementptr i64, i64* %26, i32 1
  %28 = load i64, i64* %27
  br label %$12
$14:
  %29 = phi i64 [%22, %$12] ; # Tail
; # (if (== Sym (isIntern Nm $PrivT)) $priv (let Lst (val $Intern) (l...
; # (isIntern Nm $PrivT)
  %30 = call i64 @isIntern(i64 %29, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 112) to i64))
; # (== Sym (isIntern Nm $PrivT))
  %31 = icmp eq i64 %13, %30
  br i1 %31, label %$15, label %$16
$15:
  br label %$17
$16:
; # (let Lst (val $Intern) (loop (? (atom Lst) $Nil) (let Nsp (car Ls...
; # (val $Intern)
  %32 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 0) to i64) to i64*
  %33 = load i64, i64* %32
; # (loop (? (atom Lst) $Nil) (let Nsp (car Lst) (? (== Sym (isIntern...
  br label %$18
$18:
  %34 = phi i64 [%33, %$16], [%52, %$22] ; # Lst
; # (? (atom Lst) $Nil)
; # (atom Lst)
  %35 = and i64 %34, 15
  %36 = icmp ne i64 %35, 0
  br i1 %36, label %$21, label %$19
$21:
  %37 = phi i64 [%34, %$18] ; # Lst
  br label %$20
$19:
  %38 = phi i64 [%34, %$18] ; # Lst
; # (let Nsp (car Lst) (? (== Sym (isIntern Nm (cdar Nsp))) Nsp))
; # (car Lst)
  %39 = inttoptr i64 %38 to i64*
  %40 = load i64, i64* %39
; # (? (== Sym (isIntern Nm (cdar Nsp))) Nsp)
; # (cdar Nsp)
  %41 = inttoptr i64 %40 to i64*
  %42 = load i64, i64* %41
  %43 = inttoptr i64 %42 to i64*
  %44 = getelementptr i64, i64* %43, i32 1
  %45 = load i64, i64* %44
; # (isIntern Nm (cdar Nsp))
  %46 = call i64 @isIntern(i64 %29, i64 %45)
; # (== Sym (isIntern Nm (cdar Nsp)))
  %47 = icmp eq i64 %13, %46
  br i1 %47, label %$23, label %$22
$23:
  %48 = phi i64 [%38, %$19] ; # Lst
  br label %$20
$22:
  %49 = phi i64 [%38, %$19] ; # Lst
; # (shift Lst)
  %50 = inttoptr i64 %49 to i64*
  %51 = getelementptr i64, i64* %50, i32 1
  %52 = load i64, i64* %51
  br label %$18
$20:
  %53 = phi i64 [%37, %$21], [%48, %$23] ; # Lst
  %54 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$21], [%40, %$23] ; # ->
  br label %$17
$17:
  %55 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 152) to i64), %$15], [%54, %$20] ; # ->
  br label %$11
$11:
  %56 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$9], [%55, %$17] ; # ->
  ret i64 %56
}

define i64 @_SpQ(i64) align 8 {
$1:
; # (if (isBlank (eval (cadr Exe))) $T $Nil)
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (isBlank (eval (cadr Exe)))
  %14 = call i1 @isBlank(i64 %13)
  br i1 %14, label %$7, label %$8
$7:
  br label %$9
$8:
  br label %$9
$9:
  %15 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # ->
  ret i64 %15
}

define i64 @_PatQ(i64) align 8 {
$1:
; # (let X (eval (cadr Exe)) (if (and (symb? X) (== (firstChar X) (ch...
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (if (and (symb? X) (== (firstChar X) (char "@"))) X $Nil)
; # (and (symb? X) (== (firstChar X) (char "@")))
; # (symb? X)
  %14 = xor i64 %13, 8
  %15 = and i64 %14, 14
  %16 = icmp eq i64 %15, 0
  br i1 %16, label %$8, label %$7
$8:
; # (firstChar X)
  %17 = call i32 @firstChar(i64 %13)
; # (== (firstChar X) (char "@"))
  %18 = icmp eq i32 %17, 64
  br label %$7
$7:
  %19 = phi i1 [0, %$2], [%18, %$8] ; # ->
  br i1 %19, label %$9, label %$10
$9:
  br label %$11
$10:
  br label %$11
$11:
  %20 = phi i64 [%13, %$9], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$10] ; # ->
  ret i64 %20
}

define i64 @_FunQ(i64) align 8 {
$1:
; # (if (funq (eval (cadr Exe))) @ $Nil)
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (funq (eval (cadr Exe)))
  %14 = call i64 @funq(i64 %13)
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$7, label %$8
$7:
  br label %$9
$8:
  br label %$9
$9:
  %16 = phi i64 [%14, %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # ->
  ret i64 %16
}

define i64 @_Getd(i64) align 8 {
$1:
; # (let (X (eval (cadr Exe)) V T) (cond ((not (symb? X)) $Nil) ((fun...
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (cond ((not (symb? X)) $Nil) ((funq (setq V (val X))) V) ((and (n...
; # (symb? X)
  %14 = xor i64 %13, 8
  %15 = and i64 %14, 14
  %16 = icmp eq i64 %15, 0
; # (not (symb? X))
  %17 = icmp eq i1 %16, 0
  br i1 %17, label %$9, label %$8
$9:
  br label %$7
$8:
; # (val X)
  %18 = inttoptr i64 %13 to i64*
  %19 = load i64, i64* %18
; # (funq (setq V (val X)))
  %20 = call i64 @funq(i64 %19)
  %21 = icmp ne i64 %20, 0
  br i1 %21, label %$11, label %$10
$11:
  %22 = phi i64 [%19, %$8] ; # V
  br label %$7
$10:
  %23 = phi i64 [%19, %$8] ; # V
; # (and (nil? V) (sharedLib X))
; # (nil? V)
  %24 = icmp eq i64 %23, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %24, label %$13, label %$12
$13:
  %25 = phi i64 [%23, %$10] ; # V
; # (sharedLib X)
  %26 = call i1 @sharedLib(i64 %13)
  br label %$12
$12:
  %27 = phi i64 [%23, %$10], [%25, %$13] ; # V
  %28 = phi i1 [0, %$10], [%26, %$13] ; # ->
  br i1 %28, label %$15, label %$14
$15:
  %29 = phi i64 [%27, %$12] ; # V
; # (val X)
  %30 = inttoptr i64 %13 to i64*
  %31 = load i64, i64* %30
  br label %$7
$14:
  %32 = phi i64 [%27, %$12] ; # V
  br label %$7
$7:
  %33 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$9], [%22, %$11], [%31, %$15], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$14] ; # ->
  ret i64 %33
}

define i64 @consTree(i64, i64) align 8 {
$1:
; # (if (atom P) Lst (let (Q (link (push NIL NIL)) Tos (link (push -Z...
; # (atom P)
  %2 = and i64 %0, 15
  %3 = icmp ne i64 %2, 0
  br i1 %3, label %$2, label %$3
$2:
  %4 = phi i64 [%0, %$1] ; # P
  %5 = phi i64 [%1, %$1] ; # Lst
  br label %$4
$3:
  %6 = phi i64 [%0, %$1] ; # P
  %7 = phi i64 [%1, %$1] ; # Lst
; # (let (Q (link (push NIL NIL)) Tos (link (push -ZERO NIL))) (loop ...
; # (push NIL NIL)
  %8 = alloca i64, i64 2, align 16
  %9 = ptrtoint i64* %8 to i64
; # (link (push NIL NIL))
  %10 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %11 = load i64, i64* %10
  %12 = inttoptr i64 %9 to i64*
  %13 = getelementptr i64, i64* %12, i32 1
  store i64 %11, i64* %13
  %14 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %9, i64* %14
; # (push -ZERO NIL)
  %15 = alloca i64, i64 2, align 16
  %16 = ptrtoint i64* %15 to i64
  %17 = inttoptr i64 %16 to i64*
  store i64 10, i64* %17
; # (link (push -ZERO NIL))
  %18 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %19 = load i64, i64* %18
  %20 = inttoptr i64 %16 to i64*
  %21 = getelementptr i64, i64* %20, i32 1
  store i64 %19, i64* %21
  %22 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %16, i64* %22
; # (loop (loop (let X (cdr P) (? (atom (cdr X))) (let Y P (setq P @)...
  br label %$5
$5:
  %23 = phi i64 [%6, %$3], [%113, %$11] ; # P
  %24 = phi i64 [%7, %$3], [%114, %$11] ; # Lst
; # (loop (let X (cdr P) (? (atom (cdr X))) (let Y P (setq P @) (set ...
  br label %$6
$6:
  %25 = phi i64 [%23, %$5], [%32, %$7] ; # P
  %26 = phi i64 [%24, %$5], [%36, %$7] ; # Lst
; # (let X (cdr P) (? (atom (cdr X))) (let Y P (setq P @) (set 2 X (v...
; # (cdr P)
  %27 = inttoptr i64 %25 to i64*
  %28 = getelementptr i64, i64* %27, i32 1
  %29 = load i64, i64* %28
; # (? (atom (cdr X)))
; # (cdr X)
  %30 = inttoptr i64 %29 to i64*
  %31 = getelementptr i64, i64* %30, i32 1
  %32 = load i64, i64* %31
; # (atom (cdr X))
  %33 = and i64 %32, 15
  %34 = icmp ne i64 %33, 0
  br i1 %34, label %$8, label %$7
$7:
  %35 = phi i64 [%25, %$6] ; # P
  %36 = phi i64 [%26, %$6] ; # Lst
; # (let Y P (setq P @) (set 2 X (val Tos)) (set Tos Y))
; # (set 2 X (val Tos))
; # (val Tos)
  %37 = inttoptr i64 %16 to i64*
  %38 = load i64, i64* %37
  %39 = inttoptr i64 %29 to i64*
  %40 = getelementptr i64, i64* %39, i32 1
  store i64 %38, i64* %40
; # (set Tos Y)
  %41 = inttoptr i64 %16 to i64*
  store i64 %35, i64* %41
  br label %$6
$8:
  %42 = phi i64 [%25, %$6] ; # P
  %43 = phi i64 [%26, %$6] ; # Lst
  %44 = phi i64 [0, %$6] ; # ->
; # (set Q P)
  %45 = inttoptr i64 %9 to i64*
  store i64 %42, i64* %45
; # (loop (setq Lst (cons (car P) Lst)) (let X (cdr P) (? (pair (car ...
  br label %$9
$9:
  %46 = phi i64 [%42, %$8], [%110, %$17] ; # P
  %47 = phi i64 [%43, %$8], [%111, %$17] ; # Lst
; # (car P)
  %48 = inttoptr i64 %46 to i64*
  %49 = load i64, i64* %48
; # (cons (car P) Lst)
  %50 = call i64 @cons(i64 %49, i64 %47)
; # (let X (cdr P) (? (pair (car X)) (let Y P (setq P @) (set X (val ...
; # (cdr P)
  %51 = inttoptr i64 %46 to i64*
  %52 = getelementptr i64, i64* %51, i32 1
  %53 = load i64, i64* %52
; # (? (pair (car X)) (let Y P (setq P @) (set X (val Tos)) (set Tos ...
; # (car X)
  %54 = inttoptr i64 %53 to i64*
  %55 = load i64, i64* %54
; # (pair (car X))
  %56 = and i64 %55, 15
  %57 = icmp eq i64 %56, 0
  br i1 %57, label %$12, label %$10
$12:
  %58 = phi i64 [%46, %$9] ; # P
  %59 = phi i64 [%50, %$9] ; # Lst
; # (let Y P (setq P @) (set X (val Tos)) (set Tos (| Y 8)) (set Q P)...
; # (set X (val Tos))
; # (val Tos)
  %60 = inttoptr i64 %16 to i64*
  %61 = load i64, i64* %60
  %62 = inttoptr i64 %53 to i64*
  store i64 %61, i64* %62
; # (set Tos (| Y 8))
; # (| Y 8)
  %63 = or i64 %58, 8
  %64 = inttoptr i64 %16 to i64*
  store i64 %63, i64* %64
; # (set Q P)
  %65 = inttoptr i64 %9 to i64*
  store i64 %55, i64* %65
  br label %$11
$10:
  %66 = phi i64 [%46, %$9] ; # P
  %67 = phi i64 [%50, %$9] ; # Lst
; # (loop (let X (val Tos) (when (== -ZERO X) (drop Q) (ret Lst)) (? ...
  br label %$13
$13:
  %68 = phi i64 [%66, %$10], [%101, %$16] ; # P
  %69 = phi i64 [%67, %$10], [%99, %$16] ; # Lst
; # (let X (val Tos) (when (== -ZERO X) (drop Q) (ret Lst)) (? (=0 (&...
; # (val Tos)
  %70 = inttoptr i64 %16 to i64*
  %71 = load i64, i64* %70
; # (when (== -ZERO X) (drop Q) (ret Lst))
; # (== -ZERO X)
  %72 = icmp eq i64 10, %71
  br i1 %72, label %$14, label %$15
$14:
  %73 = phi i64 [%68, %$13] ; # P
  %74 = phi i64 [%69, %$13] ; # Lst
  %75 = phi i64 [%71, %$13] ; # X
; # (drop Q)
  %76 = inttoptr i64 %9 to i64*
  %77 = getelementptr i64, i64* %76, i32 1
  %78 = load i64, i64* %77
  %79 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %78, i64* %79
; # (ret Lst)
  ret i64 %74
$15:
  %80 = phi i64 [%68, %$13] ; # P
  %81 = phi i64 [%69, %$13] ; # Lst
  %82 = phi i64 [%71, %$13] ; # X
; # (? (=0 (& X 8)) (let Y (cdr X) (set Tos (cdr Y)) (set 2 Y P) (set...
; # (& X 8)
  %83 = and i64 %82, 8
; # (=0 (& X 8))
  %84 = icmp eq i64 %83, 0
  br i1 %84, label %$18, label %$16
$18:
  %85 = phi i64 [%80, %$15] ; # P
  %86 = phi i64 [%81, %$15] ; # Lst
  %87 = phi i64 [%82, %$15] ; # X
; # (let Y (cdr X) (set Tos (cdr Y)) (set 2 Y P) (setq P X) (set Q P)...
; # (cdr X)
  %88 = inttoptr i64 %87 to i64*
  %89 = getelementptr i64, i64* %88, i32 1
  %90 = load i64, i64* %89
; # (set Tos (cdr Y))
; # (cdr Y)
  %91 = inttoptr i64 %90 to i64*
  %92 = getelementptr i64, i64* %91, i32 1
  %93 = load i64, i64* %92
  %94 = inttoptr i64 %16 to i64*
  store i64 %93, i64* %94
; # (set 2 Y P)
  %95 = inttoptr i64 %90 to i64*
  %96 = getelementptr i64, i64* %95, i32 1
  store i64 %85, i64* %96
; # (set Q P)
  %97 = inttoptr i64 %9 to i64*
  store i64 %87, i64* %97
  br label %$17
$16:
  %98 = phi i64 [%80, %$15] ; # P
  %99 = phi i64 [%81, %$15] ; # Lst
  %100 = phi i64 [%82, %$15] ; # X
; # (& X -9)
  %101 = and i64 %100, -9
; # (let Y (cdr X) (set Tos (car Y)) (set Y P) (setq P X) (set Q P))
; # (cdr X)
  %102 = inttoptr i64 %101 to i64*
  %103 = getelementptr i64, i64* %102, i32 1
  %104 = load i64, i64* %103
; # (set Tos (car Y))
; # (car Y)
  %105 = inttoptr i64 %104 to i64*
  %106 = load i64, i64* %105
  %107 = inttoptr i64 %16 to i64*
  store i64 %106, i64* %107
; # (set Y P)
  %108 = inttoptr i64 %104 to i64*
  store i64 %98, i64* %108
; # (set Q P)
  %109 = inttoptr i64 %9 to i64*
  store i64 %101, i64* %109
  br label %$13
$17:
  %110 = phi i64 [%87, %$18] ; # P
  %111 = phi i64 [%86, %$18] ; # Lst
  %112 = phi i64 [%87, %$18] ; # ->
  br label %$9
$11:
  %113 = phi i64 [%55, %$12] ; # P
  %114 = phi i64 [%59, %$12] ; # Lst
  %115 = phi i64 [%55, %$12] ; # ->
  br label %$5
$4:
  %116 = phi i64 [%4, %$2] ; # P
  %117 = phi i64 [%5, %$2] ; # Lst
  %118 = phi i64 [%5, %$2] ; # ->
  ret i64 %118
}

define i64 @_All(i64) align 8 {
$1:
; # (let X (eval (cadr Exe)) (cond ((nil? X) (let Y (val $Intern) (lo...
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (cond ((nil? X) (let Y (val $Intern) (loop (let Z (cdar (++ Y)) (...
; # (nil? X)
  %14 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %14, label %$9, label %$8
$9:
  %15 = phi i64 [%13, %$2] ; # X
; # (let Y (val $Intern) (loop (let Z (cdar (++ Y)) (setq X (consTree...
; # (val $Intern)
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 0) to i64) to i64*
  %17 = load i64, i64* %16
; # (loop (let Z (cdar (++ Y)) (setq X (consTree (car Z) (consTree (c...
  br label %$10
$10:
  %18 = phi i64 [%15, %$9], [%40, %$11] ; # X
  %19 = phi i64 [%17, %$9], [%41, %$11] ; # Y
; # (let Z (cdar (++ Y)) (setq X (consTree (car Z) (consTree (cdr Z) ...
; # (++ Y)
  %20 = inttoptr i64 %19 to i64*
  %21 = load i64, i64* %20
  %22 = getelementptr i64, i64* %20, i32 1
  %23 = load i64, i64* %22
; # (cdar (++ Y))
  %24 = inttoptr i64 %21 to i64*
  %25 = load i64, i64* %24
  %26 = inttoptr i64 %25 to i64*
  %27 = getelementptr i64, i64* %26, i32 1
  %28 = load i64, i64* %27
; # (car Z)
  %29 = inttoptr i64 %28 to i64*
  %30 = load i64, i64* %29
; # (cdr Z)
  %31 = inttoptr i64 %28 to i64*
  %32 = getelementptr i64, i64* %31, i32 1
  %33 = load i64, i64* %32
; # (consTree (cdr Z) X)
  %34 = call i64 @consTree(i64 %33, i64 %18)
; # (consTree (car Z) (consTree (cdr Z) X))
  %35 = call i64 @consTree(i64 %30, i64 %34)
; # (? (atom Y) X)
; # (atom Y)
  %36 = and i64 %23, 15
  %37 = icmp ne i64 %36, 0
  br i1 %37, label %$13, label %$11
$13:
  %38 = phi i64 [%35, %$10] ; # X
  %39 = phi i64 [%23, %$10] ; # Y
  br label %$12
$11:
  %40 = phi i64 [%35, %$10] ; # X
  %41 = phi i64 [%23, %$10] ; # Y
  br label %$10
$12:
  %42 = phi i64 [%38, %$13] ; # X
  %43 = phi i64 [%39, %$13] ; # Y
  %44 = phi i64 [%38, %$13] ; # ->
  br label %$7
$8:
  %45 = phi i64 [%13, %$2] ; # X
; # (t? X)
  %46 = icmp eq i64 %45, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %46, label %$15, label %$14
$15:
  %47 = phi i64 [%45, %$8] ; # X
; # (val $Transient)
  %48 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 8) to i64) to i64*
  %49 = load i64, i64* %48
; # (val 2 $Transient)
  %50 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 8) to i64) to i64*
  %51 = getelementptr i64, i64* %50, i32 1
  %52 = load i64, i64* %51
; # (consTree (val 2 $Transient) $Nil)
  %53 = call i64 @consTree(i64 %52, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (consTree (val $Transient) (consTree (val 2 $Transient) $Nil))
  %54 = call i64 @consTree(i64 %49, i64 %53)
  br label %$7
$14:
  %55 = phi i64 [%45, %$8] ; # X
; # (num? X)
  %56 = and i64 %55, 6
  %57 = icmp ne i64 %56, 0
  br i1 %57, label %$17, label %$16
$17:
  %58 = phi i64 [%55, %$14] ; # X
; # (val $Extern)
  %59 = load i64, i64* @$Extern
; # (consTree (val $Extern) $Nil)
  %60 = call i64 @consTree(i64 %59, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  br label %$7
$16:
  %61 = phi i64 [%55, %$14] ; # X
; # (sym? X)
  %62 = and i64 %61, 8
  %63 = icmp ne i64 %62, 0
  br i1 %63, label %$19, label %$18
$19:
  %64 = phi i64 [%61, %$16] ; # X
; # (let Y (cdar X) (if (pair Y) (consTree (car Y) (consTree (cdr Y) ...
; # (cdar X)
  %65 = inttoptr i64 %64 to i64*
  %66 = load i64, i64* %65
  %67 = inttoptr i64 %66 to i64*
  %68 = getelementptr i64, i64* %67, i32 1
  %69 = load i64, i64* %68
; # (if (pair Y) (consTree (car Y) (consTree (cdr Y) $Nil)) $Nil)
; # (pair Y)
  %70 = and i64 %69, 15
  %71 = icmp eq i64 %70, 0
  br i1 %71, label %$20, label %$21
$20:
  %72 = phi i64 [%64, %$19] ; # X
; # (car Y)
  %73 = inttoptr i64 %69 to i64*
  %74 = load i64, i64* %73
; # (cdr Y)
  %75 = inttoptr i64 %69 to i64*
  %76 = getelementptr i64, i64* %75, i32 1
  %77 = load i64, i64* %76
; # (consTree (cdr Y) $Nil)
  %78 = call i64 @consTree(i64 %77, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (consTree (car Y) (consTree (cdr Y) $Nil))
  %79 = call i64 @consTree(i64 %74, i64 %78)
  br label %$22
$21:
  %80 = phi i64 [%64, %$19] ; # X
  br label %$22
$22:
  %81 = phi i64 [%72, %$20], [%80, %$21] ; # X
  %82 = phi i64 [%79, %$20], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$21] ; # ->
  br label %$7
$18:
  %83 = phi i64 [%61, %$16] ; # X
; # (car X)
  %84 = inttoptr i64 %83 to i64*
  %85 = load i64, i64* %84
; # (nil? (car X))
  %86 = icmp eq i64 %85, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %86, label %$24, label %$23
$24:
  %87 = phi i64 [%83, %$18] ; # X
; # (let Y (val (car (val $Intern))) (if (nil? (cdr X)) (val Y) (val ...
; # (val $Intern)
  %88 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 0) to i64) to i64*
  %89 = load i64, i64* %88
; # (car (val $Intern))
  %90 = inttoptr i64 %89 to i64*
  %91 = load i64, i64* %90
; # (val (car (val $Intern)))
  %92 = inttoptr i64 %91 to i64*
  %93 = load i64, i64* %92
; # (if (nil? (cdr X)) (val Y) (val 2 Y))
; # (cdr X)
  %94 = inttoptr i64 %87 to i64*
  %95 = getelementptr i64, i64* %94, i32 1
  %96 = load i64, i64* %95
; # (nil? (cdr X))
  %97 = icmp eq i64 %96, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %97, label %$25, label %$26
$25:
  %98 = phi i64 [%87, %$24] ; # X
; # (val Y)
  %99 = inttoptr i64 %93 to i64*
  %100 = load i64, i64* %99
  br label %$27
$26:
  %101 = phi i64 [%87, %$24] ; # X
; # (val 2 Y)
  %102 = inttoptr i64 %93 to i64*
  %103 = getelementptr i64, i64* %102, i32 1
  %104 = load i64, i64* %103
  br label %$27
$27:
  %105 = phi i64 [%98, %$25], [%101, %$26] ; # X
  %106 = phi i64 [%100, %$25], [%104, %$26] ; # ->
  br label %$7
$23:
  %107 = phi i64 [%83, %$18] ; # X
; # (car X)
  %108 = inttoptr i64 %107 to i64*
  %109 = load i64, i64* %108
; # (t? (car X))
  %110 = icmp eq i64 %109, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %110, label %$29, label %$28
$29:
  %111 = phi i64 [%107, %$23] ; # X
; # (if (nil? (cdr X)) (val $Transient) (val 2 $Transient))
; # (cdr X)
  %112 = inttoptr i64 %111 to i64*
  %113 = getelementptr i64, i64* %112, i32 1
  %114 = load i64, i64* %113
; # (nil? (cdr X))
  %115 = icmp eq i64 %114, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %115, label %$30, label %$31
$30:
  %116 = phi i64 [%111, %$29] ; # X
; # (val $Transient)
  %117 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 8) to i64) to i64*
  %118 = load i64, i64* %117
  br label %$32
$31:
  %119 = phi i64 [%111, %$29] ; # X
; # (val 2 $Transient)
  %120 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 8) to i64) to i64*
  %121 = getelementptr i64, i64* %120, i32 1
  %122 = load i64, i64* %121
  br label %$32
$32:
  %123 = phi i64 [%116, %$30], [%119, %$31] ; # X
  %124 = phi i64 [%118, %$30], [%122, %$31] ; # ->
  br label %$7
$28:
  %125 = phi i64 [%107, %$23] ; # X
; # (val $Extern)
  %126 = load i64, i64* @$Extern
  br label %$7
$7:
  %127 = phi i64 [%42, %$12], [%47, %$15], [%58, %$17], [%81, %$22], [%105, %$27], [%123, %$32], [%125, %$28] ; # X
  %128 = phi i64 [%44, %$12], [%54, %$15], [%60, %$17], [%82, %$22], [%106, %$27], [%124, %$32], [%126, %$28] ; # ->
  ret i64 %128
}

define i64 @_Symbols(i64) align 8 {
$1:
; # (let X (cdr Exe) (if (atom X) (val $Intern) (let Y (eval (++ X)) ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (if (atom X) (val $Intern) (let Y (eval (++ X)) (if (pair Y) (let...
; # (atom X)
  %4 = and i64 %3, 15
  %5 = icmp ne i64 %4, 0
  br i1 %5, label %$2, label %$3
$2:
  %6 = phi i64 [%3, %$1] ; # X
; # (val $Intern)
  %7 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 0) to i64) to i64*
  %8 = load i64, i64* %7
  br label %$4
$3:
  %9 = phi i64 [%3, %$1] ; # X
; # (let Y (eval (++ X)) (if (pair Y) (let L Y (loop (needNsp Exe (ne...
; # (++ X)
  %10 = inttoptr i64 %9 to i64*
  %11 = load i64, i64* %10
  %12 = getelementptr i64, i64* %10, i32 1
  %13 = load i64, i64* %12
; # (eval (++ X))
  %14 = and i64 %11, 6
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$7, label %$6
$7:
  br label %$5
$6:
  %16 = and i64 %11, 8
  %17 = icmp ne i64 %16, 0
  br i1 %17, label %$9, label %$8
$9:
  %18 = inttoptr i64 %11 to i64*
  %19 = load i64, i64* %18
  br label %$5
$8:
  %20 = call i64 @evList(i64 %11)
  br label %$5
$5:
  %21 = phi i64 [%11, %$7], [%19, %$9], [%20, %$8] ; # ->
; # (if (pair Y) (let L Y (loop (needNsp Exe (needSymb Exe (++ L))) (...
; # (pair Y)
  %22 = and i64 %21, 15
  %23 = icmp eq i64 %22, 0
  br i1 %23, label %$10, label %$11
$10:
  %24 = phi i64 [%13, %$5] ; # X
  %25 = phi i64 [%21, %$5] ; # Y
; # (let L Y (loop (needNsp Exe (needSymb Exe (++ L))) (? (atom L))) ...
; # (loop (needNsp Exe (needSymb Exe (++ L))) (? (atom L)))
  br label %$13
$13:
  %26 = phi i64 [%24, %$10], [%46, %$20] ; # X
  %27 = phi i64 [%25, %$10], [%47, %$20] ; # Y
  %28 = phi i64 [%25, %$10], [%48, %$20] ; # L
; # (++ L)
  %29 = inttoptr i64 %28 to i64*
  %30 = load i64, i64* %29
  %31 = getelementptr i64, i64* %29, i32 1
  %32 = load i64, i64* %31
; # (needSymb Exe (++ L))
  %33 = xor i64 %30, 8
  %34 = and i64 %33, 14
  %35 = icmp eq i64 %34, 0
  br i1 %35, label %$15, label %$14
$14:
  call void @symErr(i64 %0, i64 %30)
  unreachable
$15:
; # (needNsp Exe (needSymb Exe (++ L)))
  %36 = inttoptr i64 %30 to i64*
  %37 = load i64, i64* %36
  %38 = and i64 %37, 15
  %39 = icmp eq i64 %38, 0
  br i1 %39, label %$17, label %$16
$17:
  %40 = inttoptr i64 %37 to i64*
  %41 = load i64, i64* %40
  %42 = icmp eq i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 40) to i64), %41
  br label %$16
$16:
  %43 = phi i1 [0, %$15], [%42, %$17] ; # ->
  br i1 %43, label %$19, label %$18
$18:
  call void @symNspErr(i64 %0, i64 %30)
  unreachable
$19:
; # (? (atom L))
; # (atom L)
  %44 = and i64 %32, 15
  %45 = icmp ne i64 %44, 0
  br i1 %45, label %$21, label %$20
$20:
  %46 = phi i64 [%26, %$19] ; # X
  %47 = phi i64 [%27, %$19] ; # Y
  %48 = phi i64 [%32, %$19] ; # L
  br label %$13
$21:
  %49 = phi i64 [%26, %$19] ; # X
  %50 = phi i64 [%27, %$19] ; # Y
  %51 = phi i64 [%32, %$19] ; # L
  %52 = phi i64 [0, %$19] ; # ->
; # (if (atom X) (prog1 (val $Intern) (set $Intern Y)) (let Z (save (...
; # (atom X)
  %53 = and i64 %49, 15
  %54 = icmp ne i64 %53, 0
  br i1 %54, label %$22, label %$23
$22:
  %55 = phi i64 [%49, %$21] ; # X
  %56 = phi i64 [%50, %$21] ; # Y
  %57 = phi i64 [%51, %$21] ; # L
; # (prog1 (val $Intern) (set $Intern Y))
; # (val $Intern)
  %58 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 0) to i64) to i64*
  %59 = load i64, i64* %58
; # (set $Intern Y)
  %60 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 0) to i64) to i64*
  store i64 %56, i64* %60
  br label %$24
$23:
  %61 = phi i64 [%49, %$21] ; # X
  %62 = phi i64 [%50, %$21] ; # Y
  %63 = phi i64 [%51, %$21] ; # L
; # (let Z (save (val $Intern)) (set $Intern Y) (prog1 (run X) (set $...
; # (val $Intern)
  %64 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 0) to i64) to i64*
  %65 = load i64, i64* %64
; # (save (val $Intern))
  %66 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %67 = load i64, i64* %66
  %68 = alloca i64, i64 2, align 16
  %69 = ptrtoint i64* %68 to i64
  %70 = inttoptr i64 %69 to i64*
  store i64 %65, i64* %70
  %71 = add i64 %69, 8
  %72 = inttoptr i64 %71 to i64*
  store i64 %67, i64* %72
  %73 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %69, i64* %73
; # (set $Intern Y)
  %74 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 0) to i64) to i64*
  store i64 %62, i64* %74
; # (prog1 (run X) (set $Intern Z))
; # (run X)
  br label %$25
$25:
  %75 = phi i64 [%61, %$23], [%97, %$34] ; # Prg
  %76 = inttoptr i64 %75 to i64*
  %77 = load i64, i64* %76
  %78 = getelementptr i64, i64* %76, i32 1
  %79 = load i64, i64* %78
  %80 = and i64 %79, 15
  %81 = icmp ne i64 %80, 0
  br i1 %81, label %$28, label %$26
$28:
  %82 = phi i64 [%79, %$25] ; # Prg
  %83 = and i64 %77, 6
  %84 = icmp ne i64 %83, 0
  br i1 %84, label %$31, label %$30
$31:
  br label %$29
$30:
  %85 = and i64 %77, 8
  %86 = icmp ne i64 %85, 0
  br i1 %86, label %$33, label %$32
$33:
  %87 = inttoptr i64 %77 to i64*
  %88 = load i64, i64* %87
  br label %$29
$32:
  %89 = call i64 @evList(i64 %77)
  br label %$29
$29:
  %90 = phi i64 [%77, %$31], [%88, %$33], [%89, %$32] ; # ->
  br label %$27
$26:
  %91 = phi i64 [%79, %$25] ; # Prg
  %92 = and i64 %77, 15
  %93 = icmp eq i64 %92, 0
  br i1 %93, label %$35, label %$34
$35:
  %94 = phi i64 [%91, %$26] ; # Prg
  %95 = call i64 @evList(i64 %77)
  %96 = icmp ne i64 %95, 0
  br label %$34
$34:
  %97 = phi i64 [%91, %$26], [%94, %$35] ; # Prg
  %98 = phi i1 [0, %$26], [%96, %$35] ; # ->
  br label %$25
$27:
  %99 = phi i64 [%82, %$29] ; # Prg
  %100 = phi i64 [%90, %$29] ; # ->
; # (set $Intern Z)
  %101 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 0) to i64) to i64*
  store i64 %65, i64* %101
; # (drop *Safe)
  %102 = inttoptr i64 %69 to i64*
  %103 = getelementptr i64, i64* %102, i32 1
  %104 = load i64, i64* %103
  %105 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %104, i64* %105
  br label %$24
$24:
  %106 = phi i64 [%55, %$22], [%61, %$27] ; # X
  %107 = phi i64 [%56, %$22], [%62, %$27] ; # Y
  %108 = phi i64 [%57, %$22], [%63, %$27] ; # L
  %109 = phi i64 [%59, %$22], [%100, %$27] ; # ->
  br label %$12
$11:
  %110 = phi i64 [%13, %$5] ; # X
  %111 = phi i64 [%21, %$5] ; # Y
; # (let F (t? Y) (when F (setq Y (eval (++ X)))) (if (or (nil? (val ...
; # (t? Y)
  %112 = icmp eq i64 %111, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
; # (when F (setq Y (eval (++ X))))
  br i1 %112, label %$36, label %$37
$36:
  %113 = phi i64 [%110, %$11] ; # X
  %114 = phi i64 [%111, %$11] ; # Y
; # (++ X)
  %115 = inttoptr i64 %113 to i64*
  %116 = load i64, i64* %115
  %117 = getelementptr i64, i64* %115, i32 1
  %118 = load i64, i64* %117
; # (eval (++ X))
  %119 = and i64 %116, 6
  %120 = icmp ne i64 %119, 0
  br i1 %120, label %$40, label %$39
$40:
  br label %$38
$39:
  %121 = and i64 %116, 8
  %122 = icmp ne i64 %121, 0
  br i1 %122, label %$42, label %$41
$42:
  %123 = inttoptr i64 %116 to i64*
  %124 = load i64, i64* %123
  br label %$38
$41:
  %125 = call i64 @evList(i64 %116)
  br label %$38
$38:
  %126 = phi i64 [%116, %$40], [%124, %$42], [%125, %$41] ; # ->
  br label %$37
$37:
  %127 = phi i64 [%110, %$11], [%118, %$38] ; # X
  %128 = phi i64 [%111, %$11], [%126, %$38] ; # Y
; # (if (or (nil? (val (needSymb Exe Y))) (== @ Y)) (set (chkVar Exe ...
; # (or (nil? (val (needSymb Exe Y))) (== @ Y))
; # (needSymb Exe Y)
  %129 = xor i64 %128, 8
  %130 = and i64 %129, 14
  %131 = icmp eq i64 %130, 0
  br i1 %131, label %$45, label %$44
$44:
  call void @symErr(i64 %0, i64 %128)
  unreachable
$45:
; # (val (needSymb Exe Y))
  %132 = inttoptr i64 %128 to i64*
  %133 = load i64, i64* %132
; # (nil? (val (needSymb Exe Y)))
  %134 = icmp eq i64 %133, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %134, label %$43, label %$46
$46:
  %135 = phi i64 [%127, %$45] ; # X
  %136 = phi i64 [%128, %$45] ; # Y
; # (== @ Y)
  %137 = icmp eq i64 %133, %136
  br label %$43
$43:
  %138 = phi i64 [%127, %$45], [%135, %$46] ; # X
  %139 = phi i64 [%128, %$45], [%136, %$46] ; # Y
  %140 = phi i1 [1, %$45], [%137, %$46] ; # ->
  br i1 %140, label %$47, label %$48
$47:
  %141 = phi i64 [%138, %$43] ; # X
  %142 = phi i64 [%139, %$43] ; # Y
; # (set (chkVar Exe Y) (cons $Tilde (cons $Nil $Nil)))
; # (chkVar Exe Y)
  %143 = icmp uge i64 %142, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %143, label %$51, label %$50
$51:
  %144 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %142
  br label %$50
$50:
  %145 = phi i1 [0, %$47], [%144, %$51] ; # ->
  br i1 %145, label %$52, label %$53
$52:
  call void @protErr(i64 %0, i64 %142)
  unreachable
$53:
; # (cons $Nil $Nil)
  %146 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (cons $Tilde (cons $Nil $Nil))
  %147 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 40) to i64), i64 %146)
  %148 = inttoptr i64 %142 to i64*
  store i64 %147, i64* %148
  br label %$49
$48:
  %149 = phi i64 [%138, %$43] ; # X
  %150 = phi i64 [%139, %$43] ; # Y
; # (needNsp Exe Y)
  %151 = inttoptr i64 %150 to i64*
  %152 = load i64, i64* %151
  %153 = and i64 %152, 15
  %154 = icmp eq i64 %153, 0
  br i1 %154, label %$55, label %$54
$55:
  %155 = inttoptr i64 %152 to i64*
  %156 = load i64, i64* %155
  %157 = icmp eq i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 40) to i64), %156
  br label %$54
$54:
  %158 = phi i1 [0, %$48], [%157, %$55] ; # ->
  br i1 %158, label %$57, label %$56
$56:
  call void @symNspErr(i64 %0, i64 %150)
  unreachable
$57:
  br label %$49
$49:
  %159 = phi i64 [%141, %$53], [%149, %$57] ; # X
  %160 = phi i64 [%142, %$53], [%150, %$57] ; # Y
  %161 = phi i64 [%147, %$53], [%150, %$57] ; # ->
; # (let R (setq Y (save (cons Y $Nil))) (while (pair X) (setq Y (set...
; # (cons Y $Nil)
  %162 = call i64 @cons(i64 %160, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (save (cons Y $Nil))
  %163 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %164 = load i64, i64* %163
  %165 = alloca i64, i64 2, align 16
  %166 = ptrtoint i64* %165 to i64
  %167 = inttoptr i64 %166 to i64*
  store i64 %162, i64* %167
  %168 = add i64 %166, 8
  %169 = inttoptr i64 %168 to i64*
  store i64 %164, i64* %169
  %170 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %166, i64* %170
; # (while (pair X) (setq Y (set 2 Y (cons (needNsp Exe (needSymb Exe...
  br label %$58
$58:
  %171 = phi i64 [%159, %$49], [%180, %$71] ; # X
  %172 = phi i64 [%162, %$49], [%200, %$71] ; # Y
; # (pair X)
  %173 = and i64 %171, 15
  %174 = icmp eq i64 %173, 0
  br i1 %174, label %$59, label %$60
$59:
  %175 = phi i64 [%171, %$58] ; # X
  %176 = phi i64 [%172, %$58] ; # Y
; # (set 2 Y (cons (needNsp Exe (needSymb Exe (eval (++ X)))) $Nil))
; # (++ X)
  %177 = inttoptr i64 %175 to i64*
  %178 = load i64, i64* %177
  %179 = getelementptr i64, i64* %177, i32 1
  %180 = load i64, i64* %179
; # (eval (++ X))
  %181 = and i64 %178, 6
  %182 = icmp ne i64 %181, 0
  br i1 %182, label %$63, label %$62
$63:
  br label %$61
$62:
  %183 = and i64 %178, 8
  %184 = icmp ne i64 %183, 0
  br i1 %184, label %$65, label %$64
$65:
  %185 = inttoptr i64 %178 to i64*
  %186 = load i64, i64* %185
  br label %$61
$64:
  %187 = call i64 @evList(i64 %178)
  br label %$61
$61:
  %188 = phi i64 [%178, %$63], [%186, %$65], [%187, %$64] ; # ->
; # (needSymb Exe (eval (++ X)))
  %189 = xor i64 %188, 8
  %190 = and i64 %189, 14
  %191 = icmp eq i64 %190, 0
  br i1 %191, label %$67, label %$66
$66:
  call void @symErr(i64 %0, i64 %188)
  unreachable
$67:
; # (needNsp Exe (needSymb Exe (eval (++ X))))
  %192 = inttoptr i64 %188 to i64*
  %193 = load i64, i64* %192
  %194 = and i64 %193, 15
  %195 = icmp eq i64 %194, 0
  br i1 %195, label %$69, label %$68
$69:
  %196 = inttoptr i64 %193 to i64*
  %197 = load i64, i64* %196
  %198 = icmp eq i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 40) to i64), %197
  br label %$68
$68:
  %199 = phi i1 [0, %$67], [%198, %$69] ; # ->
  br i1 %199, label %$71, label %$70
$70:
  call void @symNspErr(i64 %0, i64 %188)
  unreachable
$71:
; # (cons (needNsp Exe (needSymb Exe (eval (++ X)))) $Nil)
  %200 = call i64 @cons(i64 %188, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %201 = inttoptr i64 %176 to i64*
  %202 = getelementptr i64, i64* %201, i32 1
  store i64 %200, i64* %202
  br label %$58
$60:
  %203 = phi i64 [%171, %$58] ; # X
  %204 = phi i64 [%172, %$58] ; # Y
; # (prog1 (val $Intern) (set $Intern R) (when F (set (val $NsLink) R...
; # (val $Intern)
  %205 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 0) to i64) to i64*
  %206 = load i64, i64* %205
; # (set $Intern R)
  %207 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 0) to i64) to i64*
  store i64 %162, i64* %207
; # (when F (set (val $NsLink) R))
  br i1 %112, label %$72, label %$73
$72:
  %208 = phi i64 [%203, %$60] ; # X
  %209 = phi i64 [%204, %$60] ; # Y
; # (set (val $NsLink) R)
; # (val $NsLink)
  %210 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 24) to i64) to i64*
  %211 = load i64, i64* %210
  %212 = inttoptr i64 %211 to i64*
  store i64 %162, i64* %212
  br label %$73
$73:
  %213 = phi i64 [%203, %$60], [%208, %$72] ; # X
  %214 = phi i64 [%204, %$60], [%209, %$72] ; # Y
; # (car R)
  %215 = inttoptr i64 %162 to i64*
  %216 = load i64, i64* %215
; # (putSrc (car R) 0)
  call void @putSrc(i64 %216, i64 0)
; # (drop *Safe)
  %217 = inttoptr i64 %166 to i64*
  %218 = getelementptr i64, i64* %217, i32 1
  %219 = load i64, i64* %218
  %220 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %219, i64* %220
  br label %$12
$12:
  %221 = phi i64 [%106, %$24], [%213, %$73] ; # X
  %222 = phi i64 [%107, %$24], [%214, %$73] ; # Y
  %223 = phi i64 [%109, %$24], [%206, %$73] ; # ->
  br label %$4
$4:
  %224 = phi i64 [%6, %$2], [%221, %$12] ; # X
  %225 = phi i64 [%8, %$2], [%223, %$12] ; # ->
  ret i64 %225
}

define i64 @_Intern(i64) align 8 {
$1:
; # (let (X (cdr Exe) Sym (save (evSym X))) (cond ((sym? (val (tail S...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (evSym X)
  %4 = call i64 @evSym(i64 %3)
; # (save (evSym X))
  %5 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %6 = load i64, i64* %5
  %7 = alloca i64, i64 2, align 16
  %8 = ptrtoint i64* %7 to i64
  %9 = inttoptr i64 %8 to i64*
  store i64 %4, i64* %9
  %10 = add i64 %8, 8
  %11 = inttoptr i64 %10 to i64*
  store i64 %6, i64* %11
  %12 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %8, i64* %12
; # (cond ((sym? (val (tail Sym))) $Nil) ((== (name @) ZERO) $Nil) (T...
; # (tail Sym)
  %13 = add i64 %4, -8
; # (val (tail Sym))
  %14 = inttoptr i64 %13 to i64*
  %15 = load i64, i64* %14
; # (sym? (val (tail Sym)))
  %16 = and i64 %15, 8
  %17 = icmp ne i64 %16, 0
  br i1 %17, label %$4, label %$3
$4:
  br label %$2
$3:
; # (name @)
  br label %$5
$5:
  %18 = phi i64 [%15, %$3], [%24, %$6] ; # Tail
  %19 = and i64 %18, 6
  %20 = icmp ne i64 %19, 0
  br i1 %20, label %$7, label %$6
$6:
  %21 = phi i64 [%18, %$5] ; # Tail
  %22 = inttoptr i64 %21 to i64*
  %23 = getelementptr i64, i64* %22, i32 1
  %24 = load i64, i64* %23
  br label %$5
$7:
  %25 = phi i64 [%18, %$5] ; # Tail
; # (== (name @) ZERO)
  %26 = icmp eq i64 %25, 2
  br i1 %26, label %$9, label %$8
$9:
  br label %$2
$8:
; # (let Nm @ (if (nil? (eval (cadr X))) (let L (val $Intern) (intern...
; # (if (nil? (eval (cadr X))) (let L (val $Intern) (intern Sym 0 Nm ...
; # (cadr X)
  %27 = inttoptr i64 %3 to i64*
  %28 = getelementptr i64, i64* %27, i32 1
  %29 = load i64, i64* %28
  %30 = inttoptr i64 %29 to i64*
  %31 = load i64, i64* %30
; # (eval (cadr X))
  %32 = and i64 %31, 6
  %33 = icmp ne i64 %32, 0
  br i1 %33, label %$12, label %$11
$12:
  br label %$10
$11:
  %34 = and i64 %31, 8
  %35 = icmp ne i64 %34, 0
  br i1 %35, label %$14, label %$13
$14:
  %36 = inttoptr i64 %31 to i64*
  %37 = load i64, i64* %36
  br label %$10
$13:
  %38 = call i64 @evList(i64 %31)
  br label %$10
$10:
  %39 = phi i64 [%31, %$12], [%37, %$14], [%38, %$13] ; # ->
; # (nil? (eval (cadr X)))
  %40 = icmp eq i64 %39, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %40, label %$15, label %$16
$15:
; # (let L (val $Intern) (intern Sym 0 Nm (cdar (car L)) (cdr L) NO))...
; # (val $Intern)
  %41 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 0) to i64) to i64*
  %42 = load i64, i64* %41
; # (car L)
  %43 = inttoptr i64 %42 to i64*
  %44 = load i64, i64* %43
; # (cdar (car L))
  %45 = inttoptr i64 %44 to i64*
  %46 = load i64, i64* %45
  %47 = inttoptr i64 %46 to i64*
  %48 = getelementptr i64, i64* %47, i32 1
  %49 = load i64, i64* %48
; # (cdr L)
  %50 = inttoptr i64 %42 to i64*
  %51 = getelementptr i64, i64* %50, i32 1
  %52 = load i64, i64* %51
; # (intern Sym 0 Nm (cdar (car L)) (cdr L) NO)
  %53 = call i64 @intern(i64 %4, i64 0, i64 %25, i64 %49, i64 %52, i1 0)
  br label %$17
$16:
; # (if (t? @) (cdar (car (val $Intern))) (cdar @))
; # (t? @)
  %54 = icmp eq i64 %39, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %54, label %$18, label %$19
$18:
; # (val $Intern)
  %55 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 0) to i64) to i64*
  %56 = load i64, i64* %55
; # (car (val $Intern))
  %57 = inttoptr i64 %56 to i64*
  %58 = load i64, i64* %57
; # (cdar (car (val $Intern)))
  %59 = inttoptr i64 %58 to i64*
  %60 = load i64, i64* %59
  %61 = inttoptr i64 %60 to i64*
  %62 = getelementptr i64, i64* %61, i32 1
  %63 = load i64, i64* %62
  br label %$20
$19:
; # (cdar @)
  %64 = inttoptr i64 %39 to i64*
  %65 = load i64, i64* %64
  %66 = inttoptr i64 %65 to i64*
  %67 = getelementptr i64, i64* %66, i32 1
  %68 = load i64, i64* %67
  br label %$20
$20:
  %69 = phi i64 [%63, %$18], [%68, %$19] ; # ->
; # (intern Sym 0 Nm (if (t? @) (cdar (car (val $Intern))) (cdar @)) ...
  %70 = call i64 @intern(i64 %4, i64 0, i64 %25, i64 %69, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i1 0)
  br label %$17
$17:
  %71 = phi i64 [%53, %$15], [%70, %$20] ; # ->
  br label %$2
$2:
  %72 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$4], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$9], [%71, %$17] ; # ->
; # (drop *Safe)
  %73 = inttoptr i64 %8 to i64*
  %74 = getelementptr i64, i64* %73, i32 1
  %75 = load i64, i64* %74
  %76 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %75, i64* %76
  ret i64 %72
}

define i64 @_Hide(i64) align 8 {
$1:
; # (set $Transient (set 2 $Transient $Nil))
; # (set 2 $Transient $Nil)
  %1 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 8) to i64) to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %2
  %3 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 8) to i64) to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %3
  ret i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
}

define i64 @_BoxQ(i64) align 8 {
$1:
; # (let X (eval (cadr Exe)) (if (and (symb? X) (not (sym? (val (tail...
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (if (and (symb? X) (not (sym? (val (tail X)))) (== ZERO (name @))...
; # (and (symb? X) (not (sym? (val (tail X)))) (== ZERO (name @)))
; # (symb? X)
  %14 = xor i64 %13, 8
  %15 = and i64 %14, 14
  %16 = icmp eq i64 %15, 0
  br i1 %16, label %$8, label %$7
$8:
; # (tail X)
  %17 = add i64 %13, -8
; # (val (tail X))
  %18 = inttoptr i64 %17 to i64*
  %19 = load i64, i64* %18
; # (sym? (val (tail X)))
  %20 = and i64 %19, 8
  %21 = icmp ne i64 %20, 0
; # (not (sym? (val (tail X))))
  %22 = icmp eq i1 %21, 0
  br i1 %22, label %$9, label %$7
$9:
; # (name @)
  br label %$10
$10:
  %23 = phi i64 [%19, %$9], [%29, %$11] ; # Tail
  %24 = and i64 %23, 6
  %25 = icmp ne i64 %24, 0
  br i1 %25, label %$12, label %$11
$11:
  %26 = phi i64 [%23, %$10] ; # Tail
  %27 = inttoptr i64 %26 to i64*
  %28 = getelementptr i64, i64* %27, i32 1
  %29 = load i64, i64* %28
  br label %$10
$12:
  %30 = phi i64 [%23, %$10] ; # Tail
; # (== ZERO (name @))
  %31 = icmp eq i64 2, %30
  br label %$7
$7:
  %32 = phi i1 [0, %$2], [0, %$8], [%31, %$12] ; # ->
  br i1 %32, label %$13, label %$14
$13:
  br label %$15
$14:
  br label %$15
$15:
  %33 = phi i64 [%13, %$13], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$14] ; # ->
  ret i64 %33
}

define i64 @_StrQ(i64) align 8 {
$1:
; # (let X (eval (cadr Exe)) (cond ((not (symb? X)) $Nil) ((or (sym? ...
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (cond ((not (symb? X)) $Nil) ((or (sym? (val (tail X))) (findSym ...
; # (symb? X)
  %14 = xor i64 %13, 8
  %15 = and i64 %14, 14
  %16 = icmp eq i64 %15, 0
; # (not (symb? X))
  %17 = icmp eq i1 %16, 0
  br i1 %17, label %$9, label %$8
$9:
  br label %$7
$8:
; # (or (sym? (val (tail X))) (findSym X (name @) (val $Intern)))
; # (tail X)
  %18 = add i64 %13, -8
; # (val (tail X))
  %19 = inttoptr i64 %18 to i64*
  %20 = load i64, i64* %19
; # (sym? (val (tail X)))
  %21 = and i64 %20, 8
  %22 = icmp ne i64 %21, 0
  br i1 %22, label %$10, label %$11
$11:
; # (name @)
  br label %$12
$12:
  %23 = phi i64 [%20, %$11], [%29, %$13] ; # Tail
  %24 = and i64 %23, 6
  %25 = icmp ne i64 %24, 0
  br i1 %25, label %$14, label %$13
$13:
  %26 = phi i64 [%23, %$12] ; # Tail
  %27 = inttoptr i64 %26 to i64*
  %28 = getelementptr i64, i64* %27, i32 1
  %29 = load i64, i64* %28
  br label %$12
$14:
  %30 = phi i64 [%23, %$12] ; # Tail
; # (val $Intern)
  %31 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 0) to i64) to i64*
  %32 = load i64, i64* %31
; # (findSym X (name @) (val $Intern))
  %33 = call i1 @findSym(i64 %13, i64 %30, i64 %32)
  br label %$10
$10:
  %34 = phi i1 [1, %$8], [%33, %$14] ; # ->
  br i1 %34, label %$16, label %$15
$16:
  br label %$7
$15:
  br label %$7
$7:
  %35 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$9], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$16], [%13, %$15] ; # ->
  ret i64 %35
}

define i64 @_Zap(i64) align 8 {
$1:
; # (let Sym (needSymb Exe (eval (cadr Exe))) (if (sym? (val (tail Sy...
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (needSymb Exe (eval (cadr Exe)))
  %14 = xor i64 %13, 8
  %15 = and i64 %14, 14
  %16 = icmp eq i64 %15, 0
  br i1 %16, label %$8, label %$7
$7:
  call void @symErr(i64 %0, i64 %13)
  unreachable
$8:
; # (if (sym? (val (tail Sym))) (dbZap Sym) (unintern Sym (name @) (c...
; # (tail Sym)
  %17 = add i64 %13, -8
; # (val (tail Sym))
  %18 = inttoptr i64 %17 to i64*
  %19 = load i64, i64* %18
; # (sym? (val (tail Sym)))
  %20 = and i64 %19, 8
  %21 = icmp ne i64 %20, 0
  br i1 %21, label %$9, label %$10
$9:
; # (dbZap Sym)
  call void @dbZap(i64 %13)
  br label %$11
$10:
; # (name @)
  br label %$12
$12:
  %22 = phi i64 [%19, %$10], [%28, %$13] ; # Tail
  %23 = and i64 %22, 6
  %24 = icmp ne i64 %23, 0
  br i1 %24, label %$14, label %$13
$13:
  %25 = phi i64 [%22, %$12] ; # Tail
  %26 = inttoptr i64 %25 to i64*
  %27 = getelementptr i64, i64* %26, i32 1
  %28 = load i64, i64* %27
  br label %$12
$14:
  %29 = phi i64 [%22, %$12] ; # Tail
; # (val $Intern)
  %30 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 0) to i64) to i64*
  %31 = load i64, i64* %30
; # (car (val $Intern))
  %32 = inttoptr i64 %31 to i64*
  %33 = load i64, i64* %32
; # (cdar (car (val $Intern)))
  %34 = inttoptr i64 %33 to i64*
  %35 = load i64, i64* %34
  %36 = inttoptr i64 %35 to i64*
  %37 = getelementptr i64, i64* %36, i32 1
  %38 = load i64, i64* %37
; # (unintern Sym (name @) (cdar (car (val $Intern))))
  call void @unintern(i64 %13, i64 %29, i64 %38)
  br label %$11
$11:
  ret i64 %13
}

define i64 @_Chop(i64) align 8 {
$1:
; # (let X (eval (cadr Exe)) (if (or (pair X) (nil? X)) X (let Tail (...
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (if (or (pair X) (nil? X)) X (let Tail (val (tail (xSym X))) (if ...
; # (or (pair X) (nil? X))
; # (pair X)
  %14 = and i64 %13, 15
  %15 = icmp eq i64 %14, 0
  br i1 %15, label %$7, label %$8
$8:
; # (nil? X)
  %16 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$7
$7:
  %17 = phi i1 [1, %$2], [%16, %$8] ; # ->
  br i1 %17, label %$9, label %$10
$9:
  br label %$11
$10:
; # (let Tail (val (tail (xSym X))) (if (sym? Tail) (chopExtNm (name ...
; # (xSym X)
  %18 = call i64 @xSym(i64 %13)
; # (tail (xSym X))
  %19 = add i64 %18, -8
; # (val (tail (xSym X)))
  %20 = inttoptr i64 %19 to i64*
  %21 = load i64, i64* %20
; # (if (sym? Tail) (chopExtNm (name (& Tail -9))) (let (P (push 0 (n...
; # (sym? Tail)
  %22 = and i64 %21, 8
  %23 = icmp ne i64 %22, 0
  br i1 %23, label %$12, label %$13
$12:
; # (& Tail -9)
  %24 = and i64 %21, -9
; # (name (& Tail -9))
  br label %$15
$15:
  %25 = phi i64 [%24, %$12], [%31, %$16] ; # Tail
  %26 = and i64 %25, 6
  %27 = icmp ne i64 %26, 0
  br i1 %27, label %$17, label %$16
$16:
  %28 = phi i64 [%25, %$15] ; # Tail
  %29 = inttoptr i64 %28 to i64*
  %30 = getelementptr i64, i64* %29, i32 1
  %31 = load i64, i64* %30
  br label %$15
$17:
  %32 = phi i64 [%25, %$15] ; # Tail
; # (chopExtNm (name (& Tail -9)))
  %33 = call i64 @chopExtNm(i64 %32)
  br label %$14
$13:
; # (let (P (push 0 (name Tail)) C (symChar P)) (if C (save Tail (let...
; # (name Tail)
  br label %$18
$18:
  %34 = phi i64 [%21, %$13], [%40, %$19] ; # Tail
  %35 = and i64 %34, 6
  %36 = icmp ne i64 %35, 0
  br i1 %36, label %$20, label %$19
$19:
  %37 = phi i64 [%34, %$18] ; # Tail
  %38 = inttoptr i64 %37 to i64*
  %39 = getelementptr i64, i64* %38, i32 1
  %40 = load i64, i64* %39
  br label %$18
$20:
  %41 = phi i64 [%34, %$18] ; # Tail
; # (push 0 (name Tail))
  %42 = alloca i64, i64 2, align 16
  store i64 0, i64* %42
  %43 = getelementptr i64, i64* %42, i32 1
  store i64 %41, i64* %43
; # (symChar P)
  %44 = call i32 @symChar(i64* %42)
; # (if C (save Tail (let (Y (cons (mkChar C) $Nil) R (save Y)) (whil...
  %45 = icmp ne i32 %44, 0
  br i1 %45, label %$21, label %$22
$21:
  %46 = phi i32 [%44, %$20] ; # C
; # (save Tail (let (Y (cons (mkChar C) $Nil) R (save Y)) (while (set...
  %47 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %48 = load i64, i64* %47
  %49 = alloca i64, i64 2, align 16
  %50 = ptrtoint i64* %49 to i64
  %51 = inttoptr i64 %50 to i64*
  store i64 %21, i64* %51
  %52 = add i64 %50, 8
  %53 = inttoptr i64 %52 to i64*
  store i64 %48, i64* %53
  %54 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %50, i64* %54
; # (let (Y (cons (mkChar C) $Nil) R (save Y)) (while (setq C (symCha...
; # (mkChar C)
  %55 = call i64 @mkChar(i32 %46)
; # (cons (mkChar C) $Nil)
  %56 = call i64 @cons(i64 %55, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (save Y)
  %57 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %58 = load i64, i64* %57
  %59 = alloca i64, i64 2, align 16
  %60 = ptrtoint i64* %59 to i64
  %61 = inttoptr i64 %60 to i64*
  store i64 %56, i64* %61
  %62 = add i64 %60, 8
  %63 = inttoptr i64 %62 to i64*
  store i64 %58, i64* %63
  %64 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %60, i64* %64
; # (while (setq C (symChar P)) (setq Y (set 2 Y (cons (mkChar C) $Ni...
  br label %$24
$24:
  %65 = phi i32 [%46, %$21], [%69, %$25] ; # C
  %66 = phi i64 [%56, %$21], [%72, %$25] ; # Y
; # (symChar P)
  %67 = call i32 @symChar(i64* %42)
  %68 = icmp ne i32 %67, 0
  br i1 %68, label %$25, label %$26
$25:
  %69 = phi i32 [%67, %$24] ; # C
  %70 = phi i64 [%66, %$24] ; # Y
; # (set 2 Y (cons (mkChar C) $Nil))
; # (mkChar C)
  %71 = call i64 @mkChar(i32 %69)
; # (cons (mkChar C) $Nil)
  %72 = call i64 @cons(i64 %71, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %73 = inttoptr i64 %70 to i64*
  %74 = getelementptr i64, i64* %73, i32 1
  store i64 %72, i64* %74
  br label %$24
$26:
  %75 = phi i32 [%67, %$24] ; # C
  %76 = phi i64 [%66, %$24] ; # Y
; # drop
  %77 = inttoptr i64 %50 to i64*
  %78 = getelementptr i64, i64* %77, i32 1
  %79 = load i64, i64* %78
  %80 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %79, i64* %80
  br label %$23
$22:
  %81 = phi i32 [%44, %$20] ; # C
  br label %$23
$23:
  %82 = phi i32 [%75, %$26], [%81, %$22] ; # C
  %83 = phi i64 [%56, %$26], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$22] ; # ->
  br label %$14
$14:
  %84 = phi i64 [%33, %$17], [%83, %$23] ; # ->
  br label %$11
$11:
  %85 = phi i64 [%13, %$9], [%84, %$14] ; # ->
  ret i64 %85
}

define i64 @_Pack(i64) align 8 {
$1:
; # (save -ZERO (let (X (cdr Exe) P (push 4 NIL ZERO NIL)) (link (ofs...
  %1 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %2 = load i64, i64* %1
  %3 = alloca i64, i64 2, align 16
  %4 = ptrtoint i64* %3 to i64
  %5 = inttoptr i64 %4 to i64*
  store i64 10, i64* %5
  %6 = add i64 %4, 8
  %7 = inttoptr i64 %6 to i64*
  store i64 %2, i64* %7
  %8 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %4, i64* %8
; # (let (X (cdr Exe) P (push 4 NIL ZERO NIL)) (link (ofs P 2)) (whil...
; # (cdr Exe)
  %9 = inttoptr i64 %0 to i64*
  %10 = getelementptr i64, i64* %9, i32 1
  %11 = load i64, i64* %10
; # (push 4 NIL ZERO NIL)
  %12 = alloca i64, i64 4, align 16
  store i64 4, i64* %12
  %13 = getelementptr i64, i64* %12, i32 2
  store i64 2, i64* %13
; # (ofs P 2)
  %14 = getelementptr i64, i64* %12, i32 2
; # (link (ofs P 2))
  %15 = ptrtoint i64* %14 to i64
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %17 = load i64, i64* %16
  %18 = inttoptr i64 %15 to i64*
  %19 = getelementptr i64, i64* %18, i32 1
  store i64 %17, i64* %19
  %20 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %15, i64* %20
; # (while (pair X) (pack (safe (eval (++ X))) P))
  br label %$2
$2:
  %21 = phi i64 [%11, %$1], [%28, %$5] ; # X
; # (pair X)
  %22 = and i64 %21, 15
  %23 = icmp eq i64 %22, 0
  br i1 %23, label %$3, label %$4
$3:
  %24 = phi i64 [%21, %$2] ; # X
; # (++ X)
  %25 = inttoptr i64 %24 to i64*
  %26 = load i64, i64* %25
  %27 = getelementptr i64, i64* %25, i32 1
  %28 = load i64, i64* %27
; # (eval (++ X))
  %29 = and i64 %26, 6
  %30 = icmp ne i64 %29, 0
  br i1 %30, label %$7, label %$6
$7:
  br label %$5
$6:
  %31 = and i64 %26, 8
  %32 = icmp ne i64 %31, 0
  br i1 %32, label %$9, label %$8
$9:
  %33 = inttoptr i64 %26 to i64*
  %34 = load i64, i64* %33
  br label %$5
$8:
  %35 = call i64 @evList(i64 %26)
  br label %$5
$5:
  %36 = phi i64 [%26, %$7], [%34, %$9], [%35, %$8] ; # ->
; # (safe (eval (++ X)))
  %37 = inttoptr i64 %4 to i64*
  store i64 %36, i64* %37
; # (pack (safe (eval (++ X))) P)
  call void @pack(i64 %36, i64* %12)
  br label %$2
$4:
  %38 = phi i64 [%21, %$2] ; # X
; # (val 3 P)
  %39 = getelementptr i64, i64* %12, i32 2
  %40 = load i64, i64* %39
; # (consStr (val 3 P))
  %41 = call i64 @consStr(i64 %40)
; # drop
  %42 = inttoptr i64 %4 to i64*
  %43 = getelementptr i64, i64* %42, i32 1
  %44 = load i64, i64* %43
  %45 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %44, i64* %45
  ret i64 %41
}

define i64 @_Glue(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (save (eval (++ X)))) (if (atom (eval (++ X))...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (save (eval (++ X)))
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %17 = load i64, i64* %16
  %18 = alloca i64, i64 2, align 16
  %19 = ptrtoint i64* %18 to i64
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = add i64 %19, 8
  %22 = inttoptr i64 %21 to i64*
  store i64 %17, i64* %22
  %23 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %19, i64* %23
; # (if (atom (eval (++ X))) @ (let (Z (save @) P (push 4 NIL ZERO NI...
; # (++ X)
  %24 = inttoptr i64 %7 to i64*
  %25 = load i64, i64* %24
  %26 = getelementptr i64, i64* %24, i32 1
  %27 = load i64, i64* %26
; # (eval (++ X))
  %28 = and i64 %25, 6
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %$9, label %$8
$9:
  br label %$7
$8:
  %30 = and i64 %25, 8
  %31 = icmp ne i64 %30, 0
  br i1 %31, label %$11, label %$10
$11:
  %32 = inttoptr i64 %25 to i64*
  %33 = load i64, i64* %32
  br label %$7
$10:
  %34 = call i64 @evList(i64 %25)
  br label %$7
$7:
  %35 = phi i64 [%25, %$9], [%33, %$11], [%34, %$10] ; # ->
; # (atom (eval (++ X)))
  %36 = and i64 %35, 15
  %37 = icmp ne i64 %36, 0
  br i1 %37, label %$12, label %$13
$12:
  %38 = phi i64 [%27, %$7] ; # X
  br label %$14
$13:
  %39 = phi i64 [%27, %$7] ; # X
; # (let (Z (save @) P (push 4 NIL ZERO NIL)) (link (ofs P 2)) (loop ...
; # (save @)
  %40 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %41 = load i64, i64* %40
  %42 = alloca i64, i64 2, align 16
  %43 = ptrtoint i64* %42 to i64
  %44 = inttoptr i64 %43 to i64*
  store i64 %35, i64* %44
  %45 = add i64 %43, 8
  %46 = inttoptr i64 %45 to i64*
  store i64 %41, i64* %46
  %47 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %43, i64* %47
; # (push 4 NIL ZERO NIL)
  %48 = alloca i64, i64 4, align 16
  store i64 4, i64* %48
  %49 = getelementptr i64, i64* %48, i32 2
  store i64 2, i64* %49
; # (ofs P 2)
  %50 = getelementptr i64, i64* %48, i32 2
; # (link (ofs P 2))
  %51 = ptrtoint i64* %50 to i64
  %52 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %53 = load i64, i64* %52
  %54 = inttoptr i64 %51 to i64*
  %55 = getelementptr i64, i64* %54, i32 1
  store i64 %53, i64* %55
  %56 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %51, i64* %56
; # (loop (pack (++ Z) P) (? (atom Z)) (pack Y P))
  br label %$15
$15:
  %57 = phi i64 [%39, %$13], [%65, %$16] ; # X
  %58 = phi i64 [%35, %$13], [%66, %$16] ; # Z
; # (++ Z)
  %59 = inttoptr i64 %58 to i64*
  %60 = load i64, i64* %59
  %61 = getelementptr i64, i64* %59, i32 1
  %62 = load i64, i64* %61
; # (pack (++ Z) P)
  call void @pack(i64 %60, i64* %48)
; # (? (atom Z))
; # (atom Z)
  %63 = and i64 %62, 15
  %64 = icmp ne i64 %63, 0
  br i1 %64, label %$17, label %$16
$16:
  %65 = phi i64 [%57, %$15] ; # X
  %66 = phi i64 [%62, %$15] ; # Z
; # (pack Y P)
  call void @pack(i64 %15, i64* %48)
  br label %$15
$17:
  %67 = phi i64 [%57, %$15] ; # X
  %68 = phi i64 [%62, %$15] ; # Z
  %69 = phi i64 [0, %$15] ; # ->
; # (val 3 P)
  %70 = getelementptr i64, i64* %48, i32 2
  %71 = load i64, i64* %70
; # (consStr (val 3 P))
  %72 = call i64 @consStr(i64 %71)
  br label %$14
$14:
  %73 = phi i64 [%38, %$12], [%67, %$17] ; # X
  %74 = phi i64 [%35, %$12], [%72, %$17] ; # ->
; # (drop *Safe)
  %75 = inttoptr i64 %19 to i64*
  %76 = getelementptr i64, i64* %75, i32 1
  %77 = load i64, i64* %76
  %78 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %77, i64* %78
  ret i64 %74
}

define i64 @_Text(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (evSym X)) (if (nil? Y) Y (let (P (push 0 (xN...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (evSym X)
  %4 = call i64 @evSym(i64 %3)
; # (if (nil? Y) Y (let (P (push 0 (xName Y) NIL) Q (link (ofs P 1) T...
; # (nil? Y)
  %5 = icmp eq i64 %4, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %5, label %$2, label %$3
$2:
  %6 = phi i64 [%3, %$1] ; # X
  br label %$4
$3:
  %7 = phi i64 [%3, %$1] ; # X
; # (let (P (push 0 (xName Y) NIL) Q (link (ofs P 1) T) R (push 4 NIL...
; # (xName Y)
  %8 = call i64 @xName(i64 %4)
; # (push 0 (xName Y) NIL)
  %9 = alloca i64, i64 3, align 16
  store i64 0, i64* %9
  %10 = getelementptr i64, i64* %9, i32 1
  store i64 %8, i64* %10
; # (ofs P 1)
  %11 = getelementptr i64, i64* %9, i32 1
; # (link (ofs P 1) T)
  %12 = ptrtoint i64* %11 to i64
  %13 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %14 = load i64, i64* %13
  %15 = inttoptr i64 %12 to i64*
  %16 = getelementptr i64, i64* %15, i32 1
  store i64 %14, i64* %16
  %17 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %12, i64* %17
; # (push 4 NIL ZERO NIL)
  %18 = alloca i64, i64 4, align 16
  store i64 4, i64* %18
  %19 = getelementptr i64, i64* %18, i32 2
  store i64 2, i64* %19
; # (ofs R 2)
  %20 = getelementptr i64, i64* %18, i32 2
; # (link (ofs R 2))
  %21 = ptrtoint i64* %20 to i64
  %22 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %23 = load i64, i64* %22
  %24 = inttoptr i64 %21 to i64*
  %25 = getelementptr i64, i64* %24, i32 1
  store i64 %23, i64* %25
  %26 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %21, i64* %26
; # (while (pair (shift X)) (setq A (link (push (eval (car X)) NIL)))...
  br label %$5
$5:
  %27 = phi i64 [%7, %$3], [%35, %$8] ; # X
  %28 = phi i64 [%21, %$3], [%49, %$8] ; # A
  %29 = phi i64 [0, %$3], [%56, %$8] ; # N
; # (shift X)
  %30 = inttoptr i64 %27 to i64*
  %31 = getelementptr i64, i64* %30, i32 1
  %32 = load i64, i64* %31
; # (pair (shift X))
  %33 = and i64 %32, 15
  %34 = icmp eq i64 %33, 0
  br i1 %34, label %$6, label %$7
$6:
  %35 = phi i64 [%32, %$5] ; # X
  %36 = phi i64 [%28, %$5] ; # A
  %37 = phi i64 [%29, %$5] ; # N
; # (car X)
  %38 = inttoptr i64 %35 to i64*
  %39 = load i64, i64* %38
; # (eval (car X))
  %40 = and i64 %39, 6
  %41 = icmp ne i64 %40, 0
  br i1 %41, label %$10, label %$9
$10:
  br label %$8
$9:
  %42 = and i64 %39, 8
  %43 = icmp ne i64 %42, 0
  br i1 %43, label %$12, label %$11
$12:
  %44 = inttoptr i64 %39 to i64*
  %45 = load i64, i64* %44
  br label %$8
$11:
  %46 = call i64 @evList(i64 %39)
  br label %$8
$8:
  %47 = phi i64 [%39, %$10], [%45, %$12], [%46, %$11] ; # ->
; # (push (eval (car X)) NIL)
  %48 = alloca i64, i64 2, align 16
  %49 = ptrtoint i64* %48 to i64
  %50 = inttoptr i64 %49 to i64*
  store i64 %47, i64* %50
; # (link (push (eval (car X)) NIL))
  %51 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %52 = load i64, i64* %51
  %53 = inttoptr i64 %49 to i64*
  %54 = getelementptr i64, i64* %53, i32 1
  store i64 %52, i64* %54
  %55 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %49, i64* %55
; # (inc 'N)
  %56 = add i64 %37, 1
  br label %$5
$7:
  %57 = phi i64 [%32, %$5] ; # X
  %58 = phi i64 [%28, %$5] ; # A
  %59 = phi i64 [%29, %$5] ; # N
; # (while (setq C (symByte P)) (cond ((<> C (char "@")) (byteSym C R...
  br label %$13
$13:
  %60 = phi i64 [%57, %$7], [%141, %$16] ; # X
  %61 = phi i64 [%58, %$7], [%142, %$16] ; # A
  %62 = phi i64 [%59, %$7], [%143, %$16] ; # N
; # (symByte P)
  %63 = call i8 @symByte(i64* %9)
  %64 = icmp ne i8 %63, 0
  br i1 %64, label %$14, label %$15
$14:
  %65 = phi i64 [%60, %$13] ; # X
  %66 = phi i64 [%61, %$13] ; # A
  %67 = phi i64 [%62, %$13] ; # N
  %68 = phi i8 [%63, %$13] ; # C
; # (cond ((<> C (char "@")) (byteSym C R)) ((== (setq C (symByte P))...
; # (<> C (char "@"))
  %69 = icmp ne i8 %68, 64
  br i1 %69, label %$18, label %$17
$18:
  %70 = phi i64 [%65, %$14] ; # X
  %71 = phi i64 [%66, %$14] ; # A
  %72 = phi i64 [%67, %$14] ; # N
  %73 = phi i8 [%68, %$14] ; # C
; # (byteSym C R)
  call void @byteSym(i8 %73, i64* %18)
  br label %$16
$17:
  %74 = phi i64 [%65, %$14] ; # X
  %75 = phi i64 [%66, %$14] ; # A
  %76 = phi i64 [%67, %$14] ; # N
  %77 = phi i8 [%68, %$14] ; # C
; # (symByte P)
  %78 = call i8 @symByte(i64* %9)
; # (== (setq C (symByte P)) (char "@"))
  %79 = icmp eq i8 %78, 64
  br i1 %79, label %$20, label %$19
$20:
  %80 = phi i64 [%74, %$17] ; # X
  %81 = phi i64 [%75, %$17] ; # A
  %82 = phi i64 [%76, %$17] ; # N
  %83 = phi i8 [%78, %$17] ; # C
; # (byteSym C R)
  call void @byteSym(i8 %83, i64* %18)
  br label %$16
$19:
  %84 = phi i64 [%74, %$17] ; # X
  %85 = phi i64 [%75, %$17] ; # A
  %86 = phi i64 [%76, %$17] ; # N
  %87 = phi i8 [%78, %$17] ; # C
; # (dec 'C (char "0"))
  %88 = sub i8 %87, 48
; # (gt0 (dec 'C (char "0")))
  %89 = icmp sgt i8 %88, 0
  br i1 %89, label %$22, label %$21
$22:
  %90 = phi i64 [%84, %$19] ; # X
  %91 = phi i64 [%85, %$19] ; # A
  %92 = phi i64 [%86, %$19] ; # N
  %93 = phi i8 [%88, %$19] ; # C
; # (when (> C 9) (dec 'C 7))
; # (> C 9)
  %94 = icmp ugt i8 %93, 9
  br i1 %94, label %$23, label %$24
$23:
  %95 = phi i64 [%90, %$22] ; # X
  %96 = phi i64 [%91, %$22] ; # A
  %97 = phi i64 [%92, %$22] ; # N
  %98 = phi i8 [%93, %$22] ; # C
; # (dec 'C 7)
  %99 = sub i8 %98, 7
  br label %$24
$24:
  %100 = phi i64 [%90, %$22], [%95, %$23] ; # X
  %101 = phi i64 [%91, %$22], [%96, %$23] ; # A
  %102 = phi i64 [%92, %$22], [%97, %$23] ; # N
  %103 = phi i8 [%93, %$22], [%99, %$23] ; # C
; # (when (ge0 (setq C (- N (i64 C)))) (let I A (while (ge0 (dec 'C))...
; # (i64 C)
  %104 = zext i8 %103 to i64
; # (- N (i64 C))
  %105 = sub i64 %102, %104
; # (ge0 (setq C (- N (i64 C))))
  %106 = icmp sge i64 %105, 0
  br i1 %106, label %$25, label %$26
$25:
  %107 = phi i64 [%100, %$24] ; # X
  %108 = phi i64 [%101, %$24] ; # A
  %109 = phi i64 [%102, %$24] ; # N
  %110 = phi i64 [%105, %$24] ; # C
; # (let I A (while (ge0 (dec 'C)) (shift I)) (pack (val I) R))
; # (while (ge0 (dec 'C)) (shift I))
  br label %$27
$27:
  %111 = phi i64 [%107, %$25], [%118, %$28] ; # X
  %112 = phi i64 [%108, %$25], [%119, %$28] ; # A
  %113 = phi i64 [%109, %$25], [%120, %$28] ; # N
  %114 = phi i64 [%110, %$25], [%121, %$28] ; # C
  %115 = phi i64 [%108, %$25], [%125, %$28] ; # I
; # (dec 'C)
  %116 = sub i64 %114, 1
; # (ge0 (dec 'C))
  %117 = icmp sge i64 %116, 0
  br i1 %117, label %$28, label %$29
$28:
  %118 = phi i64 [%111, %$27] ; # X
  %119 = phi i64 [%112, %$27] ; # A
  %120 = phi i64 [%113, %$27] ; # N
  %121 = phi i64 [%116, %$27] ; # C
  %122 = phi i64 [%115, %$27] ; # I
; # (shift I)
  %123 = inttoptr i64 %122 to i64*
  %124 = getelementptr i64, i64* %123, i32 1
  %125 = load i64, i64* %124
  br label %$27
$29:
  %126 = phi i64 [%111, %$27] ; # X
  %127 = phi i64 [%112, %$27] ; # A
  %128 = phi i64 [%113, %$27] ; # N
  %129 = phi i64 [%116, %$27] ; # C
  %130 = phi i64 [%115, %$27] ; # I
; # (val I)
  %131 = inttoptr i64 %130 to i64*
  %132 = load i64, i64* %131
; # (pack (val I) R)
  call void @pack(i64 %132, i64* %18)
  br label %$26
$26:
  %133 = phi i64 [%100, %$24], [%126, %$29] ; # X
  %134 = phi i64 [%101, %$24], [%127, %$29] ; # A
  %135 = phi i64 [%102, %$24], [%128, %$29] ; # N
  %136 = phi i64 [%105, %$24], [%129, %$29] ; # C
  br label %$16
$21:
  %137 = phi i64 [%84, %$19] ; # X
  %138 = phi i64 [%85, %$19] ; # A
  %139 = phi i64 [%86, %$19] ; # N
  %140 = phi i8 [%88, %$19] ; # C
  br label %$16
$16:
  %141 = phi i64 [%70, %$18], [%80, %$20], [%133, %$26], [%137, %$21] ; # X
  %142 = phi i64 [%71, %$18], [%81, %$20], [%134, %$26], [%138, %$21] ; # A
  %143 = phi i64 [%72, %$18], [%82, %$20], [%135, %$26], [%139, %$21] ; # N
  br label %$13
$15:
  %144 = phi i64 [%60, %$13] ; # X
  %145 = phi i64 [%61, %$13] ; # A
  %146 = phi i64 [%62, %$13] ; # N
  %147 = phi i8 [%63, %$13] ; # C
; # (val 3 R)
  %148 = getelementptr i64, i64* %18, i32 2
  %149 = load i64, i64* %148
; # (consStr (val 3 R))
  %150 = call i64 @consStr(i64 %149)
; # (drop *Safe)
  %151 = inttoptr i64 %12 to i64*
  %152 = getelementptr i64, i64* %151, i32 1
  %153 = load i64, i64* %152
  %154 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %153, i64* %154
  br label %$4
$4:
  %155 = phi i64 [%6, %$2], [%144, %$15] ; # X
  %156 = phi i64 [%4, %$2], [%150, %$15] ; # ->
  ret i64 %156
}

define i1 @preStr(i64, i8, i64*) align 8 {
$1:
; # (let (Q (push 0 (i64 Nm)) C (symByte Q)) (loop (? (<> B C) NO) (?...
; # (i64 Nm)
; # (push 0 (i64 Nm))
  %3 = alloca i64, i64 2, align 16
  store i64 0, i64* %3
  %4 = getelementptr i64, i64* %3, i32 1
  store i64 %0, i64* %4
; # (symByte Q)
  %5 = call i8 @symByte(i64* %3)
; # (loop (? (<> B C) NO) (? (=0 (setq C (symByte Q))) YES) (? (=0 (s...
  br label %$2
$2:
  %6 = phi i8 [%1, %$1], [%23, %$8] ; # B
  %7 = phi i8 [%5, %$1], [%24, %$8] ; # C
; # (? (<> B C) NO)
; # (<> B C)
  %8 = icmp ne i8 %6, %7
  br i1 %8, label %$5, label %$3
$5:
  %9 = phi i8 [%6, %$2] ; # B
  %10 = phi i8 [%7, %$2] ; # C
  br label %$4
$3:
  %11 = phi i8 [%6, %$2] ; # B
  %12 = phi i8 [%7, %$2] ; # C
; # (? (=0 (setq C (symByte Q))) YES)
; # (symByte Q)
  %13 = call i8 @symByte(i64* %3)
; # (=0 (setq C (symByte Q)))
  %14 = icmp eq i8 %13, 0
  br i1 %14, label %$7, label %$6
$7:
  %15 = phi i8 [%11, %$3] ; # B
  %16 = phi i8 [%13, %$3] ; # C
  br label %$4
$6:
  %17 = phi i8 [%11, %$3] ; # B
  %18 = phi i8 [%13, %$3] ; # C
; # (? (=0 (setq B (symByte P))) NO)
; # (symByte P)
  %19 = call i8 @symByte(i64* %2)
; # (=0 (setq B (symByte P)))
  %20 = icmp eq i8 %19, 0
  br i1 %20, label %$9, label %$8
$9:
  %21 = phi i8 [%19, %$6] ; # B
  %22 = phi i8 [%18, %$6] ; # C
  br label %$4
$8:
  %23 = phi i8 [%19, %$6] ; # B
  %24 = phi i8 [%18, %$6] ; # C
  br label %$2
$4:
  %25 = phi i8 [%9, %$5], [%15, %$7], [%21, %$9] ; # B
  %26 = phi i8 [%10, %$5], [%16, %$7], [%22, %$9] ; # C
  %27 = phi i1 [0, %$5], [1, %$7], [0, %$9] ; # ->
  ret i1 %27
}

define i1 @subStr(i64, i64) align 8 {
$1:
; # (or (nil? X) (== ZERO (setq X (xName X))) (let (P (push 0 (xName ...
; # (nil? X)
  %2 = icmp eq i64 %0, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %2, label %$2, label %$3
$3:
  %3 = phi i64 [%0, %$1] ; # X
; # (xName X)
  %4 = call i64 @xName(i64 %3)
; # (== ZERO (setq X (xName X)))
  %5 = icmp eq i64 2, %4
  br i1 %5, label %$2, label %$4
$4:
  %6 = phi i64 [%4, %$3] ; # X
; # (let (P (push 0 (xName Y)) B T) (loop (? (=0 (setq B (symByte P))...
; # (xName Y)
  %7 = call i64 @xName(i64 %1)
; # (push 0 (xName Y))
  %8 = alloca i64, i64 2, align 16
  store i64 0, i64* %8
  %9 = getelementptr i64, i64* %8, i32 1
  store i64 %7, i64* %9
; # (loop (? (=0 (setq B (symByte P))) NO) (let (Cnt (val P) Nm (val ...
  br label %$5
$5:
  %10 = phi i64 [%6, %$4], [%23, %$9] ; # X
; # (? (=0 (setq B (symByte P))) NO)
; # (symByte P)
  %11 = call i8 @symByte(i64* %8)
; # (=0 (setq B (symByte P)))
  %12 = icmp eq i8 %11, 0
  br i1 %12, label %$8, label %$6
$8:
  %13 = phi i64 [%10, %$5] ; # X
  %14 = phi i8 [%11, %$5] ; # B
  br label %$7
$6:
  %15 = phi i64 [%10, %$5] ; # X
  %16 = phi i8 [%11, %$5] ; # B
; # (let (Cnt (val P) Nm (val 2 P)) (? (preStr X B P) YES) (set P Cnt...
; # (val P)
  %17 = load i64, i64* %8
; # (val 2 P)
  %18 = getelementptr i64, i64* %8, i32 1
  %19 = load i64, i64* %18
; # (? (preStr X B P) YES)
; # (preStr X B P)
  %20 = call i1 @preStr(i64 %15, i8 %16, i64* %8)
  br i1 %20, label %$10, label %$9
$10:
  %21 = phi i64 [%15, %$6] ; # X
  %22 = phi i8 [%16, %$6] ; # B
  br label %$7
$9:
  %23 = phi i64 [%15, %$6] ; # X
  %24 = phi i8 [%16, %$6] ; # B
; # (set P Cnt 2 P Nm)
  store i64 %17, i64* %8
  %25 = getelementptr i64, i64* %8, i32 1
  store i64 %19, i64* %25
  br label %$5
$7:
  %26 = phi i64 [%13, %$8], [%21, %$10] ; # X
  %27 = phi i8 [%14, %$8], [%22, %$10] ; # B
  %28 = phi i1 [0, %$8], [1, %$10] ; # ->
  br label %$2
$2:
  %29 = phi i64 [%0, %$1], [%4, %$3], [%26, %$7] ; # X
  %30 = phi i1 [1, %$1], [1, %$3], [%28, %$7] ; # ->
  ret i1 %30
}

define i64 @_PreQ(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (save (evSym X)) Z (evSym (shift X))) (cond (...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (evSym X)
  %4 = call i64 @evSym(i64 %3)
; # (save (evSym X))
  %5 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %6 = load i64, i64* %5
  %7 = alloca i64, i64 2, align 16
  %8 = ptrtoint i64* %7 to i64
  %9 = inttoptr i64 %8 to i64*
  store i64 %4, i64* %9
  %10 = add i64 %8, 8
  %11 = inttoptr i64 %10 to i64*
  store i64 %6, i64* %11
  %12 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %8, i64* %12
; # (shift X)
  %13 = inttoptr i64 %3 to i64*
  %14 = getelementptr i64, i64* %13, i32 1
  %15 = load i64, i64* %14
; # (evSym (shift X))
  %16 = call i64 @evSym(i64 %15)
; # (cond ((nil? Y) Z) ((== ZERO (setq Y (xName Y))) Z) (T (let P (pu...
; # (nil? Y)
  %17 = icmp eq i64 %4, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %17, label %$4, label %$3
$4:
  %18 = phi i64 [%4, %$1] ; # Y
  br label %$2
$3:
  %19 = phi i64 [%4, %$1] ; # Y
; # (xName Y)
  %20 = call i64 @xName(i64 %19)
; # (== ZERO (setq Y (xName Y)))
  %21 = icmp eq i64 2, %20
  br i1 %21, label %$6, label %$5
$6:
  %22 = phi i64 [%20, %$3] ; # Y
  br label %$2
$5:
  %23 = phi i64 [%20, %$3] ; # Y
; # (let P (push 0 (xName Z)) (cond ((=0 (symByte P)) $Nil) ((preStr ...
; # (xName Z)
  %24 = call i64 @xName(i64 %16)
; # (push 0 (xName Z))
  %25 = alloca i64, i64 2, align 16
  store i64 0, i64* %25
  %26 = getelementptr i64, i64* %25, i32 1
  store i64 %24, i64* %26
; # (cond ((=0 (symByte P)) $Nil) ((preStr Y @ P) Z) (T $Nil))
; # (symByte P)
  %27 = call i8 @symByte(i64* %25)
; # (=0 (symByte P))
  %28 = icmp eq i8 %27, 0
  br i1 %28, label %$9, label %$8
$9:
  %29 = phi i64 [%23, %$5] ; # Y
  br label %$7
$8:
  %30 = phi i64 [%23, %$5] ; # Y
; # (preStr Y @ P)
  %31 = call i1 @preStr(i64 %30, i8 %27, i64* %25)
  br i1 %31, label %$11, label %$10
$11:
  %32 = phi i64 [%30, %$8] ; # Y
  br label %$7
$10:
  %33 = phi i64 [%30, %$8] ; # Y
  br label %$7
$7:
  %34 = phi i64 [%29, %$9], [%32, %$11], [%33, %$10] ; # Y
  %35 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$9], [%16, %$11], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$10] ; # ->
  br label %$2
$2:
  %36 = phi i64 [%18, %$4], [%22, %$6], [%34, %$7] ; # Y
  %37 = phi i64 [%16, %$4], [%16, %$6], [%35, %$7] ; # ->
; # (drop *Safe)
  %38 = inttoptr i64 %8 to i64*
  %39 = getelementptr i64, i64* %38, i32 1
  %40 = load i64, i64* %39
  %41 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %40, i64* %41
  ret i64 %37
}

define i64 @_SubQ(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (save (evSym X)) Z (evSym (shift X))) (if (su...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (evSym X)
  %4 = call i64 @evSym(i64 %3)
; # (save (evSym X))
  %5 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %6 = load i64, i64* %5
  %7 = alloca i64, i64 2, align 16
  %8 = ptrtoint i64* %7 to i64
  %9 = inttoptr i64 %8 to i64*
  store i64 %4, i64* %9
  %10 = add i64 %8, 8
  %11 = inttoptr i64 %10 to i64*
  store i64 %6, i64* %11
  %12 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %8, i64* %12
; # (shift X)
  %13 = inttoptr i64 %3 to i64*
  %14 = getelementptr i64, i64* %13, i32 1
  %15 = load i64, i64* %14
; # (evSym (shift X))
  %16 = call i64 @evSym(i64 %15)
; # (if (subStr Y Z) Z $Nil)
; # (subStr Y Z)
  %17 = call i1 @subStr(i64 %4, i64 %16)
  br i1 %17, label %$2, label %$3
$2:
  br label %$4
$3:
  br label %$4
$4:
  %18 = phi i64 [%16, %$2], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$3] ; # ->
; # (drop *Safe)
  %19 = inttoptr i64 %8 to i64*
  %20 = getelementptr i64, i64* %19, i32 1
  %21 = load i64, i64* %20
  %22 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %21, i64* %22
  ret i64 %18
}

define i64 @_Val(i64) align 8 {
$1:
; # (let V (needVar Exe (eval (cadr Exe))) (when (and (sym? V) (sym? ...
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (needVar Exe (eval (cadr Exe)))
  %14 = and i64 %13, 6
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$7, label %$8
$7:
  call void @varErr(i64 %0, i64 %13)
  unreachable
$8:
; # (when (and (sym? V) (sym? (val (tail V)))) (dbFetch Exe V))
; # (and (sym? V) (sym? (val (tail V))))
; # (sym? V)
  %16 = and i64 %13, 8
  %17 = icmp ne i64 %16, 0
  br i1 %17, label %$10, label %$9
$10:
; # (tail V)
  %18 = add i64 %13, -8
; # (val (tail V))
  %19 = inttoptr i64 %18 to i64*
  %20 = load i64, i64* %19
; # (sym? (val (tail V)))
  %21 = and i64 %20, 8
  %22 = icmp ne i64 %21, 0
  br label %$9
$9:
  %23 = phi i1 [0, %$8], [%22, %$10] ; # ->
  br i1 %23, label %$11, label %$12
$11:
; # (dbFetch Exe V)
  call void @dbFetch(i64 %0, i64 %13)
  br label %$12
$12:
; # (val V)
  %24 = inttoptr i64 %13 to i64*
  %25 = load i64, i64* %24
  ret i64 %25
}

define i64 @_Set(i64) align 8 {
$1:
; # (save -ZERO (let X (cdr Exe) (loop (let Y (safe (needChkVar Exe (...
  %1 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %2 = load i64, i64* %1
  %3 = alloca i64, i64 2, align 16
  %4 = ptrtoint i64* %3 to i64
  %5 = inttoptr i64 %4 to i64*
  store i64 10, i64* %5
  %6 = add i64 %4, 8
  %7 = inttoptr i64 %6 to i64*
  store i64 %2, i64* %7
  %8 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %4, i64* %8
; # (let X (cdr Exe) (loop (let Y (safe (needChkVar Exe (eval (++ X))...
; # (cdr Exe)
  %9 = inttoptr i64 %0 to i64*
  %10 = getelementptr i64, i64* %9, i32 1
  %11 = load i64, i64* %10
; # (loop (let Y (safe (needChkVar Exe (eval (++ X)))) (when (and (sy...
  br label %$2
$2:
  %12 = phi i64 [%11, %$1], [%59, %$23] ; # X
; # (let Y (safe (needChkVar Exe (eval (++ X)))) (when (and (sym? Y) ...
; # (++ X)
  %13 = inttoptr i64 %12 to i64*
  %14 = load i64, i64* %13
  %15 = getelementptr i64, i64* %13, i32 1
  %16 = load i64, i64* %15
; # (eval (++ X))
  %17 = and i64 %14, 6
  %18 = icmp ne i64 %17, 0
  br i1 %18, label %$5, label %$4
$5:
  br label %$3
$4:
  %19 = and i64 %14, 8
  %20 = icmp ne i64 %19, 0
  br i1 %20, label %$7, label %$6
$7:
  %21 = inttoptr i64 %14 to i64*
  %22 = load i64, i64* %21
  br label %$3
$6:
  %23 = call i64 @evList(i64 %14)
  br label %$3
$3:
  %24 = phi i64 [%14, %$5], [%22, %$7], [%23, %$6] ; # ->
; # (needChkVar Exe (eval (++ X)))
  %25 = and i64 %24, 6
  %26 = icmp ne i64 %25, 0
  br i1 %26, label %$8, label %$9
$8:
  call void @varErr(i64 %0, i64 %24)
  unreachable
$9:
  %27 = icmp uge i64 %24, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %27, label %$11, label %$10
$11:
  %28 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %24
  br label %$10
$10:
  %29 = phi i1 [0, %$9], [%28, %$11] ; # ->
  br i1 %29, label %$12, label %$13
$12:
  call void @protErr(i64 %0, i64 %24)
  unreachable
$13:
; # (safe (needChkVar Exe (eval (++ X))))
  %30 = inttoptr i64 %4 to i64*
  store i64 %24, i64* %30
; # (when (and (sym? Y) (sym? (val (tail Y)))) (dbTouch Exe Y))
; # (and (sym? Y) (sym? (val (tail Y))))
; # (sym? Y)
  %31 = and i64 %24, 8
  %32 = icmp ne i64 %31, 0
  br i1 %32, label %$15, label %$14
$15:
  %33 = phi i64 [%16, %$13] ; # X
; # (tail Y)
  %34 = add i64 %24, -8
; # (val (tail Y))
  %35 = inttoptr i64 %34 to i64*
  %36 = load i64, i64* %35
; # (sym? (val (tail Y)))
  %37 = and i64 %36, 8
  %38 = icmp ne i64 %37, 0
  br label %$14
$14:
  %39 = phi i64 [%16, %$13], [%33, %$15] ; # X
  %40 = phi i1 [0, %$13], [%38, %$15] ; # ->
  br i1 %40, label %$16, label %$17
$16:
  %41 = phi i64 [%39, %$14] ; # X
; # (dbTouch Exe Y)
  call void @dbTouch(i64 %0, i64 %24)
  br label %$17
$17:
  %42 = phi i64 [%39, %$14], [%41, %$16] ; # X
; # (let Z (eval (++ X)) (set Y Z) (? (atom X) Z))
; # (++ X)
  %43 = inttoptr i64 %42 to i64*
  %44 = load i64, i64* %43
  %45 = getelementptr i64, i64* %43, i32 1
  %46 = load i64, i64* %45
; # (eval (++ X))
  %47 = and i64 %44, 6
  %48 = icmp ne i64 %47, 0
  br i1 %48, label %$20, label %$19
$20:
  br label %$18
$19:
  %49 = and i64 %44, 8
  %50 = icmp ne i64 %49, 0
  br i1 %50, label %$22, label %$21
$22:
  %51 = inttoptr i64 %44 to i64*
  %52 = load i64, i64* %51
  br label %$18
$21:
  %53 = call i64 @evList(i64 %44)
  br label %$18
$18:
  %54 = phi i64 [%44, %$20], [%52, %$22], [%53, %$21] ; # ->
; # (set Y Z)
  %55 = inttoptr i64 %24 to i64*
  store i64 %54, i64* %55
; # (? (atom X) Z)
; # (atom X)
  %56 = and i64 %46, 15
  %57 = icmp ne i64 %56, 0
  br i1 %57, label %$25, label %$23
$25:
  %58 = phi i64 [%46, %$18] ; # X
  br label %$24
$23:
  %59 = phi i64 [%46, %$18] ; # X
  br label %$2
$24:
  %60 = phi i64 [%58, %$25] ; # X
  %61 = phi i64 [%54, %$25] ; # ->
; # drop
  %62 = inttoptr i64 %4 to i64*
  %63 = getelementptr i64, i64* %62, i32 1
  %64 = load i64, i64* %63
  %65 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %64, i64* %65
  ret i64 %61
}

define i64 @_Setq(i64) align 8 {
$1:
; # (let X (cdr Exe) (loop (let Y (set (needChkVar Exe (++ X)) (eval ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (loop (let Y (set (needChkVar Exe (++ X)) (eval (++ X))) (? (atom...
  br label %$2
$2:
  %4 = phi i64 [%3, %$1], [%30, %$14] ; # X
; # (let Y (set (needChkVar Exe (++ X)) (eval (++ X))) (? (atom X) Y)...
; # (set (needChkVar Exe (++ X)) (eval (++ X)))
; # (++ X)
  %5 = inttoptr i64 %4 to i64*
  %6 = load i64, i64* %5
  %7 = getelementptr i64, i64* %5, i32 1
  %8 = load i64, i64* %7
; # (needChkVar Exe (++ X))
  %9 = and i64 %6, 6
  %10 = icmp ne i64 %9, 0
  br i1 %10, label %$3, label %$4
$3:
  call void @varErr(i64 %0, i64 %6)
  unreachable
$4:
  %11 = icmp uge i64 %6, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %11, label %$6, label %$5
$6:
  %12 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %6
  br label %$5
$5:
  %13 = phi i1 [0, %$4], [%12, %$6] ; # ->
  br i1 %13, label %$7, label %$8
$7:
  call void @protErr(i64 %0, i64 %6)
  unreachable
$8:
; # (++ X)
  %14 = inttoptr i64 %8 to i64*
  %15 = load i64, i64* %14
  %16 = getelementptr i64, i64* %14, i32 1
  %17 = load i64, i64* %16
; # (eval (++ X))
  %18 = and i64 %15, 6
  %19 = icmp ne i64 %18, 0
  br i1 %19, label %$11, label %$10
$11:
  br label %$9
$10:
  %20 = and i64 %15, 8
  %21 = icmp ne i64 %20, 0
  br i1 %21, label %$13, label %$12
$13:
  %22 = inttoptr i64 %15 to i64*
  %23 = load i64, i64* %22
  br label %$9
$12:
  %24 = call i64 @evList(i64 %15)
  br label %$9
$9:
  %25 = phi i64 [%15, %$11], [%23, %$13], [%24, %$12] ; # ->
  %26 = inttoptr i64 %6 to i64*
  store i64 %25, i64* %26
; # (? (atom X) Y)
; # (atom X)
  %27 = and i64 %17, 15
  %28 = icmp ne i64 %27, 0
  br i1 %28, label %$16, label %$14
$16:
  %29 = phi i64 [%17, %$9] ; # X
  br label %$15
$14:
  %30 = phi i64 [%17, %$9] ; # X
  br label %$2
$15:
  %31 = phi i64 [%29, %$16] ; # X
  %32 = phi i64 [%25, %$16] ; # ->
  ret i64 %32
}

define i64 @_Swap(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (save (needChkVar Exe (eval (++ X))))) (when ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (needChkVar Exe (eval (++ X)))
  %16 = and i64 %15, 6
  %17 = icmp ne i64 %16, 0
  br i1 %17, label %$7, label %$8
$7:
  call void @varErr(i64 %0, i64 %15)
  unreachable
$8:
  %18 = icmp uge i64 %15, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %18, label %$10, label %$9
$10:
  %19 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %15
  br label %$9
$9:
  %20 = phi i1 [0, %$8], [%19, %$10] ; # ->
  br i1 %20, label %$11, label %$12
$11:
  call void @protErr(i64 %0, i64 %15)
  unreachable
$12:
; # (save (needChkVar Exe (eval (++ X))))
  %21 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %22 = load i64, i64* %21
  %23 = alloca i64, i64 2, align 16
  %24 = ptrtoint i64* %23 to i64
  %25 = inttoptr i64 %24 to i64*
  store i64 %15, i64* %25
  %26 = add i64 %24, 8
  %27 = inttoptr i64 %26 to i64*
  store i64 %22, i64* %27
  %28 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %24, i64* %28
; # (when (and (sym? Y) (sym? (val (tail Y)))) (dbTouch Exe Y))
; # (and (sym? Y) (sym? (val (tail Y))))
; # (sym? Y)
  %29 = and i64 %15, 8
  %30 = icmp ne i64 %29, 0
  br i1 %30, label %$14, label %$13
$14:
; # (tail Y)
  %31 = add i64 %15, -8
; # (val (tail Y))
  %32 = inttoptr i64 %31 to i64*
  %33 = load i64, i64* %32
; # (sym? (val (tail Y)))
  %34 = and i64 %33, 8
  %35 = icmp ne i64 %34, 0
  br label %$13
$13:
  %36 = phi i1 [0, %$12], [%35, %$14] ; # ->
  br i1 %36, label %$15, label %$16
$15:
; # (dbTouch Exe Y)
  call void @dbTouch(i64 %0, i64 %15)
  br label %$16
$16:
; # (let (Z (eval (car X)) V (val Y)) (set Y Z) V)
; # (car X)
  %37 = inttoptr i64 %7 to i64*
  %38 = load i64, i64* %37
; # (eval (car X))
  %39 = and i64 %38, 6
  %40 = icmp ne i64 %39, 0
  br i1 %40, label %$19, label %$18
$19:
  br label %$17
$18:
  %41 = and i64 %38, 8
  %42 = icmp ne i64 %41, 0
  br i1 %42, label %$21, label %$20
$21:
  %43 = inttoptr i64 %38 to i64*
  %44 = load i64, i64* %43
  br label %$17
$20:
  %45 = call i64 @evList(i64 %38)
  br label %$17
$17:
  %46 = phi i64 [%38, %$19], [%44, %$21], [%45, %$20] ; # ->
; # (val Y)
  %47 = inttoptr i64 %15 to i64*
  %48 = load i64, i64* %47
; # (set Y Z)
  %49 = inttoptr i64 %15 to i64*
  store i64 %46, i64* %49
; # (drop *Safe)
  %50 = inttoptr i64 %24 to i64*
  %51 = getelementptr i64, i64* %50, i32 1
  %52 = load i64, i64* %51
  %53 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %52, i64* %53
  ret i64 %48
}

define i64 @_Xchg(i64) align 8 {
$1:
; # (save -ZERO (let X (cdr Exe) (loop (let Y (safe (needChkVar Exe (...
  %1 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %2 = load i64, i64* %1
  %3 = alloca i64, i64 2, align 16
  %4 = ptrtoint i64* %3 to i64
  %5 = inttoptr i64 %4 to i64*
  store i64 10, i64* %5
  %6 = add i64 %4, 8
  %7 = inttoptr i64 %6 to i64*
  store i64 %2, i64* %7
  %8 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %4, i64* %8
; # (let X (cdr Exe) (loop (let Y (safe (needChkVar Exe (eval (++ X))...
; # (cdr Exe)
  %9 = inttoptr i64 %0 to i64*
  %10 = getelementptr i64, i64* %9, i32 1
  %11 = load i64, i64* %10
; # (loop (let Y (safe (needChkVar Exe (eval (++ X)))) (when (and (sy...
  br label %$2
$2:
  %12 = phi i64 [%11, %$1], [%84, %$33] ; # X
; # (let Y (safe (needChkVar Exe (eval (++ X)))) (when (and (sym? Y) ...
; # (++ X)
  %13 = inttoptr i64 %12 to i64*
  %14 = load i64, i64* %13
  %15 = getelementptr i64, i64* %13, i32 1
  %16 = load i64, i64* %15
; # (eval (++ X))
  %17 = and i64 %14, 6
  %18 = icmp ne i64 %17, 0
  br i1 %18, label %$5, label %$4
$5:
  br label %$3
$4:
  %19 = and i64 %14, 8
  %20 = icmp ne i64 %19, 0
  br i1 %20, label %$7, label %$6
$7:
  %21 = inttoptr i64 %14 to i64*
  %22 = load i64, i64* %21
  br label %$3
$6:
  %23 = call i64 @evList(i64 %14)
  br label %$3
$3:
  %24 = phi i64 [%14, %$5], [%22, %$7], [%23, %$6] ; # ->
; # (needChkVar Exe (eval (++ X)))
  %25 = and i64 %24, 6
  %26 = icmp ne i64 %25, 0
  br i1 %26, label %$8, label %$9
$8:
  call void @varErr(i64 %0, i64 %24)
  unreachable
$9:
  %27 = icmp uge i64 %24, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %27, label %$11, label %$10
$11:
  %28 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %24
  br label %$10
$10:
  %29 = phi i1 [0, %$9], [%28, %$11] ; # ->
  br i1 %29, label %$12, label %$13
$12:
  call void @protErr(i64 %0, i64 %24)
  unreachable
$13:
; # (safe (needChkVar Exe (eval (++ X))))
  %30 = inttoptr i64 %4 to i64*
  store i64 %24, i64* %30
; # (when (and (sym? Y) (sym? (val (tail Y)))) (dbTouch Exe Y))
; # (and (sym? Y) (sym? (val (tail Y))))
; # (sym? Y)
  %31 = and i64 %24, 8
  %32 = icmp ne i64 %31, 0
  br i1 %32, label %$15, label %$14
$15:
  %33 = phi i64 [%16, %$13] ; # X
; # (tail Y)
  %34 = add i64 %24, -8
; # (val (tail Y))
  %35 = inttoptr i64 %34 to i64*
  %36 = load i64, i64* %35
; # (sym? (val (tail Y)))
  %37 = and i64 %36, 8
  %38 = icmp ne i64 %37, 0
  br label %$14
$14:
  %39 = phi i64 [%16, %$13], [%33, %$15] ; # X
  %40 = phi i1 [0, %$13], [%38, %$15] ; # ->
  br i1 %40, label %$16, label %$17
$16:
  %41 = phi i64 [%39, %$14] ; # X
; # (dbTouch Exe Y)
  call void @dbTouch(i64 %0, i64 %24)
  br label %$17
$17:
  %42 = phi i64 [%39, %$14], [%41, %$16] ; # X
; # (let Z (needChkVar Exe (eval (++ X))) (when (and (sym? Z) (sym? (...
; # (++ X)
  %43 = inttoptr i64 %42 to i64*
  %44 = load i64, i64* %43
  %45 = getelementptr i64, i64* %43, i32 1
  %46 = load i64, i64* %45
; # (eval (++ X))
  %47 = and i64 %44, 6
  %48 = icmp ne i64 %47, 0
  br i1 %48, label %$20, label %$19
$20:
  br label %$18
$19:
  %49 = and i64 %44, 8
  %50 = icmp ne i64 %49, 0
  br i1 %50, label %$22, label %$21
$22:
  %51 = inttoptr i64 %44 to i64*
  %52 = load i64, i64* %51
  br label %$18
$21:
  %53 = call i64 @evList(i64 %44)
  br label %$18
$18:
  %54 = phi i64 [%44, %$20], [%52, %$22], [%53, %$21] ; # ->
; # (needChkVar Exe (eval (++ X)))
  %55 = and i64 %54, 6
  %56 = icmp ne i64 %55, 0
  br i1 %56, label %$23, label %$24
$23:
  call void @varErr(i64 %0, i64 %54)
  unreachable
$24:
  %57 = icmp uge i64 %54, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %57, label %$26, label %$25
$26:
  %58 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %54
  br label %$25
$25:
  %59 = phi i1 [0, %$24], [%58, %$26] ; # ->
  br i1 %59, label %$27, label %$28
$27:
  call void @protErr(i64 %0, i64 %54)
  unreachable
$28:
; # (when (and (sym? Z) (sym? (val (tail Z)))) (dbTouch Exe Z))
; # (and (sym? Z) (sym? (val (tail Z))))
; # (sym? Z)
  %60 = and i64 %54, 8
  %61 = icmp ne i64 %60, 0
  br i1 %61, label %$30, label %$29
$30:
  %62 = phi i64 [%46, %$28] ; # X
  %63 = phi i64 [%54, %$28] ; # Z
; # (tail Z)
  %64 = add i64 %63, -8
; # (val (tail Z))
  %65 = inttoptr i64 %64 to i64*
  %66 = load i64, i64* %65
; # (sym? (val (tail Z)))
  %67 = and i64 %66, 8
  %68 = icmp ne i64 %67, 0
  br label %$29
$29:
  %69 = phi i64 [%46, %$28], [%62, %$30] ; # X
  %70 = phi i64 [%54, %$28], [%63, %$30] ; # Z
  %71 = phi i1 [0, %$28], [%68, %$30] ; # ->
  br i1 %71, label %$31, label %$32
$31:
  %72 = phi i64 [%69, %$29] ; # X
  %73 = phi i64 [%70, %$29] ; # Z
; # (dbTouch Exe Z)
  call void @dbTouch(i64 %0, i64 %73)
  br label %$32
$32:
  %74 = phi i64 [%69, %$29], [%72, %$31] ; # X
  %75 = phi i64 [%70, %$29], [%73, %$31] ; # Z
; # (xchg Y Z)
  %76 = inttoptr i64 %24 to i64*
  %77 = load i64, i64* %76
  %78 = inttoptr i64 %75 to i64*
  %79 = load i64, i64* %78
  store i64 %79, i64* %76
  store i64 %77, i64* %78
; # (? (atom X) Z)
; # (atom X)
  %80 = and i64 %74, 15
  %81 = icmp ne i64 %80, 0
  br i1 %81, label %$35, label %$33
$35:
  %82 = phi i64 [%74, %$32] ; # X
  %83 = phi i64 [%77, %$32] ; # Z
  br label %$34
$33:
  %84 = phi i64 [%74, %$32] ; # X
  %85 = phi i64 [%77, %$32] ; # Z
  br label %$2
$34:
  %86 = phi i64 [%82, %$35] ; # X
  %87 = phi i64 [%83, %$35] ; # ->
; # drop
  %88 = inttoptr i64 %4 to i64*
  %89 = getelementptr i64, i64* %88, i32 1
  %90 = load i64, i64* %89
  %91 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %90, i64* %91
  ret i64 %87
}

define i64 @_On(i64) align 8 {
$1:
; # (let X (cdr Exe) (loop (set (needChkVar Exe (++ X)) $T) (? (atom ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (loop (set (needChkVar Exe (++ X)) $T) (? (atom X) $T))
  br label %$2
$2:
  %4 = phi i64 [%3, %$1], [%18, %$9] ; # X
; # (set (needChkVar Exe (++ X)) $T)
; # (++ X)
  %5 = inttoptr i64 %4 to i64*
  %6 = load i64, i64* %5
  %7 = getelementptr i64, i64* %5, i32 1
  %8 = load i64, i64* %7
; # (needChkVar Exe (++ X))
  %9 = and i64 %6, 6
  %10 = icmp ne i64 %9, 0
  br i1 %10, label %$3, label %$4
$3:
  call void @varErr(i64 %0, i64 %6)
  unreachable
$4:
  %11 = icmp uge i64 %6, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %11, label %$6, label %$5
$6:
  %12 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %6
  br label %$5
$5:
  %13 = phi i1 [0, %$4], [%12, %$6] ; # ->
  br i1 %13, label %$7, label %$8
$7:
  call void @protErr(i64 %0, i64 %6)
  unreachable
$8:
  %14 = inttoptr i64 %6 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), i64* %14
; # (? (atom X) $T)
; # (atom X)
  %15 = and i64 %8, 15
  %16 = icmp ne i64 %15, 0
  br i1 %16, label %$11, label %$9
$11:
  %17 = phi i64 [%8, %$8] ; # X
  br label %$10
$9:
  %18 = phi i64 [%8, %$8] ; # X
  br label %$2
$10:
  %19 = phi i64 [%17, %$11] ; # X
  %20 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$11] ; # ->
  ret i64 %20
}

define i64 @_Off(i64) align 8 {
$1:
; # (let X (cdr Exe) (loop (set (needChkVar Exe (++ X)) $Nil) (? (ato...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (loop (set (needChkVar Exe (++ X)) $Nil) (? (atom X) $Nil))
  br label %$2
$2:
  %4 = phi i64 [%3, %$1], [%18, %$9] ; # X
; # (set (needChkVar Exe (++ X)) $Nil)
; # (++ X)
  %5 = inttoptr i64 %4 to i64*
  %6 = load i64, i64* %5
  %7 = getelementptr i64, i64* %5, i32 1
  %8 = load i64, i64* %7
; # (needChkVar Exe (++ X))
  %9 = and i64 %6, 6
  %10 = icmp ne i64 %9, 0
  br i1 %10, label %$3, label %$4
$3:
  call void @varErr(i64 %0, i64 %6)
  unreachable
$4:
  %11 = icmp uge i64 %6, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %11, label %$6, label %$5
$6:
  %12 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %6
  br label %$5
$5:
  %13 = phi i1 [0, %$4], [%12, %$6] ; # ->
  br i1 %13, label %$7, label %$8
$7:
  call void @protErr(i64 %0, i64 %6)
  unreachable
$8:
  %14 = inttoptr i64 %6 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %14
; # (? (atom X) $Nil)
; # (atom X)
  %15 = and i64 %8, 15
  %16 = icmp ne i64 %15, 0
  br i1 %16, label %$11, label %$9
$11:
  %17 = phi i64 [%8, %$8] ; # X
  br label %$10
$9:
  %18 = phi i64 [%8, %$8] ; # X
  br label %$2
$10:
  %19 = phi i64 [%17, %$11] ; # X
  %20 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$11] ; # ->
  ret i64 %20
}

define i64 @_OnOff(i64) align 8 {
$1:
; # (let X (cdr Exe) (loop (let (Y (needChkVar Exe (++ X)) Z (if (nil...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (loop (let (Y (needChkVar Exe (++ X)) Z (if (nil? (val Y)) $T $Ni...
  br label %$2
$2:
  %4 = phi i64 [%3, %$1], [%25, %$12] ; # X
; # (let (Y (needChkVar Exe (++ X)) Z (if (nil? (val Y)) $T $Nil)) (s...
; # (++ X)
  %5 = inttoptr i64 %4 to i64*
  %6 = load i64, i64* %5
  %7 = getelementptr i64, i64* %5, i32 1
  %8 = load i64, i64* %7
; # (needChkVar Exe (++ X))
  %9 = and i64 %6, 6
  %10 = icmp ne i64 %9, 0
  br i1 %10, label %$3, label %$4
$3:
  call void @varErr(i64 %0, i64 %6)
  unreachable
$4:
  %11 = icmp uge i64 %6, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %11, label %$6, label %$5
$6:
  %12 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %6
  br label %$5
$5:
  %13 = phi i1 [0, %$4], [%12, %$6] ; # ->
  br i1 %13, label %$7, label %$8
$7:
  call void @protErr(i64 %0, i64 %6)
  unreachable
$8:
; # (if (nil? (val Y)) $T $Nil)
; # (val Y)
  %14 = inttoptr i64 %6 to i64*
  %15 = load i64, i64* %14
; # (nil? (val Y))
  %16 = icmp eq i64 %15, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %16, label %$9, label %$10
$9:
  %17 = phi i64 [%8, %$8] ; # X
  br label %$11
$10:
  %18 = phi i64 [%8, %$8] ; # X
  br label %$11
$11:
  %19 = phi i64 [%17, %$9], [%18, %$10] ; # X
  %20 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$9], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$10] ; # ->
; # (set Y Z)
  %21 = inttoptr i64 %6 to i64*
  store i64 %20, i64* %21
; # (? (atom X) Z)
; # (atom X)
  %22 = and i64 %19, 15
  %23 = icmp ne i64 %22, 0
  br i1 %23, label %$14, label %$12
$14:
  %24 = phi i64 [%19, %$11] ; # X
  br label %$13
$12:
  %25 = phi i64 [%19, %$11] ; # X
  br label %$2
$13:
  %26 = phi i64 [%24, %$14] ; # X
  %27 = phi i64 [%20, %$14] ; # ->
  ret i64 %27
}

define i64 @_Zero(i64) align 8 {
$1:
; # (let X (cdr Exe) (loop (set (needChkVar Exe (++ X)) ZERO) (? (ato...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (loop (set (needChkVar Exe (++ X)) ZERO) (? (atom X) ZERO))
  br label %$2
$2:
  %4 = phi i64 [%3, %$1], [%18, %$9] ; # X
; # (set (needChkVar Exe (++ X)) ZERO)
; # (++ X)
  %5 = inttoptr i64 %4 to i64*
  %6 = load i64, i64* %5
  %7 = getelementptr i64, i64* %5, i32 1
  %8 = load i64, i64* %7
; # (needChkVar Exe (++ X))
  %9 = and i64 %6, 6
  %10 = icmp ne i64 %9, 0
  br i1 %10, label %$3, label %$4
$3:
  call void @varErr(i64 %0, i64 %6)
  unreachable
$4:
  %11 = icmp uge i64 %6, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %11, label %$6, label %$5
$6:
  %12 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %6
  br label %$5
$5:
  %13 = phi i1 [0, %$4], [%12, %$6] ; # ->
  br i1 %13, label %$7, label %$8
$7:
  call void @protErr(i64 %0, i64 %6)
  unreachable
$8:
  %14 = inttoptr i64 %6 to i64*
  store i64 2, i64* %14
; # (? (atom X) ZERO)
; # (atom X)
  %15 = and i64 %8, 15
  %16 = icmp ne i64 %15, 0
  br i1 %16, label %$11, label %$9
$11:
  %17 = phi i64 [%8, %$8] ; # X
  br label %$10
$9:
  %18 = phi i64 [%8, %$8] ; # X
  br label %$2
$10:
  %19 = phi i64 [%17, %$11] ; # X
  %20 = phi i64 [2, %$11] ; # ->
  ret i64 %20
}

define i64 @_One(i64) align 8 {
$1:
; # (let X (cdr Exe) (loop (set (needChkVar Exe (++ X)) ONE) (? (atom...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (loop (set (needChkVar Exe (++ X)) ONE) (? (atom X) ONE))
  br label %$2
$2:
  %4 = phi i64 [%3, %$1], [%18, %$9] ; # X
; # (set (needChkVar Exe (++ X)) ONE)
; # (++ X)
  %5 = inttoptr i64 %4 to i64*
  %6 = load i64, i64* %5
  %7 = getelementptr i64, i64* %5, i32 1
  %8 = load i64, i64* %7
; # (needChkVar Exe (++ X))
  %9 = and i64 %6, 6
  %10 = icmp ne i64 %9, 0
  br i1 %10, label %$3, label %$4
$3:
  call void @varErr(i64 %0, i64 %6)
  unreachable
$4:
  %11 = icmp uge i64 %6, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %11, label %$6, label %$5
$6:
  %12 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %6
  br label %$5
$5:
  %13 = phi i1 [0, %$4], [%12, %$6] ; # ->
  br i1 %13, label %$7, label %$8
$7:
  call void @protErr(i64 %0, i64 %6)
  unreachable
$8:
  %14 = inttoptr i64 %6 to i64*
  store i64 18, i64* %14
; # (? (atom X) ONE)
; # (atom X)
  %15 = and i64 %8, 15
  %16 = icmp ne i64 %15, 0
  br i1 %16, label %$11, label %$9
$11:
  %17 = phi i64 [%8, %$8] ; # X
  br label %$10
$9:
  %18 = phi i64 [%8, %$8] ; # X
  br label %$2
$10:
  %19 = phi i64 [%17, %$11] ; # X
  %20 = phi i64 [18, %$11] ; # ->
  ret i64 %20
}

define i64 @_Default(i64) align 8 {
$1:
; # (let X (cdr Exe) (loop (let Y (needChkVar Exe (++ X)) (when (nil?...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (loop (let Y (needChkVar Exe (++ X)) (when (nil? (val Y)) (set Y ...
  br label %$2
$2:
  %4 = phi i64 [%3, %$1], [%38, %$16] ; # X
; # (let Y (needChkVar Exe (++ X)) (when (nil? (val Y)) (set Y (eval ...
; # (++ X)
  %5 = inttoptr i64 %4 to i64*
  %6 = load i64, i64* %5
  %7 = getelementptr i64, i64* %5, i32 1
  %8 = load i64, i64* %7
; # (needChkVar Exe (++ X))
  %9 = and i64 %6, 6
  %10 = icmp ne i64 %9, 0
  br i1 %10, label %$3, label %$4
$3:
  call void @varErr(i64 %0, i64 %6)
  unreachable
$4:
  %11 = icmp uge i64 %6, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %11, label %$6, label %$5
$6:
  %12 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %6
  br label %$5
$5:
  %13 = phi i1 [0, %$4], [%12, %$6] ; # ->
  br i1 %13, label %$7, label %$8
$7:
  call void @protErr(i64 %0, i64 %6)
  unreachable
$8:
; # (when (nil? (val Y)) (set Y (eval (car X))))
; # (val Y)
  %14 = inttoptr i64 %6 to i64*
  %15 = load i64, i64* %14
; # (nil? (val Y))
  %16 = icmp eq i64 %15, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %16, label %$9, label %$10
$9:
  %17 = phi i64 [%8, %$8] ; # X
; # (set Y (eval (car X)))
; # (car X)
  %18 = inttoptr i64 %17 to i64*
  %19 = load i64, i64* %18
; # (eval (car X))
  %20 = and i64 %19, 6
  %21 = icmp ne i64 %20, 0
  br i1 %21, label %$13, label %$12
$13:
  br label %$11
$12:
  %22 = and i64 %19, 8
  %23 = icmp ne i64 %22, 0
  br i1 %23, label %$15, label %$14
$15:
  %24 = inttoptr i64 %19 to i64*
  %25 = load i64, i64* %24
  br label %$11
$14:
  %26 = call i64 @evList(i64 %19)
  br label %$11
$11:
  %27 = phi i64 [%19, %$13], [%25, %$15], [%26, %$14] ; # ->
  %28 = inttoptr i64 %6 to i64*
  store i64 %27, i64* %28
  br label %$10
$10:
  %29 = phi i64 [%8, %$8], [%17, %$11] ; # X
; # (? (atom (shift X)) (val Y))
; # (shift X)
  %30 = inttoptr i64 %29 to i64*
  %31 = getelementptr i64, i64* %30, i32 1
  %32 = load i64, i64* %31
; # (atom (shift X))
  %33 = and i64 %32, 15
  %34 = icmp ne i64 %33, 0
  br i1 %34, label %$18, label %$16
$18:
  %35 = phi i64 [%32, %$10] ; # X
; # (val Y)
  %36 = inttoptr i64 %6 to i64*
  %37 = load i64, i64* %36
  br label %$17
$16:
  %38 = phi i64 [%32, %$10] ; # X
  br label %$2
$17:
  %39 = phi i64 [%35, %$18] ; # X
  %40 = phi i64 [%37, %$18] ; # ->
  ret i64 %40
}

define i64 @_Push(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (save (needChkVar Exe (eval (++ X))))) (when ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (needChkVar Exe (eval (++ X)))
  %16 = and i64 %15, 6
  %17 = icmp ne i64 %16, 0
  br i1 %17, label %$7, label %$8
$7:
  call void @varErr(i64 %0, i64 %15)
  unreachable
$8:
  %18 = icmp uge i64 %15, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %18, label %$10, label %$9
$10:
  %19 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %15
  br label %$9
$9:
  %20 = phi i1 [0, %$8], [%19, %$10] ; # ->
  br i1 %20, label %$11, label %$12
$11:
  call void @protErr(i64 %0, i64 %15)
  unreachable
$12:
; # (save (needChkVar Exe (eval (++ X))))
  %21 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %22 = load i64, i64* %21
  %23 = alloca i64, i64 2, align 16
  %24 = ptrtoint i64* %23 to i64
  %25 = inttoptr i64 %24 to i64*
  store i64 %15, i64* %25
  %26 = add i64 %24, 8
  %27 = inttoptr i64 %26 to i64*
  store i64 %22, i64* %27
  %28 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %24, i64* %28
; # (when (and (sym? Y) (sym? (val (tail Y)))) (dbTouch Exe Y))
; # (and (sym? Y) (sym? (val (tail Y))))
; # (sym? Y)
  %29 = and i64 %15, 8
  %30 = icmp ne i64 %29, 0
  br i1 %30, label %$14, label %$13
$14:
  %31 = phi i64 [%7, %$12] ; # X
; # (tail Y)
  %32 = add i64 %15, -8
; # (val (tail Y))
  %33 = inttoptr i64 %32 to i64*
  %34 = load i64, i64* %33
; # (sym? (val (tail Y)))
  %35 = and i64 %34, 8
  %36 = icmp ne i64 %35, 0
  br label %$13
$13:
  %37 = phi i64 [%7, %$12], [%31, %$14] ; # X
  %38 = phi i1 [0, %$12], [%36, %$14] ; # ->
  br i1 %38, label %$15, label %$16
$15:
  %39 = phi i64 [%37, %$13] ; # X
; # (dbTouch Exe Y)
  call void @dbTouch(i64 %0, i64 %15)
  br label %$16
$16:
  %40 = phi i64 [%37, %$13], [%39, %$15] ; # X
; # (loop (let Z (eval (++ X)) (set Y (cons Z (val Y))) (? (atom X) Z...
  br label %$17
$17:
  %41 = phi i64 [%40, %$16], [%61, %$23] ; # X
; # (let Z (eval (++ X)) (set Y (cons Z (val Y))) (? (atom X) Z))
; # (++ X)
  %42 = inttoptr i64 %41 to i64*
  %43 = load i64, i64* %42
  %44 = getelementptr i64, i64* %42, i32 1
  %45 = load i64, i64* %44
; # (eval (++ X))
  %46 = and i64 %43, 6
  %47 = icmp ne i64 %46, 0
  br i1 %47, label %$20, label %$19
$20:
  br label %$18
$19:
  %48 = and i64 %43, 8
  %49 = icmp ne i64 %48, 0
  br i1 %49, label %$22, label %$21
$22:
  %50 = inttoptr i64 %43 to i64*
  %51 = load i64, i64* %50
  br label %$18
$21:
  %52 = call i64 @evList(i64 %43)
  br label %$18
$18:
  %53 = phi i64 [%43, %$20], [%51, %$22], [%52, %$21] ; # ->
; # (set Y (cons Z (val Y)))
; # (val Y)
  %54 = inttoptr i64 %15 to i64*
  %55 = load i64, i64* %54
; # (cons Z (val Y))
  %56 = call i64 @cons(i64 %53, i64 %55)
  %57 = inttoptr i64 %15 to i64*
  store i64 %56, i64* %57
; # (? (atom X) Z)
; # (atom X)
  %58 = and i64 %45, 15
  %59 = icmp ne i64 %58, 0
  br i1 %59, label %$25, label %$23
$25:
  %60 = phi i64 [%45, %$18] ; # X
  br label %$24
$23:
  %61 = phi i64 [%45, %$18] ; # X
  br label %$17
$24:
  %62 = phi i64 [%60, %$25] ; # X
  %63 = phi i64 [%53, %$25] ; # ->
; # (drop *Safe)
  %64 = inttoptr i64 %24 to i64*
  %65 = getelementptr i64, i64* %64, i32 1
  %66 = load i64, i64* %65
  %67 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %66, i64* %67
  ret i64 %63
}

define i64 @_Push1(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (save (needChkVar Exe (eval (++ X))))) (when ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (needChkVar Exe (eval (++ X)))
  %16 = and i64 %15, 6
  %17 = icmp ne i64 %16, 0
  br i1 %17, label %$7, label %$8
$7:
  call void @varErr(i64 %0, i64 %15)
  unreachable
$8:
  %18 = icmp uge i64 %15, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %18, label %$10, label %$9
$10:
  %19 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %15
  br label %$9
$9:
  %20 = phi i1 [0, %$8], [%19, %$10] ; # ->
  br i1 %20, label %$11, label %$12
$11:
  call void @protErr(i64 %0, i64 %15)
  unreachable
$12:
; # (save (needChkVar Exe (eval (++ X))))
  %21 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %22 = load i64, i64* %21
  %23 = alloca i64, i64 2, align 16
  %24 = ptrtoint i64* %23 to i64
  %25 = inttoptr i64 %24 to i64*
  store i64 %15, i64* %25
  %26 = add i64 %24, 8
  %27 = inttoptr i64 %26 to i64*
  store i64 %22, i64* %27
  %28 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %24, i64* %28
; # (when (and (sym? Y) (sym? (val (tail Y)))) (dbTouch Exe Y))
; # (and (sym? Y) (sym? (val (tail Y))))
; # (sym? Y)
  %29 = and i64 %15, 8
  %30 = icmp ne i64 %29, 0
  br i1 %30, label %$14, label %$13
$14:
  %31 = phi i64 [%7, %$12] ; # X
; # (tail Y)
  %32 = add i64 %15, -8
; # (val (tail Y))
  %33 = inttoptr i64 %32 to i64*
  %34 = load i64, i64* %33
; # (sym? (val (tail Y)))
  %35 = and i64 %34, 8
  %36 = icmp ne i64 %35, 0
  br label %$13
$13:
  %37 = phi i64 [%7, %$12], [%31, %$14] ; # X
  %38 = phi i1 [0, %$12], [%36, %$14] ; # ->
  br i1 %38, label %$15, label %$16
$15:
  %39 = phi i64 [%37, %$13] ; # X
; # (dbTouch Exe Y)
  call void @dbTouch(i64 %0, i64 %15)
  br label %$16
$16:
  %40 = phi i64 [%37, %$13], [%39, %$15] ; # X
; # (loop (let (Z (eval (++ X)) V (val Y)) (unless (member Z V) (set ...
  br label %$17
$17:
  %41 = phi i64 [%40, %$16], [%78, %$31] ; # X
; # (let (Z (eval (++ X)) V (val Y)) (unless (member Z V) (set Y (con...
; # (++ X)
  %42 = inttoptr i64 %41 to i64*
  %43 = load i64, i64* %42
  %44 = getelementptr i64, i64* %42, i32 1
  %45 = load i64, i64* %44
; # (eval (++ X))
  %46 = and i64 %43, 6
  %47 = icmp ne i64 %46, 0
  br i1 %47, label %$20, label %$19
$20:
  br label %$18
$19:
  %48 = and i64 %43, 8
  %49 = icmp ne i64 %48, 0
  br i1 %49, label %$22, label %$21
$22:
  %50 = inttoptr i64 %43 to i64*
  %51 = load i64, i64* %50
  br label %$18
$21:
  %52 = call i64 @evList(i64 %43)
  br label %$18
$18:
  %53 = phi i64 [%43, %$20], [%51, %$22], [%52, %$21] ; # ->
; # (val Y)
  %54 = inttoptr i64 %15 to i64*
  %55 = load i64, i64* %54
; # (unless (member Z V) (set Y (cons Z V)))
; # (member Z V)
  br label %$23
$23:
  %56 = phi i64 [%55, %$18], [%68, %$27] ; # L
  %57 = and i64 %56, 15
  %58 = icmp ne i64 %57, 0
  br i1 %58, label %$26, label %$24
$26:
  %59 = phi i64 [%56, %$23] ; # L
  br label %$25
$24:
  %60 = phi i64 [%56, %$23] ; # L
  %61 = inttoptr i64 %60 to i64*
  %62 = load i64, i64* %61
  %63 = call i1 @equal(i64 %53, i64 %62)
  br i1 %63, label %$28, label %$27
$28:
  %64 = phi i64 [%60, %$24] ; # L
  br label %$25
$27:
  %65 = phi i64 [%60, %$24] ; # L
  %66 = inttoptr i64 %65 to i64*
  %67 = getelementptr i64, i64* %66, i32 1
  %68 = load i64, i64* %67
  br label %$23
$25:
  %69 = phi i64 [%59, %$26], [%64, %$28] ; # L
  %70 = phi i1 [0, %$26], [1, %$28] ; # ->
  br i1 %70, label %$30, label %$29
$29:
  %71 = phi i64 [%45, %$25] ; # X
; # (set Y (cons Z V))
; # (cons Z V)
  %72 = call i64 @cons(i64 %53, i64 %55)
  %73 = inttoptr i64 %15 to i64*
  store i64 %72, i64* %73
  br label %$30
$30:
  %74 = phi i64 [%45, %$25], [%71, %$29] ; # X
; # (? (atom X) Z)
; # (atom X)
  %75 = and i64 %74, 15
  %76 = icmp ne i64 %75, 0
  br i1 %76, label %$33, label %$31
$33:
  %77 = phi i64 [%74, %$30] ; # X
  br label %$32
$31:
  %78 = phi i64 [%74, %$30] ; # X
  br label %$17
$32:
  %79 = phi i64 [%77, %$33] ; # X
  %80 = phi i64 [%53, %$33] ; # ->
; # (drop *Safe)
  %81 = inttoptr i64 %24 to i64*
  %82 = getelementptr i64, i64* %81, i32 1
  %83 = load i64, i64* %82
  %84 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %83, i64* %84
  ret i64 %80
}

define i64 @_Push1q(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (save (needChkVar Exe (eval (++ X))))) (when ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (needChkVar Exe (eval (++ X)))
  %16 = and i64 %15, 6
  %17 = icmp ne i64 %16, 0
  br i1 %17, label %$7, label %$8
$7:
  call void @varErr(i64 %0, i64 %15)
  unreachable
$8:
  %18 = icmp uge i64 %15, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %18, label %$10, label %$9
$10:
  %19 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %15
  br label %$9
$9:
  %20 = phi i1 [0, %$8], [%19, %$10] ; # ->
  br i1 %20, label %$11, label %$12
$11:
  call void @protErr(i64 %0, i64 %15)
  unreachable
$12:
; # (save (needChkVar Exe (eval (++ X))))
  %21 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %22 = load i64, i64* %21
  %23 = alloca i64, i64 2, align 16
  %24 = ptrtoint i64* %23 to i64
  %25 = inttoptr i64 %24 to i64*
  store i64 %15, i64* %25
  %26 = add i64 %24, 8
  %27 = inttoptr i64 %26 to i64*
  store i64 %22, i64* %27
  %28 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %24, i64* %28
; # (when (and (sym? Y) (sym? (val (tail Y)))) (dbTouch Exe Y))
; # (and (sym? Y) (sym? (val (tail Y))))
; # (sym? Y)
  %29 = and i64 %15, 8
  %30 = icmp ne i64 %29, 0
  br i1 %30, label %$14, label %$13
$14:
  %31 = phi i64 [%7, %$12] ; # X
; # (tail Y)
  %32 = add i64 %15, -8
; # (val (tail Y))
  %33 = inttoptr i64 %32 to i64*
  %34 = load i64, i64* %33
; # (sym? (val (tail Y)))
  %35 = and i64 %34, 8
  %36 = icmp ne i64 %35, 0
  br label %$13
$13:
  %37 = phi i64 [%7, %$12], [%31, %$14] ; # X
  %38 = phi i1 [0, %$12], [%36, %$14] ; # ->
  br i1 %38, label %$15, label %$16
$15:
  %39 = phi i64 [%37, %$13] ; # X
; # (dbTouch Exe Y)
  call void @dbTouch(i64 %0, i64 %15)
  br label %$16
$16:
  %40 = phi i64 [%37, %$13], [%39, %$15] ; # X
; # (loop (let (Z (eval (++ X)) V (val Y)) (unless (memq Z V) (set Y ...
  br label %$17
$17:
  %41 = phi i64 [%40, %$16], [%78, %$31] ; # X
; # (let (Z (eval (++ X)) V (val Y)) (unless (memq Z V) (set Y (cons ...
; # (++ X)
  %42 = inttoptr i64 %41 to i64*
  %43 = load i64, i64* %42
  %44 = getelementptr i64, i64* %42, i32 1
  %45 = load i64, i64* %44
; # (eval (++ X))
  %46 = and i64 %43, 6
  %47 = icmp ne i64 %46, 0
  br i1 %47, label %$20, label %$19
$20:
  br label %$18
$19:
  %48 = and i64 %43, 8
  %49 = icmp ne i64 %48, 0
  br i1 %49, label %$22, label %$21
$22:
  %50 = inttoptr i64 %43 to i64*
  %51 = load i64, i64* %50
  br label %$18
$21:
  %52 = call i64 @evList(i64 %43)
  br label %$18
$18:
  %53 = phi i64 [%43, %$20], [%51, %$22], [%52, %$21] ; # ->
; # (val Y)
  %54 = inttoptr i64 %15 to i64*
  %55 = load i64, i64* %54
; # (unless (memq Z V) (set Y (cons Z V)))
; # (memq Z V)
  br label %$23
$23:
  %56 = phi i64 [%55, %$18], [%68, %$27] ; # L
  %57 = and i64 %56, 15
  %58 = icmp ne i64 %57, 0
  br i1 %58, label %$26, label %$24
$26:
  %59 = phi i64 [%56, %$23] ; # L
  br label %$25
$24:
  %60 = phi i64 [%56, %$23] ; # L
  %61 = inttoptr i64 %60 to i64*
  %62 = load i64, i64* %61
  %63 = icmp eq i64 %53, %62
  br i1 %63, label %$28, label %$27
$28:
  %64 = phi i64 [%60, %$24] ; # L
  br label %$25
$27:
  %65 = phi i64 [%60, %$24] ; # L
  %66 = inttoptr i64 %65 to i64*
  %67 = getelementptr i64, i64* %66, i32 1
  %68 = load i64, i64* %67
  br label %$23
$25:
  %69 = phi i64 [%59, %$26], [%64, %$28] ; # L
  %70 = phi i1 [0, %$26], [1, %$28] ; # ->
  br i1 %70, label %$30, label %$29
$29:
  %71 = phi i64 [%45, %$25] ; # X
; # (set Y (cons Z V))
; # (cons Z V)
  %72 = call i64 @cons(i64 %53, i64 %55)
  %73 = inttoptr i64 %15 to i64*
  store i64 %72, i64* %73
  br label %$30
$30:
  %74 = phi i64 [%45, %$25], [%71, %$29] ; # X
; # (? (atom X) Z)
; # (atom X)
  %75 = and i64 %74, 15
  %76 = icmp ne i64 %75, 0
  br i1 %76, label %$33, label %$31
$33:
  %77 = phi i64 [%74, %$30] ; # X
  br label %$32
$31:
  %78 = phi i64 [%74, %$30] ; # X
  br label %$17
$32:
  %79 = phi i64 [%77, %$33] ; # X
  %80 = phi i64 [%53, %$33] ; # ->
; # (drop *Safe)
  %81 = inttoptr i64 %24 to i64*
  %82 = getelementptr i64, i64* %81, i32 1
  %83 = load i64, i64* %82
  %84 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %83, i64* %84
  ret i64 %80
}

define i64 @_Pop(i64) align 8 {
$1:
; # (let X (needChkVar Exe (eval (cadr Exe))) (when (and (sym? X) (sy...
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (needChkVar Exe (eval (cadr Exe)))
  %14 = and i64 %13, 6
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$7, label %$8
$7:
  call void @varErr(i64 %0, i64 %13)
  unreachable
$8:
  %16 = icmp uge i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %16, label %$10, label %$9
$10:
  %17 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %13
  br label %$9
$9:
  %18 = phi i1 [0, %$8], [%17, %$10] ; # ->
  br i1 %18, label %$11, label %$12
$11:
  call void @protErr(i64 %0, i64 %13)
  unreachable
$12:
; # (when (and (sym? X) (sym? (val (tail X)))) (dbTouch Exe X))
; # (and (sym? X) (sym? (val (tail X))))
; # (sym? X)
  %19 = and i64 %13, 8
  %20 = icmp ne i64 %19, 0
  br i1 %20, label %$14, label %$13
$14:
; # (tail X)
  %21 = add i64 %13, -8
; # (val (tail X))
  %22 = inttoptr i64 %21 to i64*
  %23 = load i64, i64* %22
; # (sym? (val (tail X)))
  %24 = and i64 %23, 8
  %25 = icmp ne i64 %24, 0
  br label %$13
$13:
  %26 = phi i1 [0, %$12], [%25, %$14] ; # ->
  br i1 %26, label %$15, label %$16
$15:
; # (dbTouch Exe X)
  call void @dbTouch(i64 %0, i64 %13)
  br label %$16
$16:
; # (if (atom (val X)) @ (set X (cdr @)) (car @))
; # (val X)
  %27 = inttoptr i64 %13 to i64*
  %28 = load i64, i64* %27
; # (atom (val X))
  %29 = and i64 %28, 15
  %30 = icmp ne i64 %29, 0
  br i1 %30, label %$17, label %$18
$17:
  br label %$19
$18:
; # (set X (cdr @))
; # (cdr @)
  %31 = inttoptr i64 %28 to i64*
  %32 = getelementptr i64, i64* %31, i32 1
  %33 = load i64, i64* %32
  %34 = inttoptr i64 %13 to i64*
  store i64 %33, i64* %34
; # (car @)
  %35 = inttoptr i64 %28 to i64*
  %36 = load i64, i64* %35
  br label %$19
$19:
  %37 = phi i64 [%28, %$17], [%36, %$18] ; # ->
  ret i64 %37
}

define i64 @_Popq(i64) align 8 {
$1:
; # (let X (needChkVar Exe (cadr Exe)) (if (atom (val X)) @ (set X (c...
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (needChkVar Exe (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$2, label %$3
$2:
  call void @varErr(i64 %0, i64 %5)
  unreachable
$3:
  %8 = icmp uge i64 %5, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %8, label %$5, label %$4
$5:
  %9 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %5
  br label %$4
$4:
  %10 = phi i1 [0, %$3], [%9, %$5] ; # ->
  br i1 %10, label %$6, label %$7
$6:
  call void @protErr(i64 %0, i64 %5)
  unreachable
$7:
; # (if (atom (val X)) @ (set X (cdr @)) (car @))
; # (val X)
  %11 = inttoptr i64 %5 to i64*
  %12 = load i64, i64* %11
; # (atom (val X))
  %13 = and i64 %12, 15
  %14 = icmp ne i64 %13, 0
  br i1 %14, label %$8, label %$9
$8:
  br label %$10
$9:
; # (set X (cdr @))
; # (cdr @)
  %15 = inttoptr i64 %12 to i64*
  %16 = getelementptr i64, i64* %15, i32 1
  %17 = load i64, i64* %16
  %18 = inttoptr i64 %5 to i64*
  store i64 %17, i64* %18
; # (car @)
  %19 = inttoptr i64 %12 to i64*
  %20 = load i64, i64* %19
  br label %$10
$10:
  %21 = phi i64 [%12, %$8], [%20, %$9] ; # ->
  ret i64 %21
}

define i64 @_Shift(i64) align 8 {
$1:
; # (let X (needChkVar Exe (eval (cadr Exe))) (when (and (sym? X) (sy...
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (needChkVar Exe (eval (cadr Exe)))
  %14 = and i64 %13, 6
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$7, label %$8
$7:
  call void @varErr(i64 %0, i64 %13)
  unreachable
$8:
  %16 = icmp uge i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %16, label %$10, label %$9
$10:
  %17 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %13
  br label %$9
$9:
  %18 = phi i1 [0, %$8], [%17, %$10] ; # ->
  br i1 %18, label %$11, label %$12
$11:
  call void @protErr(i64 %0, i64 %13)
  unreachable
$12:
; # (when (and (sym? X) (sym? (val (tail X)))) (dbTouch Exe X))
; # (and (sym? X) (sym? (val (tail X))))
; # (sym? X)
  %19 = and i64 %13, 8
  %20 = icmp ne i64 %19, 0
  br i1 %20, label %$14, label %$13
$14:
; # (tail X)
  %21 = add i64 %13, -8
; # (val (tail X))
  %22 = inttoptr i64 %21 to i64*
  %23 = load i64, i64* %22
; # (sym? (val (tail X)))
  %24 = and i64 %23, 8
  %25 = icmp ne i64 %24, 0
  br label %$13
$13:
  %26 = phi i1 [0, %$12], [%25, %$14] ; # ->
  br i1 %26, label %$15, label %$16
$15:
; # (dbTouch Exe X)
  call void @dbTouch(i64 %0, i64 %13)
  br label %$16
$16:
; # (set X (cdr (needLst Exe (val X))))
; # (val X)
  %27 = inttoptr i64 %13 to i64*
  %28 = load i64, i64* %27
; # (needLst Exe (val X))
  %29 = and i64 %28, 15
  %30 = icmp eq i64 %29, 0
  br i1 %30, label %$17, label %$18
$18:
  %31 = icmp eq i64 %28, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$17
$17:
  %32 = phi i1 [1, %$16], [%31, %$18] ; # ->
  br i1 %32, label %$20, label %$19
$19:
  call void @lstErr(i64 %0, i64 %28)
  unreachable
$20:
; # (cdr (needLst Exe (val X)))
  %33 = inttoptr i64 %28 to i64*
  %34 = getelementptr i64, i64* %33, i32 1
  %35 = load i64, i64* %34
  %36 = inttoptr i64 %13 to i64*
  store i64 %35, i64* %36
  ret i64 %35
}

define i64 @_Cut(i64) align 8 {
$1:
; # (let (X (cdr Exe) N (evCnt Exe X)) (if (le0 N) $Nil (let Y (needC...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (evCnt Exe X)
  %4 = call i64 @evCnt(i64 %0, i64 %3)
; # (if (le0 N) $Nil (let Y (needChkVar Exe (eval (cadr X))) (when (a...
; # (le0 N)
  %5 = icmp sle i64 %4, 0
  br i1 %5, label %$2, label %$3
$2:
  %6 = phi i64 [%4, %$1] ; # N
  br label %$4
$3:
  %7 = phi i64 [%4, %$1] ; # N
; # (let Y (needChkVar Exe (eval (cadr X))) (when (and (sym? Y) (sym?...
; # (cadr X)
  %8 = inttoptr i64 %3 to i64*
  %9 = getelementptr i64, i64* %8, i32 1
  %10 = load i64, i64* %9
  %11 = inttoptr i64 %10 to i64*
  %12 = load i64, i64* %11
; # (eval (cadr X))
  %13 = and i64 %12, 6
  %14 = icmp ne i64 %13, 0
  br i1 %14, label %$7, label %$6
$7:
  br label %$5
$6:
  %15 = and i64 %12, 8
  %16 = icmp ne i64 %15, 0
  br i1 %16, label %$9, label %$8
$9:
  %17 = inttoptr i64 %12 to i64*
  %18 = load i64, i64* %17
  br label %$5
$8:
  %19 = call i64 @evList(i64 %12)
  br label %$5
$5:
  %20 = phi i64 [%12, %$7], [%18, %$9], [%19, %$8] ; # ->
; # (needChkVar Exe (eval (cadr X)))
  %21 = and i64 %20, 6
  %22 = icmp ne i64 %21, 0
  br i1 %22, label %$10, label %$11
$10:
  call void @varErr(i64 %0, i64 %20)
  unreachable
$11:
  %23 = icmp uge i64 %20, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %23, label %$13, label %$12
$13:
  %24 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %20
  br label %$12
$12:
  %25 = phi i1 [0, %$11], [%24, %$13] ; # ->
  br i1 %25, label %$14, label %$15
$14:
  call void @protErr(i64 %0, i64 %20)
  unreachable
$15:
; # (when (and (sym? Y) (sym? (val (tail Y)))) (dbTouch Exe Y))
; # (and (sym? Y) (sym? (val (tail Y))))
; # (sym? Y)
  %26 = and i64 %20, 8
  %27 = icmp ne i64 %26, 0
  br i1 %27, label %$17, label %$16
$17:
  %28 = phi i64 [%7, %$15] ; # N
; # (tail Y)
  %29 = add i64 %20, -8
; # (val (tail Y))
  %30 = inttoptr i64 %29 to i64*
  %31 = load i64, i64* %30
; # (sym? (val (tail Y)))
  %32 = and i64 %31, 8
  %33 = icmp ne i64 %32, 0
  br label %$16
$16:
  %34 = phi i64 [%7, %$15], [%28, %$17] ; # N
  %35 = phi i1 [0, %$15], [%33, %$17] ; # ->
  br i1 %35, label %$18, label %$19
$18:
  %36 = phi i64 [%34, %$16] ; # N
; # (dbTouch Exe Y)
  call void @dbTouch(i64 %0, i64 %20)
  br label %$19
$19:
  %37 = phi i64 [%34, %$16], [%36, %$18] ; # N
; # (if (atom (val Y)) @ (let (V (save @) Z (cons (++ V) $Nil) R (sav...
; # (val Y)
  %38 = inttoptr i64 %20 to i64*
  %39 = load i64, i64* %38
; # (atom (val Y))
  %40 = and i64 %39, 15
  %41 = icmp ne i64 %40, 0
  br i1 %41, label %$20, label %$21
$20:
  %42 = phi i64 [%37, %$19] ; # N
  br label %$22
$21:
  %43 = phi i64 [%37, %$19] ; # N
; # (let (V (save @) Z (cons (++ V) $Nil) R (save Z)) (while (and (pa...
; # (save @)
  %44 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %45 = load i64, i64* %44
  %46 = alloca i64, i64 2, align 16
  %47 = ptrtoint i64* %46 to i64
  %48 = inttoptr i64 %47 to i64*
  store i64 %39, i64* %48
  %49 = add i64 %47, 8
  %50 = inttoptr i64 %49 to i64*
  store i64 %45, i64* %50
  %51 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %47, i64* %51
; # (++ V)
  %52 = inttoptr i64 %39 to i64*
  %53 = load i64, i64* %52
  %54 = getelementptr i64, i64* %52, i32 1
  %55 = load i64, i64* %54
; # (cons (++ V) $Nil)
  %56 = call i64 @cons(i64 %53, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (save Z)
  %57 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %58 = load i64, i64* %57
  %59 = alloca i64, i64 2, align 16
  %60 = ptrtoint i64* %59 to i64
  %61 = inttoptr i64 %60 to i64*
  store i64 %56, i64* %61
  %62 = add i64 %60, 8
  %63 = inttoptr i64 %62 to i64*
  store i64 %58, i64* %63
  %64 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %60, i64* %64
; # (while (and (pair V) (dec 'N)) (setq Z (set 2 Z (cons (++ V) $Nil...
  br label %$23
$23:
  %65 = phi i64 [%43, %$21], [%79, %$26] ; # N
  %66 = phi i64 [%55, %$21], [%85, %$26] ; # V
  %67 = phi i64 [%56, %$21], [%86, %$26] ; # Z
; # (and (pair V) (dec 'N))
; # (pair V)
  %68 = and i64 %66, 15
  %69 = icmp eq i64 %68, 0
  br i1 %69, label %$25, label %$24
$25:
  %70 = phi i64 [%65, %$23] ; # N
  %71 = phi i64 [%66, %$23] ; # V
  %72 = phi i64 [%67, %$23] ; # Z
; # (dec 'N)
  %73 = sub i64 %70, 1
  %74 = icmp ne i64 %73, 0
  br label %$24
$24:
  %75 = phi i64 [%65, %$23], [%73, %$25] ; # N
  %76 = phi i64 [%66, %$23], [%71, %$25] ; # V
  %77 = phi i64 [%67, %$23], [%72, %$25] ; # Z
  %78 = phi i1 [0, %$23], [%74, %$25] ; # ->
  br i1 %78, label %$26, label %$27
$26:
  %79 = phi i64 [%75, %$24] ; # N
  %80 = phi i64 [%76, %$24] ; # V
  %81 = phi i64 [%77, %$24] ; # Z
; # (set 2 Z (cons (++ V) $Nil))
; # (++ V)
  %82 = inttoptr i64 %80 to i64*
  %83 = load i64, i64* %82
  %84 = getelementptr i64, i64* %82, i32 1
  %85 = load i64, i64* %84
; # (cons (++ V) $Nil)
  %86 = call i64 @cons(i64 %83, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %87 = inttoptr i64 %81 to i64*
  %88 = getelementptr i64, i64* %87, i32 1
  store i64 %86, i64* %88
  br label %$23
$27:
  %89 = phi i64 [%75, %$24] ; # N
  %90 = phi i64 [%76, %$24] ; # V
  %91 = phi i64 [%77, %$24] ; # Z
; # (set Y V)
  %92 = inttoptr i64 %20 to i64*
  store i64 %90, i64* %92
; # (drop *Safe)
  %93 = inttoptr i64 %47 to i64*
  %94 = getelementptr i64, i64* %93, i32 1
  %95 = load i64, i64* %94
  %96 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %95, i64* %96
  br label %$22
$22:
  %97 = phi i64 [%42, %$20], [%89, %$27] ; # N
  %98 = phi i64 [%39, %$20], [%56, %$27] ; # ->
  br label %$4
$4:
  %99 = phi i64 [%6, %$2], [%97, %$22] ; # N
  %100 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%98, %$22] ; # ->
  ret i64 %100
}

define i64 @_Del(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (save (eval (++ X))) Var (save (needChkVar Ex...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (save (eval (++ X)))
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %17 = load i64, i64* %16
  %18 = alloca i64, i64 2, align 16
  %19 = ptrtoint i64* %18 to i64
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = add i64 %19, 8
  %22 = inttoptr i64 %21 to i64*
  store i64 %17, i64* %22
  %23 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %19, i64* %23
; # (++ X)
  %24 = inttoptr i64 %7 to i64*
  %25 = load i64, i64* %24
  %26 = getelementptr i64, i64* %24, i32 1
  %27 = load i64, i64* %26
; # (eval (++ X))
  %28 = and i64 %25, 6
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %$9, label %$8
$9:
  br label %$7
$8:
  %30 = and i64 %25, 8
  %31 = icmp ne i64 %30, 0
  br i1 %31, label %$11, label %$10
$11:
  %32 = inttoptr i64 %25 to i64*
  %33 = load i64, i64* %32
  br label %$7
$10:
  %34 = call i64 @evList(i64 %25)
  br label %$7
$7:
  %35 = phi i64 [%25, %$9], [%33, %$11], [%34, %$10] ; # ->
; # (needChkVar Exe (eval (++ X)))
  %36 = and i64 %35, 6
  %37 = icmp ne i64 %36, 0
  br i1 %37, label %$12, label %$13
$12:
  call void @varErr(i64 %0, i64 %35)
  unreachable
$13:
  %38 = icmp uge i64 %35, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %38, label %$15, label %$14
$15:
  %39 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %35
  br label %$14
$14:
  %40 = phi i1 [0, %$13], [%39, %$15] ; # ->
  br i1 %40, label %$16, label %$17
$16:
  call void @protErr(i64 %0, i64 %35)
  unreachable
$17:
; # (save (needChkVar Exe (eval (++ X))))
  %41 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %42 = load i64, i64* %41
  %43 = alloca i64, i64 2, align 16
  %44 = ptrtoint i64* %43 to i64
  %45 = inttoptr i64 %44 to i64*
  store i64 %35, i64* %45
  %46 = add i64 %44, 8
  %47 = inttoptr i64 %46 to i64*
  store i64 %42, i64* %47
  %48 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %44, i64* %48
; # (car X)
  %49 = inttoptr i64 %27 to i64*
  %50 = load i64, i64* %49
; # (eval (car X))
  %51 = and i64 %50, 6
  %52 = icmp ne i64 %51, 0
  br i1 %52, label %$20, label %$19
$20:
  br label %$18
$19:
  %53 = and i64 %50, 8
  %54 = icmp ne i64 %53, 0
  br i1 %54, label %$22, label %$21
$22:
  %55 = inttoptr i64 %50 to i64*
  %56 = load i64, i64* %55
  br label %$18
$21:
  %57 = call i64 @evList(i64 %50)
  br label %$18
$18:
  %58 = phi i64 [%50, %$20], [%56, %$22], [%57, %$21] ; # ->
; # (nil? (eval (car X)))
  %59 = icmp eq i64 %58, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
; # (when (and (sym? Var) (sym? (val (tail Var)))) (dbTouch Exe Var))...
; # (and (sym? Var) (sym? (val (tail Var))))
; # (sym? Var)
  %60 = and i64 %35, 8
  %61 = icmp ne i64 %60, 0
  br i1 %61, label %$24, label %$23
$24:
; # (tail Var)
  %62 = add i64 %35, -8
; # (val (tail Var))
  %63 = inttoptr i64 %62 to i64*
  %64 = load i64, i64* %63
; # (sym? (val (tail Var)))
  %65 = and i64 %64, 8
  %66 = icmp ne i64 %65, 0
  br label %$23
$23:
  %67 = phi i1 [0, %$18], [%66, %$24] ; # ->
  br i1 %67, label %$25, label %$26
$25:
; # (dbTouch Exe Var)
  call void @dbTouch(i64 %0, i64 %35)
  br label %$26
$26:
; # (let V (val Var) (loop (? (atom V) V) (let Z (++ V) (? (not (equa...
; # (val Var)
  %68 = inttoptr i64 %35 to i64*
  %69 = load i64, i64* %68
; # (loop (? (atom V) V) (let Z (++ V) (? (not (equal Y Z)) (let (P (...
  br label %$27
$27:
  %70 = phi i64 [%69, %$26], [%135, %$40] ; # V
; # (? (atom V) V)
; # (atom V)
  %71 = and i64 %70, 15
  %72 = icmp ne i64 %71, 0
  br i1 %72, label %$30, label %$28
$30:
  %73 = phi i64 [%70, %$27] ; # V
  br label %$29
$28:
  %74 = phi i64 [%70, %$27] ; # V
; # (let Z (++ V) (? (not (equal Y Z)) (let (P (cons Z $Nil) R P) (sa...
; # (++ V)
  %75 = inttoptr i64 %74 to i64*
  %76 = load i64, i64* %75
  %77 = getelementptr i64, i64* %75, i32 1
  %78 = load i64, i64* %77
; # (? (not (equal Y Z)) (let (P (cons Z $Nil) R P) (save R (loop (? ...
; # (equal Y Z)
  %79 = call i1 @equal(i64 %15, i64 %76)
; # (not (equal Y Z))
  %80 = icmp eq i1 %79, 0
  br i1 %80, label %$32, label %$31
$32:
  %81 = phi i64 [%78, %$28] ; # V
  %82 = phi i64 [%76, %$28] ; # Z
; # (let (P (cons Z $Nil) R P) (save R (loop (? (atom V)) (if (equal ...
; # (cons Z $Nil)
  %83 = call i64 @cons(i64 %82, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (save R (loop (? (atom V)) (if (equal Y (setq Z (++ V))) (? Flg) ...
  %84 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %85 = load i64, i64* %84
  %86 = alloca i64, i64 2, align 16
  %87 = ptrtoint i64* %86 to i64
  %88 = inttoptr i64 %87 to i64*
  store i64 %83, i64* %88
  %89 = add i64 %87, 8
  %90 = inttoptr i64 %89 to i64*
  store i64 %85, i64* %90
  %91 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %87, i64* %91
; # (loop (? (atom V)) (if (equal Y (setq Z (++ V))) (? Flg) (setq P ...
  br label %$33
$33:
  %92 = phi i64 [%81, %$32], [%117, %$38] ; # V
  %93 = phi i64 [%82, %$32], [%118, %$38] ; # Z
  %94 = phi i64 [%83, %$32], [%119, %$38] ; # P
; # (? (atom V))
; # (atom V)
  %95 = and i64 %92, 15
  %96 = icmp ne i64 %95, 0
  br i1 %96, label %$35, label %$34
$34:
  %97 = phi i64 [%92, %$33] ; # V
  %98 = phi i64 [%93, %$33] ; # Z
  %99 = phi i64 [%94, %$33] ; # P
; # (if (equal Y (setq Z (++ V))) (? Flg) (setq P (set 2 P (cons Z $N...
; # (++ V)
  %100 = inttoptr i64 %97 to i64*
  %101 = load i64, i64* %100
  %102 = getelementptr i64, i64* %100, i32 1
  %103 = load i64, i64* %102
; # (equal Y (setq Z (++ V)))
  %104 = call i1 @equal(i64 %15, i64 %101)
  br i1 %104, label %$36, label %$37
$36:
  %105 = phi i64 [%103, %$34] ; # V
  %106 = phi i64 [%101, %$34] ; # Z
  %107 = phi i64 [%99, %$34] ; # P
; # (? Flg)
  br i1 %59, label %$35, label %$39
$39:
  %108 = phi i64 [%105, %$36] ; # V
  %109 = phi i64 [%106, %$36] ; # Z
  %110 = phi i64 [%107, %$36] ; # P
  br label %$38
$37:
  %111 = phi i64 [%103, %$34] ; # V
  %112 = phi i64 [%101, %$34] ; # Z
  %113 = phi i64 [%99, %$34] ; # P
; # (set 2 P (cons Z $Nil))
; # (cons Z $Nil)
  %114 = call i64 @cons(i64 %112, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %115 = inttoptr i64 %113 to i64*
  %116 = getelementptr i64, i64* %115, i32 1
  store i64 %114, i64* %116
  br label %$38
$38:
  %117 = phi i64 [%108, %$39], [%111, %$37] ; # V
  %118 = phi i64 [%109, %$39], [%112, %$37] ; # Z
  %119 = phi i64 [%110, %$39], [%114, %$37] ; # P
  br label %$33
$35:
  %120 = phi i64 [%92, %$33], [%105, %$36] ; # V
  %121 = phi i64 [%93, %$33], [%106, %$36] ; # Z
  %122 = phi i64 [%94, %$33], [%107, %$36] ; # P
  %123 = phi i64 [0, %$33], [0, %$36] ; # ->
; # drop
  %124 = inttoptr i64 %87 to i64*
  %125 = getelementptr i64, i64* %124, i32 1
  %126 = load i64, i64* %125
  %127 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %126, i64* %127
; # (set 2 P V Var R)
  %128 = inttoptr i64 %122 to i64*
  %129 = getelementptr i64, i64* %128, i32 1
  store i64 %120, i64* %129
  %130 = inttoptr i64 %35 to i64*
  store i64 %83, i64* %130
  br label %$29
$31:
  %131 = phi i64 [%78, %$28] ; # V
  %132 = phi i64 [%76, %$28] ; # Z
; # (set Var V)
  %133 = inttoptr i64 %35 to i64*
  store i64 %131, i64* %133
; # (? Flg V)
  br i1 %59, label %$41, label %$40
$41:
  %134 = phi i64 [%131, %$31] ; # V
  br label %$29
$40:
  %135 = phi i64 [%131, %$31] ; # V
  br label %$27
$29:
  %136 = phi i64 [%73, %$30], [%120, %$35], [%134, %$41] ; # V
  %137 = phi i64 [%73, %$30], [%83, %$35], [%134, %$41] ; # ->
; # (drop *Safe)
  %138 = inttoptr i64 %19 to i64*
  %139 = getelementptr i64, i64* %138, i32 1
  %140 = load i64, i64* %139
  %141 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %140, i64* %141
  ret i64 %137
}

define i64 @_Queue(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (save (needChkVar Exe (eval (++ X))))) (when ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (needChkVar Exe (eval (++ X)))
  %16 = and i64 %15, 6
  %17 = icmp ne i64 %16, 0
  br i1 %17, label %$7, label %$8
$7:
  call void @varErr(i64 %0, i64 %15)
  unreachable
$8:
  %18 = icmp uge i64 %15, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %18, label %$10, label %$9
$10:
  %19 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %15
  br label %$9
$9:
  %20 = phi i1 [0, %$8], [%19, %$10] ; # ->
  br i1 %20, label %$11, label %$12
$11:
  call void @protErr(i64 %0, i64 %15)
  unreachable
$12:
; # (save (needChkVar Exe (eval (++ X))))
  %21 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %22 = load i64, i64* %21
  %23 = alloca i64, i64 2, align 16
  %24 = ptrtoint i64* %23 to i64
  %25 = inttoptr i64 %24 to i64*
  store i64 %15, i64* %25
  %26 = add i64 %24, 8
  %27 = inttoptr i64 %26 to i64*
  store i64 %22, i64* %27
  %28 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %24, i64* %28
; # (when (and (sym? Y) (sym? (val (tail Y)))) (dbTouch Exe Y))
; # (and (sym? Y) (sym? (val (tail Y))))
; # (sym? Y)
  %29 = and i64 %15, 8
  %30 = icmp ne i64 %29, 0
  br i1 %30, label %$14, label %$13
$14:
; # (tail Y)
  %31 = add i64 %15, -8
; # (val (tail Y))
  %32 = inttoptr i64 %31 to i64*
  %33 = load i64, i64* %32
; # (sym? (val (tail Y)))
  %34 = and i64 %33, 8
  %35 = icmp ne i64 %34, 0
  br label %$13
$13:
  %36 = phi i1 [0, %$12], [%35, %$14] ; # ->
  br i1 %36, label %$15, label %$16
$15:
; # (dbTouch Exe Y)
  call void @dbTouch(i64 %0, i64 %15)
  br label %$16
$16:
; # (let (Z (eval (car X)) L (cons Z $Nil) V (val Y)) (if (atom V) (s...
; # (car X)
  %37 = inttoptr i64 %7 to i64*
  %38 = load i64, i64* %37
; # (eval (car X))
  %39 = and i64 %38, 6
  %40 = icmp ne i64 %39, 0
  br i1 %40, label %$19, label %$18
$19:
  br label %$17
$18:
  %41 = and i64 %38, 8
  %42 = icmp ne i64 %41, 0
  br i1 %42, label %$21, label %$20
$21:
  %43 = inttoptr i64 %38 to i64*
  %44 = load i64, i64* %43
  br label %$17
$20:
  %45 = call i64 @evList(i64 %38)
  br label %$17
$17:
  %46 = phi i64 [%38, %$19], [%44, %$21], [%45, %$20] ; # ->
; # (cons Z $Nil)
  %47 = call i64 @cons(i64 %46, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (val Y)
  %48 = inttoptr i64 %15 to i64*
  %49 = load i64, i64* %48
; # (if (atom V) (set Y L) (while (pair (cdr V)) (shift V)) (set 2 V ...
; # (atom V)
  %50 = and i64 %49, 15
  %51 = icmp ne i64 %50, 0
  br i1 %51, label %$22, label %$23
$22:
  %52 = phi i64 [%49, %$17] ; # V
; # (set Y L)
  %53 = inttoptr i64 %15 to i64*
  store i64 %47, i64* %53
  br label %$24
$23:
  %54 = phi i64 [%49, %$17] ; # V
; # (while (pair (cdr V)) (shift V))
  br label %$25
$25:
  %55 = phi i64 [%54, %$23], [%64, %$26] ; # V
; # (cdr V)
  %56 = inttoptr i64 %55 to i64*
  %57 = getelementptr i64, i64* %56, i32 1
  %58 = load i64, i64* %57
; # (pair (cdr V))
  %59 = and i64 %58, 15
  %60 = icmp eq i64 %59, 0
  br i1 %60, label %$26, label %$27
$26:
  %61 = phi i64 [%55, %$25] ; # V
; # (shift V)
  %62 = inttoptr i64 %61 to i64*
  %63 = getelementptr i64, i64* %62, i32 1
  %64 = load i64, i64* %63
  br label %$25
$27:
  %65 = phi i64 [%55, %$25] ; # V
; # (set 2 V L)
  %66 = inttoptr i64 %65 to i64*
  %67 = getelementptr i64, i64* %66, i32 1
  store i64 %47, i64* %67
  br label %$24
$24:
  %68 = phi i64 [%52, %$22], [%65, %$27] ; # V
  %69 = phi i64 [%47, %$22], [%47, %$27] ; # ->
; # (drop *Safe)
  %70 = inttoptr i64 %24 to i64*
  %71 = getelementptr i64, i64* %70, i32 1
  %72 = load i64, i64* %71
  %73 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %72, i64* %73
  ret i64 %46
}

define i64 @_Fifo(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (save (needChkVar Exe (eval (++ X))))) (when ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (needChkVar Exe (eval (++ X)))
  %16 = and i64 %15, 6
  %17 = icmp ne i64 %16, 0
  br i1 %17, label %$7, label %$8
$7:
  call void @varErr(i64 %0, i64 %15)
  unreachable
$8:
  %18 = icmp uge i64 %15, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %18, label %$10, label %$9
$10:
  %19 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %15
  br label %$9
$9:
  %20 = phi i1 [0, %$8], [%19, %$10] ; # ->
  br i1 %20, label %$11, label %$12
$11:
  call void @protErr(i64 %0, i64 %15)
  unreachable
$12:
; # (save (needChkVar Exe (eval (++ X))))
  %21 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %22 = load i64, i64* %21
  %23 = alloca i64, i64 2, align 16
  %24 = ptrtoint i64* %23 to i64
  %25 = inttoptr i64 %24 to i64*
  store i64 %15, i64* %25
  %26 = add i64 %24, 8
  %27 = inttoptr i64 %26 to i64*
  store i64 %22, i64* %27
  %28 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %24, i64* %28
; # (when (and (sym? Y) (sym? (val (tail Y)))) (dbTouch Exe Y))
; # (and (sym? Y) (sym? (val (tail Y))))
; # (sym? Y)
  %29 = and i64 %15, 8
  %30 = icmp ne i64 %29, 0
  br i1 %30, label %$14, label %$13
$14:
  %31 = phi i64 [%7, %$12] ; # X
; # (tail Y)
  %32 = add i64 %15, -8
; # (val (tail Y))
  %33 = inttoptr i64 %32 to i64*
  %34 = load i64, i64* %33
; # (sym? (val (tail Y)))
  %35 = and i64 %34, 8
  %36 = icmp ne i64 %35, 0
  br label %$13
$13:
  %37 = phi i64 [%7, %$12], [%31, %$14] ; # X
  %38 = phi i1 [0, %$12], [%36, %$14] ; # ->
  br i1 %38, label %$15, label %$16
$15:
  %39 = phi i64 [%37, %$13] ; # X
; # (dbTouch Exe Y)
  call void @dbTouch(i64 %0, i64 %15)
  br label %$16
$16:
  %40 = phi i64 [%37, %$13], [%39, %$15] ; # X
; # (let V (val Y) (cond ((pair X) (let E (eval (car X)) (if (pair V)...
; # (val Y)
  %41 = inttoptr i64 %15 to i64*
  %42 = load i64, i64* %41
; # (cond ((pair X) (let E (eval (car X)) (if (pair V) (setq V (set 2...
; # (pair X)
  %43 = and i64 %40, 15
  %44 = icmp eq i64 %43, 0
  br i1 %44, label %$19, label %$18
$19:
  %45 = phi i64 [%40, %$16] ; # X
  %46 = phi i64 [%42, %$16] ; # V
; # (let E (eval (car X)) (if (pair V) (setq V (set 2 V (cons E (cdr ...
; # (car X)
  %47 = inttoptr i64 %45 to i64*
  %48 = load i64, i64* %47
; # (eval (car X))
  %49 = and i64 %48, 6
  %50 = icmp ne i64 %49, 0
  br i1 %50, label %$22, label %$21
$22:
  br label %$20
$21:
  %51 = and i64 %48, 8
  %52 = icmp ne i64 %51, 0
  br i1 %52, label %$24, label %$23
$24:
  %53 = inttoptr i64 %48 to i64*
  %54 = load i64, i64* %53
  br label %$20
$23:
  %55 = call i64 @evList(i64 %48)
  br label %$20
$20:
  %56 = phi i64 [%48, %$22], [%54, %$24], [%55, %$23] ; # ->
; # (if (pair V) (setq V (set 2 V (cons E (cdr V)))) (setq V (cons E ...
; # (pair V)
  %57 = and i64 %46, 15
  %58 = icmp eq i64 %57, 0
  br i1 %58, label %$25, label %$26
$25:
  %59 = phi i64 [%45, %$20] ; # X
  %60 = phi i64 [%46, %$20] ; # V
  %61 = phi i64 [%56, %$20] ; # E
; # (set 2 V (cons E (cdr V)))
; # (cdr V)
  %62 = inttoptr i64 %60 to i64*
  %63 = getelementptr i64, i64* %62, i32 1
  %64 = load i64, i64* %63
; # (cons E (cdr V))
  %65 = call i64 @cons(i64 %61, i64 %64)
  %66 = inttoptr i64 %60 to i64*
  %67 = getelementptr i64, i64* %66, i32 1
  store i64 %65, i64* %67
  br label %$27
$26:
  %68 = phi i64 [%45, %$20] ; # X
  %69 = phi i64 [%46, %$20] ; # V
  %70 = phi i64 [%56, %$20] ; # E
; # (cons E -ZERO)
  %71 = call i64 @cons(i64 %70, i64 10)
; # (set 2 V V)
  %72 = inttoptr i64 %71 to i64*
  %73 = getelementptr i64, i64* %72, i32 1
  store i64 %71, i64* %73
  br label %$27
$27:
  %74 = phi i64 [%59, %$25], [%68, %$26] ; # X
  %75 = phi i64 [%65, %$25], [%71, %$26] ; # V
  %76 = phi i64 [%61, %$25], [%70, %$26] ; # E
  %77 = phi i64 [%65, %$25], [%71, %$26] ; # ->
; # (while (pair (shift X)) (setq V (set 2 V (cons (setq E (eval (car...
  br label %$28
$28:
  %78 = phi i64 [%74, %$27], [%86, %$31] ; # X
  %79 = phi i64 [%75, %$27], [%102, %$31] ; # V
  %80 = phi i64 [%76, %$27], [%98, %$31] ; # E
; # (shift X)
  %81 = inttoptr i64 %78 to i64*
  %82 = getelementptr i64, i64* %81, i32 1
  %83 = load i64, i64* %82
; # (pair (shift X))
  %84 = and i64 %83, 15
  %85 = icmp eq i64 %84, 0
  br i1 %85, label %$29, label %$30
$29:
  %86 = phi i64 [%83, %$28] ; # X
  %87 = phi i64 [%79, %$28] ; # V
  %88 = phi i64 [%80, %$28] ; # E
; # (set 2 V (cons (setq E (eval (car X))) (cdr V)))
; # (car X)
  %89 = inttoptr i64 %86 to i64*
  %90 = load i64, i64* %89
; # (eval (car X))
  %91 = and i64 %90, 6
  %92 = icmp ne i64 %91, 0
  br i1 %92, label %$33, label %$32
$33:
  br label %$31
$32:
  %93 = and i64 %90, 8
  %94 = icmp ne i64 %93, 0
  br i1 %94, label %$35, label %$34
$35:
  %95 = inttoptr i64 %90 to i64*
  %96 = load i64, i64* %95
  br label %$31
$34:
  %97 = call i64 @evList(i64 %90)
  br label %$31
$31:
  %98 = phi i64 [%90, %$33], [%96, %$35], [%97, %$34] ; # ->
; # (cdr V)
  %99 = inttoptr i64 %87 to i64*
  %100 = getelementptr i64, i64* %99, i32 1
  %101 = load i64, i64* %100
; # (cons (setq E (eval (car X))) (cdr V))
  %102 = call i64 @cons(i64 %98, i64 %101)
  %103 = inttoptr i64 %87 to i64*
  %104 = getelementptr i64, i64* %103, i32 1
  store i64 %102, i64* %104
  br label %$28
$30:
  %105 = phi i64 [%83, %$28] ; # X
  %106 = phi i64 [%79, %$28] ; # V
  %107 = phi i64 [%80, %$28] ; # E
; # (set Y V)
  %108 = inttoptr i64 %15 to i64*
  store i64 %106, i64* %108
  br label %$17
$18:
  %109 = phi i64 [%40, %$16] ; # X
  %110 = phi i64 [%42, %$16] ; # V
; # (atom V)
  %111 = and i64 %110, 15
  %112 = icmp ne i64 %111, 0
  br i1 %112, label %$37, label %$36
$37:
  %113 = phi i64 [%109, %$18] ; # X
  %114 = phi i64 [%110, %$18] ; # V
  br label %$17
$36:
  %115 = phi i64 [%109, %$18] ; # X
  %116 = phi i64 [%110, %$18] ; # V
; # (cdr V)
  %117 = inttoptr i64 %116 to i64*
  %118 = getelementptr i64, i64* %117, i32 1
  %119 = load i64, i64* %118
; # (== (cdr V) V)
  %120 = icmp eq i64 %119, %116
  br i1 %120, label %$39, label %$38
$39:
  %121 = phi i64 [%115, %$36] ; # X
  %122 = phi i64 [%116, %$36] ; # V
; # (set Y $Nil)
  %123 = inttoptr i64 %15 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %123
; # (car V)
  %124 = inttoptr i64 %122 to i64*
  %125 = load i64, i64* %124
  br label %$17
$38:
  %126 = phi i64 [%115, %$36] ; # X
  %127 = phi i64 [%116, %$36] ; # V
; # (set 2 V (cdr @))
; # (cdr @)
  %128 = inttoptr i64 %119 to i64*
  %129 = getelementptr i64, i64* %128, i32 1
  %130 = load i64, i64* %129
  %131 = inttoptr i64 %127 to i64*
  %132 = getelementptr i64, i64* %131, i32 1
  store i64 %130, i64* %132
; # (car @)
  %133 = inttoptr i64 %119 to i64*
  %134 = load i64, i64* %133
  br label %$17
$17:
  %135 = phi i64 [%105, %$30], [%113, %$37], [%121, %$39], [%126, %$38] ; # X
  %136 = phi i64 [%106, %$30], [%114, %$37], [%122, %$39], [%127, %$38] ; # V
  %137 = phi i64 [%107, %$30], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$37], [%125, %$39], [%134, %$38] ; # ->
; # (drop *Safe)
  %138 = inttoptr i64 %24 to i64*
  %139 = getelementptr i64, i64* %138, i32 1
  %140 = load i64, i64* %139
  %141 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %140, i64* %141
  ret i64 %137
}

define i64 @_Rid(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (save (needChkVar Exe (eval (++ X))))) (when ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (needChkVar Exe (eval (++ X)))
  %16 = and i64 %15, 6
  %17 = icmp ne i64 %16, 0
  br i1 %17, label %$7, label %$8
$7:
  call void @varErr(i64 %0, i64 %15)
  unreachable
$8:
  %18 = icmp uge i64 %15, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %18, label %$10, label %$9
$10:
  %19 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %15
  br label %$9
$9:
  %20 = phi i1 [0, %$8], [%19, %$10] ; # ->
  br i1 %20, label %$11, label %$12
$11:
  call void @protErr(i64 %0, i64 %15)
  unreachable
$12:
; # (save (needChkVar Exe (eval (++ X))))
  %21 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %22 = load i64, i64* %21
  %23 = alloca i64, i64 2, align 16
  %24 = ptrtoint i64* %23 to i64
  %25 = inttoptr i64 %24 to i64*
  store i64 %15, i64* %25
  %26 = add i64 %24, 8
  %27 = inttoptr i64 %26 to i64*
  store i64 %22, i64* %27
  %28 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %24, i64* %28
; # (when (and (sym? Y) (sym? (val (tail Y)))) (dbTouch Exe Y))
; # (and (sym? Y) (sym? (val (tail Y))))
; # (sym? Y)
  %29 = and i64 %15, 8
  %30 = icmp ne i64 %29, 0
  br i1 %30, label %$14, label %$13
$14:
  %31 = phi i64 [%7, %$12] ; # X
; # (tail Y)
  %32 = add i64 %15, -8
; # (val (tail Y))
  %33 = inttoptr i64 %32 to i64*
  %34 = load i64, i64* %33
; # (sym? (val (tail Y)))
  %35 = and i64 %34, 8
  %36 = icmp ne i64 %35, 0
  br label %$13
$13:
  %37 = phi i64 [%7, %$12], [%31, %$14] ; # X
  %38 = phi i1 [0, %$12], [%36, %$14] ; # ->
  br i1 %38, label %$15, label %$16
$15:
  %39 = phi i64 [%37, %$13] ; # X
; # (dbTouch Exe Y)
  call void @dbTouch(i64 %0, i64 %15)
  br label %$16
$16:
  %40 = phi i64 [%37, %$13], [%39, %$15] ; # X
; # (car X)
  %41 = inttoptr i64 %40 to i64*
  %42 = load i64, i64* %41
; # (eval (car X))
  %43 = and i64 %42, 6
  %44 = icmp ne i64 %43, 0
  br i1 %44, label %$19, label %$18
$19:
  br label %$17
$18:
  %45 = and i64 %42, 8
  %46 = icmp ne i64 %45, 0
  br i1 %46, label %$21, label %$20
$21:
  %47 = inttoptr i64 %42 to i64*
  %48 = load i64, i64* %47
  br label %$17
$20:
  %49 = call i64 @evList(i64 %42)
  br label %$17
$17:
  %50 = phi i64 [%42, %$19], [%48, %$21], [%49, %$20] ; # ->
; # (let V (val Y) (cond ((pair V) (let (Z V L (cdr Z)) (loop (? (ato...
; # (val Y)
  %51 = inttoptr i64 %15 to i64*
  %52 = load i64, i64* %51
; # (cond ((pair V) (let (Z V L (cdr Z)) (loop (? (atom L) (when (equ...
; # (pair V)
  %53 = and i64 %52, 15
  %54 = icmp eq i64 %53, 0
  br i1 %54, label %$24, label %$23
$24:
  %55 = phi i64 [%50, %$17] ; # X
; # (let (Z V L (cdr Z)) (loop (? (atom L) (when (equal L X) (set 2 Z...
; # (cdr Z)
  %56 = inttoptr i64 %52 to i64*
  %57 = getelementptr i64, i64* %56, i32 1
  %58 = load i64, i64* %57
; # (loop (? (atom L) (when (equal L X) (set 2 Z $Nil)) (if (equal (c...
  br label %$25
$25:
  %59 = phi i64 [%55, %$24], [%150, %$43] ; # X
  %60 = phi i64 [%52, %$24], [%151, %$43] ; # Z
  %61 = phi i64 [%58, %$24], [%152, %$43] ; # L
; # (? (atom L) (when (equal L X) (set 2 Z $Nil)) (if (equal (car V) ...
; # (atom L)
  %62 = and i64 %61, 15
  %63 = icmp ne i64 %62, 0
  br i1 %63, label %$28, label %$26
$28:
  %64 = phi i64 [%59, %$25] ; # X
  %65 = phi i64 [%60, %$25] ; # Z
  %66 = phi i64 [%61, %$25] ; # L
; # (when (equal L X) (set 2 Z $Nil))
; # (equal L X)
  %67 = call i1 @equal(i64 %66, i64 %64)
  br i1 %67, label %$29, label %$30
$29:
  %68 = phi i64 [%64, %$28] ; # X
  %69 = phi i64 [%65, %$28] ; # Z
  %70 = phi i64 [%66, %$28] ; # L
; # (set 2 Z $Nil)
  %71 = inttoptr i64 %69 to i64*
  %72 = getelementptr i64, i64* %71, i32 1
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %72
  br label %$30
$30:
  %73 = phi i64 [%64, %$28], [%68, %$29] ; # X
  %74 = phi i64 [%65, %$28], [%69, %$29] ; # Z
  %75 = phi i64 [%66, %$28], [%70, %$29] ; # L
; # (if (equal (car V) X) (set Y (cdr V)) V)
; # (car V)
  %76 = inttoptr i64 %52 to i64*
  %77 = load i64, i64* %76
; # (equal (car V) X)
  %78 = call i1 @equal(i64 %77, i64 %73)
  br i1 %78, label %$31, label %$32
$31:
  %79 = phi i64 [%73, %$30] ; # X
  %80 = phi i64 [%74, %$30] ; # Z
  %81 = phi i64 [%75, %$30] ; # L
; # (set Y (cdr V))
; # (cdr V)
  %82 = inttoptr i64 %52 to i64*
  %83 = getelementptr i64, i64* %82, i32 1
  %84 = load i64, i64* %83
  %85 = inttoptr i64 %15 to i64*
  store i64 %84, i64* %85
  br label %$33
$32:
  %86 = phi i64 [%73, %$30] ; # X
  %87 = phi i64 [%74, %$30] ; # Z
  %88 = phi i64 [%75, %$30] ; # L
  br label %$33
$33:
  %89 = phi i64 [%79, %$31], [%86, %$32] ; # X
  %90 = phi i64 [%80, %$31], [%87, %$32] ; # Z
  %91 = phi i64 [%81, %$31], [%88, %$32] ; # L
  %92 = phi i64 [%84, %$31], [%52, %$32] ; # ->
  br label %$27
$26:
  %93 = phi i64 [%59, %$25] ; # X
  %94 = phi i64 [%60, %$25] ; # Z
  %95 = phi i64 [%61, %$25] ; # L
; # (? (== L V) (nond ((equal (car L) X) V) ((== L Z) (set 2 Z (cdr L...
; # (== L V)
  %96 = icmp eq i64 %95, %52
  br i1 %96, label %$35, label %$34
$35:
  %97 = phi i64 [%93, %$26] ; # X
  %98 = phi i64 [%94, %$26] ; # Z
  %99 = phi i64 [%95, %$26] ; # L
; # (nond ((equal (car L) X) V) ((== L Z) (set 2 Z (cdr L)) (set Y Z)...
; # (car L)
  %100 = inttoptr i64 %99 to i64*
  %101 = load i64, i64* %100
; # (equal (car L) X)
  %102 = call i1 @equal(i64 %101, i64 %97)
  br i1 %102, label %$37, label %$38
$38:
  %103 = phi i64 [%97, %$35] ; # X
  %104 = phi i64 [%98, %$35] ; # Z
  %105 = phi i64 [%99, %$35] ; # L
  br label %$36
$37:
  %106 = phi i64 [%97, %$35] ; # X
  %107 = phi i64 [%98, %$35] ; # Z
  %108 = phi i64 [%99, %$35] ; # L
; # (== L Z)
  %109 = icmp eq i64 %108, %107
  br i1 %109, label %$39, label %$40
$40:
  %110 = phi i64 [%106, %$37] ; # X
  %111 = phi i64 [%107, %$37] ; # Z
  %112 = phi i64 [%108, %$37] ; # L
; # (set 2 Z (cdr L))
; # (cdr L)
  %113 = inttoptr i64 %112 to i64*
  %114 = getelementptr i64, i64* %113, i32 1
  %115 = load i64, i64* %114
  %116 = inttoptr i64 %111 to i64*
  %117 = getelementptr i64, i64* %116, i32 1
  store i64 %115, i64* %117
; # (set Y Z)
  %118 = inttoptr i64 %15 to i64*
  store i64 %111, i64* %118
  br label %$36
$39:
  %119 = phi i64 [%106, %$37] ; # X
  %120 = phi i64 [%107, %$37] ; # Z
  %121 = phi i64 [%108, %$37] ; # L
; # (set Y $Nil)
  %122 = inttoptr i64 %15 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %122
  br label %$36
$36:
  %123 = phi i64 [%103, %$38], [%110, %$40], [%119, %$39] ; # X
  %124 = phi i64 [%104, %$38], [%111, %$40], [%120, %$39] ; # Z
  %125 = phi i64 [%105, %$38], [%112, %$40], [%121, %$39] ; # L
  %126 = phi i64 [%52, %$38], [%111, %$40], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$39] ; # ->
  br label %$27
$34:
  %127 = phi i64 [%93, %$26] ; # X
  %128 = phi i64 [%94, %$26] ; # Z
  %129 = phi i64 [%95, %$26] ; # L
; # (if (equal (car L) X) (set 2 Z (shift L)) (setq L (cdr (shift Z))...
; # (car L)
  %130 = inttoptr i64 %129 to i64*
  %131 = load i64, i64* %130
; # (equal (car L) X)
  %132 = call i1 @equal(i64 %131, i64 %127)
  br i1 %132, label %$41, label %$42
$41:
  %133 = phi i64 [%127, %$34] ; # X
  %134 = phi i64 [%128, %$34] ; # Z
  %135 = phi i64 [%129, %$34] ; # L
; # (set 2 Z (shift L))
; # (shift L)
  %136 = inttoptr i64 %135 to i64*
  %137 = getelementptr i64, i64* %136, i32 1
  %138 = load i64, i64* %137
  %139 = inttoptr i64 %134 to i64*
  %140 = getelementptr i64, i64* %139, i32 1
  store i64 %138, i64* %140
  br label %$43
$42:
  %141 = phi i64 [%127, %$34] ; # X
  %142 = phi i64 [%128, %$34] ; # Z
  %143 = phi i64 [%129, %$34] ; # L
; # (shift Z)
  %144 = inttoptr i64 %142 to i64*
  %145 = getelementptr i64, i64* %144, i32 1
  %146 = load i64, i64* %145
; # (cdr (shift Z))
  %147 = inttoptr i64 %146 to i64*
  %148 = getelementptr i64, i64* %147, i32 1
  %149 = load i64, i64* %148
  br label %$43
$43:
  %150 = phi i64 [%133, %$41], [%141, %$42] ; # X
  %151 = phi i64 [%134, %$41], [%146, %$42] ; # Z
  %152 = phi i64 [%138, %$41], [%149, %$42] ; # L
  %153 = phi i64 [%138, %$41], [%149, %$42] ; # ->
  br label %$25
$27:
  %154 = phi i64 [%89, %$33], [%123, %$36] ; # X
  %155 = phi i64 [%90, %$33], [%124, %$36] ; # Z
  %156 = phi i64 [%91, %$33], [%125, %$36] ; # L
  %157 = phi i64 [%92, %$33], [%126, %$36] ; # ->
  br label %$22
$23:
  %158 = phi i64 [%50, %$17] ; # X
; # (equal V X)
  %159 = call i1 @equal(i64 %52, i64 %158)
  br i1 %159, label %$45, label %$44
$45:
  %160 = phi i64 [%158, %$23] ; # X
; # (set Y $Nil)
  %161 = inttoptr i64 %15 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %161
  br label %$22
$44:
  %162 = phi i64 [%158, %$23] ; # X
  br label %$22
$22:
  %163 = phi i64 [%154, %$27], [%160, %$45], [%162, %$44] ; # X
  %164 = phi i64 [%157, %$27], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$45], [%52, %$44] ; # ->
; # (drop *Safe)
  %165 = inttoptr i64 %24 to i64*
  %166 = getelementptr i64, i64* %165, i32 1
  %167 = load i64, i64* %166
  %168 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %167, i64* %168
  ret i64 %164
}

define i64 @_Enum(i64) align 8 {
$1:
; # (let (X (cdr Exe) Var (save (needChkVar Exe (eval (++ X)))) Cnt T...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (needChkVar Exe (eval (++ X)))
  %16 = and i64 %15, 6
  %17 = icmp ne i64 %16, 0
  br i1 %17, label %$7, label %$8
$7:
  call void @varErr(i64 %0, i64 %15)
  unreachable
$8:
  %18 = icmp uge i64 %15, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %18, label %$10, label %$9
$10:
  %19 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %15
  br label %$9
$9:
  %20 = phi i1 [0, %$8], [%19, %$10] ; # ->
  br i1 %20, label %$11, label %$12
$11:
  call void @protErr(i64 %0, i64 %15)
  unreachable
$12:
; # (save (needChkVar Exe (eval (++ X))))
  %21 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %22 = load i64, i64* %21
  %23 = alloca i64, i64 2, align 16
  %24 = ptrtoint i64* %23 to i64
  %25 = inttoptr i64 %24 to i64*
  store i64 %15, i64* %25
  %26 = add i64 %24, 8
  %27 = inttoptr i64 %26 to i64*
  store i64 %22, i64* %27
  %28 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %24, i64* %28
; # (if (pair X) (loop (? (le0 (setq Cnt (evCnt Exe X))) $Nil) (let P...
; # (pair X)
  %29 = and i64 %7, 15
  %30 = icmp eq i64 %29, 0
  br i1 %30, label %$13, label %$14
$13:
  %31 = phi i64 [%7, %$12] ; # X
  %32 = phi i64 [%15, %$12] ; # Var
; # (loop (? (le0 (setq Cnt (evCnt Exe X))) $Nil) (let P (val Var) (l...
  br label %$16
$16:
  %33 = phi i64 [%31, %$13], [%179, %$40] ; # X
  %34 = phi i64 [%32, %$13], [%180, %$40] ; # Var
; # (? (le0 (setq Cnt (evCnt Exe X))) $Nil)
; # (evCnt Exe X)
  %35 = call i64 @evCnt(i64 %0, i64 %33)
; # (le0 (setq Cnt (evCnt Exe X)))
  %36 = icmp sle i64 %35, 0
  br i1 %36, label %$19, label %$17
$19:
  %37 = phi i64 [%33, %$16] ; # X
  %38 = phi i64 [%34, %$16] ; # Var
  %39 = phi i64 [%35, %$16] ; # Cnt
  br label %$18
$17:
  %40 = phi i64 [%33, %$16] ; # X
  %41 = phi i64 [%34, %$16] ; # Var
  %42 = phi i64 [%35, %$16] ; # Cnt
; # (let P (val Var) (loop (let N (shr Cnt 1) (? (=0 N) (setq Var (if...
; # (val Var)
  %43 = inttoptr i64 %41 to i64*
  %44 = load i64, i64* %43
; # (loop (let N (shr Cnt 1) (? (=0 N) (setq Var (if (pair P) @ (set ...
  br label %$20
$20:
  %45 = phi i64 [%40, %$17], [%161, %$29] ; # X
  %46 = phi i64 [%41, %$17], [%162, %$29] ; # Var
  %47 = phi i64 [%42, %$17], [%49, %$29] ; # Cnt
  %48 = phi i64 [%44, %$17], [%164, %$29] ; # P
; # (let N (shr Cnt 1) (? (=0 N) (setq Var (if (pair P) @ (set Var (c...
; # (shr Cnt 1)
  %49 = lshr i64 %47, 1
; # (? (=0 N) (setq Var (if (pair P) @ (set Var (cons $Nil $Nil)))))
; # (=0 N)
  %50 = icmp eq i64 %49, 0
  br i1 %50, label %$23, label %$21
$23:
  %51 = phi i64 [%45, %$20] ; # X
  %52 = phi i64 [%46, %$20] ; # Var
  %53 = phi i64 [%47, %$20] ; # Cnt
  %54 = phi i64 [%48, %$20] ; # P
; # (if (pair P) @ (set Var (cons $Nil $Nil)))
; # (pair P)
  %55 = and i64 %54, 15
  %56 = icmp eq i64 %55, 0
  br i1 %56, label %$24, label %$25
$24:
  %57 = phi i64 [%51, %$23] ; # X
  %58 = phi i64 [%52, %$23] ; # Var
  %59 = phi i64 [%53, %$23] ; # Cnt
  %60 = phi i64 [%54, %$23] ; # P
  br label %$26
$25:
  %61 = phi i64 [%51, %$23] ; # X
  %62 = phi i64 [%52, %$23] ; # Var
  %63 = phi i64 [%53, %$23] ; # Cnt
  %64 = phi i64 [%54, %$23] ; # P
; # (set Var (cons $Nil $Nil))
; # (cons $Nil $Nil)
  %65 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %66 = inttoptr i64 %62 to i64*
  store i64 %65, i64* %66
  br label %$26
$26:
  %67 = phi i64 [%57, %$24], [%61, %$25] ; # X
  %68 = phi i64 [%58, %$24], [%62, %$25] ; # Var
  %69 = phi i64 [%59, %$24], [%63, %$25] ; # Cnt
  %70 = phi i64 [%60, %$24], [%64, %$25] ; # P
  %71 = phi i64 [%54, %$24], [%65, %$25] ; # ->
  br label %$22
$21:
  %72 = phi i64 [%45, %$20] ; # X
  %73 = phi i64 [%46, %$20] ; # Var
  %74 = phi i64 [%47, %$20] ; # Cnt
  %75 = phi i64 [%48, %$20] ; # P
; # (if (& Cnt 1) (cond ((atom P) (let Y (cons $Nil (setq P $Nil)) (s...
; # (& Cnt 1)
  %76 = and i64 %74, 1
  %77 = icmp ne i64 %76, 0
  br i1 %77, label %$27, label %$28
$27:
  %78 = phi i64 [%72, %$21] ; # X
  %79 = phi i64 [%73, %$21] ; # Var
  %80 = phi i64 [%74, %$21] ; # Cnt
  %81 = phi i64 [%75, %$21] ; # P
; # (cond ((atom P) (let Y (cons $Nil (setq P $Nil)) (set Var (cons $...
; # (atom P)
  %82 = and i64 %81, 15
  %83 = icmp ne i64 %82, 0
  br i1 %83, label %$32, label %$31
$32:
  %84 = phi i64 [%78, %$27] ; # X
  %85 = phi i64 [%79, %$27] ; # Var
  %86 = phi i64 [%80, %$27] ; # Cnt
  %87 = phi i64 [%81, %$27] ; # P
; # (let Y (cons $Nil (setq P $Nil)) (set Var (cons $Nil Y)) (setq Va...
; # (cons $Nil (setq P $Nil))
  %88 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (set Var (cons $Nil Y))
; # (cons $Nil Y)
  %89 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64 %88)
  %90 = inttoptr i64 %85 to i64*
  store i64 %89, i64* %90
; # (ofs Y 1)
  %91 = add i64 %88, 8
  br label %$30
$31:
  %92 = phi i64 [%78, %$27] ; # X
  %93 = phi i64 [%79, %$27] ; # Var
  %94 = phi i64 [%80, %$27] ; # Cnt
  %95 = phi i64 [%81, %$27] ; # P
; # (cdr P)
  %96 = inttoptr i64 %95 to i64*
  %97 = getelementptr i64, i64* %96, i32 1
  %98 = load i64, i64* %97
; # (atom (cdr P))
  %99 = and i64 %98, 15
  %100 = icmp ne i64 %99, 0
  br i1 %100, label %$34, label %$33
$34:
  %101 = phi i64 [%92, %$31] ; # X
  %102 = phi i64 [%93, %$31] ; # Var
  %103 = phi i64 [%94, %$31] ; # Cnt
  %104 = phi i64 [%95, %$31] ; # P
; # (set 2 P (cons $Nil (setq P $Nil)))
; # (cons $Nil (setq P $Nil))
  %105 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %106 = inttoptr i64 %104 to i64*
  %107 = getelementptr i64, i64* %106, i32 1
  store i64 %105, i64* %107
; # (ofs (set 2 P (cons $Nil (setq P $Nil))) 1)
  %108 = add i64 %105, 8
  br label %$30
$33:
  %109 = phi i64 [%92, %$31] ; # X
  %110 = phi i64 [%93, %$31] ; # Var
  %111 = phi i64 [%94, %$31] ; # Cnt
  %112 = phi i64 [%95, %$31] ; # P
; # (ofs @ 1)
  %113 = add i64 %98, 8
; # (val (setq Var (ofs @ 1)))
  %114 = inttoptr i64 %113 to i64*
  %115 = load i64, i64* %114
  br label %$30
$30:
  %116 = phi i64 [%84, %$32], [%101, %$34], [%109, %$33] ; # X
  %117 = phi i64 [%91, %$32], [%108, %$34], [%113, %$33] ; # Var
  %118 = phi i64 [%86, %$32], [%103, %$34], [%111, %$33] ; # Cnt
  %119 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$32], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$34], [%115, %$33] ; # P
  %120 = phi i64 [%91, %$32], [%108, %$34], [%115, %$33] ; # ->
  br label %$29
$28:
  %121 = phi i64 [%72, %$21] ; # X
  %122 = phi i64 [%73, %$21] ; # Var
  %123 = phi i64 [%74, %$21] ; # Cnt
  %124 = phi i64 [%75, %$21] ; # P
; # (cond ((atom P) (let Y (cons (setq P $Nil) $Nil) (set Var (cons $...
; # (atom P)
  %125 = and i64 %124, 15
  %126 = icmp ne i64 %125, 0
  br i1 %126, label %$37, label %$36
$37:
  %127 = phi i64 [%121, %$28] ; # X
  %128 = phi i64 [%122, %$28] ; # Var
  %129 = phi i64 [%123, %$28] ; # Cnt
  %130 = phi i64 [%124, %$28] ; # P
; # (let Y (cons (setq P $Nil) $Nil) (set Var (cons $Nil Y)) (setq Va...
; # (cons (setq P $Nil) $Nil)
  %131 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (set Var (cons $Nil Y))
; # (cons $Nil Y)
  %132 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64 %131)
  %133 = inttoptr i64 %128 to i64*
  store i64 %132, i64* %133
  br label %$35
$36:
  %134 = phi i64 [%121, %$28] ; # X
  %135 = phi i64 [%122, %$28] ; # Var
  %136 = phi i64 [%123, %$28] ; # Cnt
  %137 = phi i64 [%124, %$28] ; # P
; # (cdr P)
  %138 = inttoptr i64 %137 to i64*
  %139 = getelementptr i64, i64* %138, i32 1
  %140 = load i64, i64* %139
; # (atom (cdr P))
  %141 = and i64 %140, 15
  %142 = icmp ne i64 %141, 0
  br i1 %142, label %$39, label %$38
$39:
  %143 = phi i64 [%134, %$36] ; # X
  %144 = phi i64 [%135, %$36] ; # Var
  %145 = phi i64 [%136, %$36] ; # Cnt
  %146 = phi i64 [%137, %$36] ; # P
; # (set 2 P (cons (setq P $Nil) $Nil))
; # (cons (setq P $Nil) $Nil)
  %147 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %148 = inttoptr i64 %146 to i64*
  %149 = getelementptr i64, i64* %148, i32 1
  store i64 %147, i64* %149
  br label %$35
$38:
  %150 = phi i64 [%134, %$36] ; # X
  %151 = phi i64 [%135, %$36] ; # Var
  %152 = phi i64 [%136, %$36] ; # Cnt
  %153 = phi i64 [%137, %$36] ; # P
; # (val (setq Var @))
  %154 = inttoptr i64 %140 to i64*
  %155 = load i64, i64* %154
  br label %$35
$35:
  %156 = phi i64 [%127, %$37], [%143, %$39], [%150, %$38] ; # X
  %157 = phi i64 [%131, %$37], [%147, %$39], [%140, %$38] ; # Var
  %158 = phi i64 [%129, %$37], [%145, %$39], [%152, %$38] ; # Cnt
  %159 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$37], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$39], [%155, %$38] ; # P
  %160 = phi i64 [%131, %$37], [%147, %$39], [%155, %$38] ; # ->
  br label %$29
$29:
  %161 = phi i64 [%116, %$30], [%156, %$35] ; # X
  %162 = phi i64 [%117, %$30], [%157, %$35] ; # Var
  %163 = phi i64 [%118, %$30], [%158, %$35] ; # Cnt
  %164 = phi i64 [%119, %$30], [%159, %$35] ; # P
  %165 = phi i64 [%120, %$30], [%160, %$35] ; # ->
  br label %$20
$22:
  %166 = phi i64 [%67, %$26] ; # X
  %167 = phi i64 [%71, %$26] ; # Var
  %168 = phi i64 [%69, %$26] ; # Cnt
  %169 = phi i64 [%70, %$26] ; # P
  %170 = phi i64 [%71, %$26] ; # ->
; # (? (atom (shift X)) Var)
; # (shift X)
  %171 = inttoptr i64 %166 to i64*
  %172 = getelementptr i64, i64* %171, i32 1
  %173 = load i64, i64* %172
; # (atom (shift X))
  %174 = and i64 %173, 15
  %175 = icmp ne i64 %174, 0
  br i1 %175, label %$41, label %$40
$41:
  %176 = phi i64 [%173, %$22] ; # X
  %177 = phi i64 [%167, %$22] ; # Var
  %178 = phi i64 [%168, %$22] ; # Cnt
  br label %$18
$40:
  %179 = phi i64 [%173, %$22] ; # X
  %180 = phi i64 [%167, %$22] ; # Var
  %181 = phi i64 [%168, %$22] ; # Cnt
  br label %$16
$18:
  %182 = phi i64 [%37, %$19], [%176, %$41] ; # X
  %183 = phi i64 [%38, %$19], [%177, %$41] ; # Var
  %184 = phi i64 [%39, %$19], [%178, %$41] ; # Cnt
  %185 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$19], [%177, %$41] ; # ->
  br label %$15
$14:
  %186 = phi i64 [%7, %$12] ; # X
  %187 = phi i64 [%15, %$12] ; # Var
; # (let (Q (link (push NIL NIL)) Tos (link (push -ZERO NIL)) R (link...
; # (push NIL NIL)
  %188 = alloca i64, i64 2, align 16
  %189 = ptrtoint i64* %188 to i64
; # (link (push NIL NIL))
  %190 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %191 = load i64, i64* %190
  %192 = inttoptr i64 %189 to i64*
  %193 = getelementptr i64, i64* %192, i32 1
  store i64 %191, i64* %193
  %194 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %189, i64* %194
; # (push -ZERO NIL)
  %195 = alloca i64, i64 2, align 16
  %196 = ptrtoint i64* %195 to i64
  %197 = inttoptr i64 %196 to i64*
  store i64 10, i64* %197
; # (link (push -ZERO NIL))
  %198 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %199 = load i64, i64* %198
  %200 = inttoptr i64 %196 to i64*
  %201 = getelementptr i64, i64* %200, i32 1
  store i64 %199, i64* %201
  %202 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %196, i64* %202
; # (push $Nil NIL)
  %203 = alloca i64, i64 2, align 16
  %204 = ptrtoint i64* %203 to i64
  %205 = inttoptr i64 %204 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %205
; # (link (push $Nil NIL))
  %206 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %207 = load i64, i64* %206
  %208 = inttoptr i64 %204 to i64*
  %209 = getelementptr i64, i64* %208, i32 1
  store i64 %207, i64* %209
  %210 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %204, i64* %210
; # (val Var)
  %211 = inttoptr i64 %187 to i64*
  %212 = load i64, i64* %211
; # (loop (loop (let Y (cdr P) (? (atom (cdr Y))) (let Z P (setq P @)...
  br label %$42
$42:
  %213 = phi i64 [%186, %$14], [%371, %$50] ; # X
  %214 = phi i64 [%187, %$14], [%372, %$50] ; # Var
  %215 = phi i64 [0, %$14], [%373, %$50] ; # Cnt
  %216 = phi i64 [%212, %$14], [%374, %$50] ; # P
  %217 = phi i64 [1, %$14], [%375, %$50] ; # M
; # (loop (let Y (cdr P) (? (atom (cdr Y))) (let Z P (setq P @) (set ...
  br label %$43
$43:
  %218 = phi i64 [%213, %$42], [%231, %$44] ; # X
  %219 = phi i64 [%214, %$42], [%232, %$44] ; # Var
  %220 = phi i64 [%215, %$42], [%241, %$44] ; # Cnt
  %221 = phi i64 [%216, %$42], [%228, %$44] ; # P
  %222 = phi i64 [%217, %$42], [%242, %$44] ; # M
; # (let Y (cdr P) (? (atom (cdr Y))) (let Z P (setq P @) (set 2 Y (v...
; # (cdr P)
  %223 = inttoptr i64 %221 to i64*
  %224 = getelementptr i64, i64* %223, i32 1
  %225 = load i64, i64* %224
; # (? (atom (cdr Y)))
; # (cdr Y)
  %226 = inttoptr i64 %225 to i64*
  %227 = getelementptr i64, i64* %226, i32 1
  %228 = load i64, i64* %227
; # (atom (cdr Y))
  %229 = and i64 %228, 15
  %230 = icmp ne i64 %229, 0
  br i1 %230, label %$45, label %$44
$44:
  %231 = phi i64 [%218, %$43] ; # X
  %232 = phi i64 [%219, %$43] ; # Var
  %233 = phi i64 [%220, %$43] ; # Cnt
  %234 = phi i64 [%221, %$43] ; # P
  %235 = phi i64 [%222, %$43] ; # M
; # (let Z P (setq P @) (set 2 Y (val Tos)) (set Tos Z))
; # (set 2 Y (val Tos))
; # (val Tos)
  %236 = inttoptr i64 %196 to i64*
  %237 = load i64, i64* %236
  %238 = inttoptr i64 %225 to i64*
  %239 = getelementptr i64, i64* %238, i32 1
  store i64 %237, i64* %239
; # (set Tos Z)
  %240 = inttoptr i64 %196 to i64*
  store i64 %234, i64* %240
; # (| Cnt M)
  %241 = or i64 %233, %235
; # (shl M 1)
  %242 = shl i64 %235, 1
  br label %$43
$45:
  %243 = phi i64 [%218, %$43] ; # X
  %244 = phi i64 [%219, %$43] ; # Var
  %245 = phi i64 [%220, %$43] ; # Cnt
  %246 = phi i64 [%221, %$43] ; # P
  %247 = phi i64 [%222, %$43] ; # M
  %248 = phi i64 [0, %$43] ; # ->
; # (set Q P)
  %249 = inttoptr i64 %189 to i64*
  store i64 %246, i64* %249
; # (loop (unless (nil? (car P)) (set R (cons (cons (cnt (| Cnt M)) @...
  br label %$46
$46:
  %250 = phi i64 [%243, %$45], [%365, %$56] ; # X
  %251 = phi i64 [%244, %$45], [%366, %$56] ; # Var
  %252 = phi i64 [%245, %$45], [%367, %$56] ; # Cnt
  %253 = phi i64 [%246, %$45], [%368, %$56] ; # P
  %254 = phi i64 [%247, %$45], [%369, %$56] ; # M
; # (unless (nil? (car P)) (set R (cons (cons (cnt (| Cnt M)) @) (val...
; # (car P)
  %255 = inttoptr i64 %253 to i64*
  %256 = load i64, i64* %255
; # (nil? (car P))
  %257 = icmp eq i64 %256, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %257, label %$48, label %$47
$47:
  %258 = phi i64 [%250, %$46] ; # X
  %259 = phi i64 [%251, %$46] ; # Var
  %260 = phi i64 [%252, %$46] ; # Cnt
  %261 = phi i64 [%253, %$46] ; # P
  %262 = phi i64 [%254, %$46] ; # M
; # (set R (cons (cons (cnt (| Cnt M)) @) (val R)))
; # (| Cnt M)
  %263 = or i64 %260, %262
; # (cnt (| Cnt M))
  %264 = shl i64 %263, 4
  %265 = or i64 %264, 2
; # (cons (cnt (| Cnt M)) @)
  %266 = call i64 @cons(i64 %265, i64 %256)
; # (val R)
  %267 = inttoptr i64 %204 to i64*
  %268 = load i64, i64* %267
; # (cons (cons (cnt (| Cnt M)) @) (val R))
  %269 = call i64 @cons(i64 %266, i64 %268)
  %270 = inttoptr i64 %204 to i64*
  store i64 %269, i64* %270
  br label %$48
$48:
  %271 = phi i64 [%250, %$46], [%258, %$47] ; # X
  %272 = phi i64 [%251, %$46], [%259, %$47] ; # Var
  %273 = phi i64 [%252, %$46], [%260, %$47] ; # Cnt
  %274 = phi i64 [%253, %$46], [%261, %$47] ; # P
  %275 = phi i64 [%254, %$46], [%262, %$47] ; # M
; # (let Y (cdr P) (? (pair (car Y)) (let Z P (setq P @) (set Y (val ...
; # (cdr P)
  %276 = inttoptr i64 %274 to i64*
  %277 = getelementptr i64, i64* %276, i32 1
  %278 = load i64, i64* %277
; # (? (pair (car Y)) (let Z P (setq P @) (set Y (val Tos)) (set Tos ...
; # (car Y)
  %279 = inttoptr i64 %278 to i64*
  %280 = load i64, i64* %279
; # (pair (car Y))
  %281 = and i64 %280, 15
  %282 = icmp eq i64 %281, 0
  br i1 %282, label %$51, label %$49
$51:
  %283 = phi i64 [%271, %$48] ; # X
  %284 = phi i64 [%272, %$48] ; # Var
  %285 = phi i64 [%273, %$48] ; # Cnt
  %286 = phi i64 [%274, %$48] ; # P
  %287 = phi i64 [%275, %$48] ; # M
; # (let Z P (setq P @) (set Y (val Tos)) (set Tos (| Z 8)) (set Q P)...
; # (set Y (val Tos))
; # (val Tos)
  %288 = inttoptr i64 %196 to i64*
  %289 = load i64, i64* %288
  %290 = inttoptr i64 %278 to i64*
  store i64 %289, i64* %290
; # (set Tos (| Z 8))
; # (| Z 8)
  %291 = or i64 %286, 8
  %292 = inttoptr i64 %196 to i64*
  store i64 %291, i64* %292
; # (set Q P)
  %293 = inttoptr i64 %189 to i64*
  store i64 %280, i64* %293
; # (shl M 1)
  %294 = shl i64 %287, 1
  br label %$50
$49:
  %295 = phi i64 [%271, %$48] ; # X
  %296 = phi i64 [%272, %$48] ; # Var
  %297 = phi i64 [%273, %$48] ; # Cnt
  %298 = phi i64 [%274, %$48] ; # P
  %299 = phi i64 [%275, %$48] ; # M
; # (loop (let Y (val Tos) (when (== -ZERO Y) (ret (val R))) (? (=0 (...
  br label %$52
$52:
  %300 = phi i64 [%295, %$49], [%347, %$55] ; # X
  %301 = phi i64 [%296, %$49], [%348, %$55] ; # Var
  %302 = phi i64 [%297, %$49], [%356, %$55] ; # Cnt
  %303 = phi i64 [%298, %$49], [%353, %$55] ; # P
  %304 = phi i64 [%299, %$49], [%354, %$55] ; # M
; # (let Y (val Tos) (when (== -ZERO Y) (ret (val R))) (? (=0 (& Y 8)...
; # (val Tos)
  %305 = inttoptr i64 %196 to i64*
  %306 = load i64, i64* %305
; # (when (== -ZERO Y) (ret (val R)))
; # (== -ZERO Y)
  %307 = icmp eq i64 10, %306
  br i1 %307, label %$53, label %$54
$53:
  %308 = phi i64 [%300, %$52] ; # X
  %309 = phi i64 [%301, %$52] ; # Var
  %310 = phi i64 [%302, %$52] ; # Cnt
  %311 = phi i64 [%303, %$52] ; # P
  %312 = phi i64 [%304, %$52] ; # M
  %313 = phi i64 [%306, %$52] ; # Y
; # (val R)
  %314 = inttoptr i64 %204 to i64*
  %315 = load i64, i64* %314
; # (ret (val R))
; # (drop *Safe)
  %316 = inttoptr i64 %24 to i64*
  %317 = getelementptr i64, i64* %316, i32 1
  %318 = load i64, i64* %317
  %319 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %318, i64* %319
  ret i64 %315
$54:
  %320 = phi i64 [%300, %$52] ; # X
  %321 = phi i64 [%301, %$52] ; # Var
  %322 = phi i64 [%302, %$52] ; # Cnt
  %323 = phi i64 [%303, %$52] ; # P
  %324 = phi i64 [%304, %$52] ; # M
  %325 = phi i64 [%306, %$52] ; # Y
; # (? (=0 (& Y 8)) (setq M (shr M 1) Cnt (& Cnt (x| M -1))) (let Z (...
; # (& Y 8)
  %326 = and i64 %325, 8
; # (=0 (& Y 8))
  %327 = icmp eq i64 %326, 0
  br i1 %327, label %$57, label %$55
$57:
  %328 = phi i64 [%320, %$54] ; # X
  %329 = phi i64 [%321, %$54] ; # Var
  %330 = phi i64 [%322, %$54] ; # Cnt
  %331 = phi i64 [%323, %$54] ; # P
  %332 = phi i64 [%324, %$54] ; # M
  %333 = phi i64 [%325, %$54] ; # Y
; # (shr M 1)
  %334 = lshr i64 %332, 1
; # (x| M -1)
  %335 = xor i64 %334, -1
; # (& Cnt (x| M -1))
  %336 = and i64 %330, %335
; # (let Z (cdr Y) (set Tos (cdr Z)) (set 2 Z P) (setq P Y) (set Q P)...
; # (cdr Y)
  %337 = inttoptr i64 %333 to i64*
  %338 = getelementptr i64, i64* %337, i32 1
  %339 = load i64, i64* %338
; # (set Tos (cdr Z))
; # (cdr Z)
  %340 = inttoptr i64 %339 to i64*
  %341 = getelementptr i64, i64* %340, i32 1
  %342 = load i64, i64* %341
  %343 = inttoptr i64 %196 to i64*
  store i64 %342, i64* %343
; # (set 2 Z P)
  %344 = inttoptr i64 %339 to i64*
  %345 = getelementptr i64, i64* %344, i32 1
  store i64 %331, i64* %345
; # (set Q P)
  %346 = inttoptr i64 %189 to i64*
  store i64 %333, i64* %346
  br label %$56
$55:
  %347 = phi i64 [%320, %$54] ; # X
  %348 = phi i64 [%321, %$54] ; # Var
  %349 = phi i64 [%322, %$54] ; # Cnt
  %350 = phi i64 [%323, %$54] ; # P
  %351 = phi i64 [%324, %$54] ; # M
  %352 = phi i64 [%325, %$54] ; # Y
; # (& Y -9)
  %353 = and i64 %352, -9
; # (shr M 1)
  %354 = lshr i64 %351, 1
; # (x| M -1)
  %355 = xor i64 %354, -1
; # (& Cnt (x| M -1))
  %356 = and i64 %349, %355
; # (let Z (cdr Y) (set Tos (car Z)) (set Z P) (setq P Y) (set Q P))
; # (cdr Y)
  %357 = inttoptr i64 %353 to i64*
  %358 = getelementptr i64, i64* %357, i32 1
  %359 = load i64, i64* %358
; # (set Tos (car Z))
; # (car Z)
  %360 = inttoptr i64 %359 to i64*
  %361 = load i64, i64* %360
  %362 = inttoptr i64 %196 to i64*
  store i64 %361, i64* %362
; # (set Z P)
  %363 = inttoptr i64 %359 to i64*
  store i64 %350, i64* %363
; # (set Q P)
  %364 = inttoptr i64 %189 to i64*
  store i64 %353, i64* %364
  br label %$52
$56:
  %365 = phi i64 [%328, %$57] ; # X
  %366 = phi i64 [%329, %$57] ; # Var
  %367 = phi i64 [%336, %$57] ; # Cnt
  %368 = phi i64 [%333, %$57] ; # P
  %369 = phi i64 [%334, %$57] ; # M
  %370 = phi i64 [%333, %$57] ; # ->
  br label %$46
$50:
  %371 = phi i64 [%283, %$51] ; # X
  %372 = phi i64 [%284, %$51] ; # Var
  %373 = phi i64 [%285, %$51] ; # Cnt
  %374 = phi i64 [%280, %$51] ; # P
  %375 = phi i64 [%294, %$51] ; # M
  %376 = phi i64 [%294, %$51] ; # ->
  br label %$42
$15:
  %377 = phi i64 [%182, %$18] ; # X
  %378 = phi i64 [%183, %$18] ; # Var
  %379 = phi i64 [%184, %$18] ; # Cnt
  %380 = phi i64 [%185, %$18] ; # ->
; # (drop *Safe)
  %381 = inttoptr i64 %24 to i64*
  %382 = getelementptr i64, i64* %381, i32 1
  %383 = load i64, i64* %382
  %384 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %383, i64* %384
  ret i64 %380
}

define i64 @_EnumQ(i64) align 8 {
$1:
; # (let (X (cdr Exe) P (save (eval (++ X))) Cnt T) (loop (? (le0 (se...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (save (eval (++ X)))
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %17 = load i64, i64* %16
  %18 = alloca i64, i64 2, align 16
  %19 = ptrtoint i64* %18 to i64
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = add i64 %19, 8
  %22 = inttoptr i64 %21 to i64*
  store i64 %17, i64* %22
  %23 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %19, i64* %23
; # (loop (? (le0 (setq Cnt (evCnt Exe X))) $Nil) (loop (let N (shr C...
  br label %$7
$7:
  %24 = phi i64 [%7, %$2], [%89, %$19] ; # X
  %25 = phi i64 [%15, %$2], [%93, %$19] ; # P
; # (? (le0 (setq Cnt (evCnt Exe X))) $Nil)
; # (evCnt Exe X)
  %26 = call i64 @evCnt(i64 %0, i64 %24)
; # (le0 (setq Cnt (evCnt Exe X)))
  %27 = icmp sle i64 %26, 0
  br i1 %27, label %$10, label %$8
$10:
  %28 = phi i64 [%24, %$7] ; # X
  %29 = phi i64 [%25, %$7] ; # P
  %30 = phi i64 [%26, %$7] ; # Cnt
  br label %$9
$8:
  %31 = phi i64 [%24, %$7] ; # X
  %32 = phi i64 [%25, %$7] ; # P
  %33 = phi i64 [%26, %$7] ; # Cnt
; # (loop (let N (shr Cnt 1) (? (=0 N)) (setq P (if (& Cnt 1) (cddr P...
  br label %$11
$11:
  %34 = phi i64 [%31, %$8], [%74, %$17] ; # X
  %35 = phi i64 [%32, %$8], [%75, %$17] ; # P
  %36 = phi i64 [%33, %$8], [%37, %$17] ; # Cnt
; # (let N (shr Cnt 1) (? (=0 N)) (setq P (if (& Cnt 1) (cddr P) (cad...
; # (shr Cnt 1)
  %37 = lshr i64 %36, 1
; # (? (=0 N))
; # (=0 N)
  %38 = icmp eq i64 %37, 0
  br i1 %38, label %$13, label %$12
$12:
  %39 = phi i64 [%34, %$11] ; # X
  %40 = phi i64 [%35, %$11] ; # P
  %41 = phi i64 [%36, %$11] ; # Cnt
; # (if (& Cnt 1) (cddr P) (cadr P))
; # (& Cnt 1)
  %42 = and i64 %41, 1
  %43 = icmp ne i64 %42, 0
  br i1 %43, label %$14, label %$15
$14:
  %44 = phi i64 [%39, %$12] ; # X
  %45 = phi i64 [%40, %$12] ; # P
  %46 = phi i64 [%41, %$12] ; # Cnt
; # (cddr P)
  %47 = inttoptr i64 %45 to i64*
  %48 = getelementptr i64, i64* %47, i32 1
  %49 = load i64, i64* %48
  %50 = inttoptr i64 %49 to i64*
  %51 = getelementptr i64, i64* %50, i32 1
  %52 = load i64, i64* %51
  br label %$16
$15:
  %53 = phi i64 [%39, %$12] ; # X
  %54 = phi i64 [%40, %$12] ; # P
  %55 = phi i64 [%41, %$12] ; # Cnt
; # (cadr P)
  %56 = inttoptr i64 %54 to i64*
  %57 = getelementptr i64, i64* %56, i32 1
  %58 = load i64, i64* %57
  %59 = inttoptr i64 %58 to i64*
  %60 = load i64, i64* %59
  br label %$16
$16:
  %61 = phi i64 [%44, %$14], [%53, %$15] ; # X
  %62 = phi i64 [%45, %$14], [%54, %$15] ; # P
  %63 = phi i64 [%46, %$14], [%55, %$15] ; # Cnt
  %64 = phi i64 [%52, %$14], [%60, %$15] ; # ->
; # (? (atom P) (ret $Nil))
; # (atom P)
  %65 = and i64 %64, 15
  %66 = icmp ne i64 %65, 0
  br i1 %66, label %$18, label %$17
$18:
  %67 = phi i64 [%61, %$16] ; # X
  %68 = phi i64 [%64, %$16] ; # P
  %69 = phi i64 [%63, %$16] ; # Cnt
; # (ret $Nil)
; # (drop *Safe)
  %70 = inttoptr i64 %19 to i64*
  %71 = getelementptr i64, i64* %70, i32 1
  %72 = load i64, i64* %71
  %73 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %72, i64* %73
  ret i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
$17:
  %74 = phi i64 [%61, %$16] ; # X
  %75 = phi i64 [%64, %$16] ; # P
  %76 = phi i64 [%63, %$16] ; # Cnt
  br label %$11
$13:
  %77 = phi i64 [%34, %$11] ; # X
  %78 = phi i64 [%35, %$11] ; # P
  %79 = phi i64 [%36, %$11] ; # Cnt
  %80 = phi i64 [0, %$11] ; # ->
; # (? (atom (shift X)) P)
; # (shift X)
  %81 = inttoptr i64 %77 to i64*
  %82 = getelementptr i64, i64* %81, i32 1
  %83 = load i64, i64* %82
; # (atom (shift X))
  %84 = and i64 %83, 15
  %85 = icmp ne i64 %84, 0
  br i1 %85, label %$20, label %$19
$20:
  %86 = phi i64 [%83, %$13] ; # X
  %87 = phi i64 [%78, %$13] ; # P
  %88 = phi i64 [%79, %$13] ; # Cnt
  br label %$9
$19:
  %89 = phi i64 [%83, %$13] ; # X
  %90 = phi i64 [%78, %$13] ; # P
  %91 = phi i64 [%79, %$13] ; # Cnt
; # (car P)
  %92 = inttoptr i64 %90 to i64*
  %93 = load i64, i64* %92
  br label %$7
$9:
  %94 = phi i64 [%28, %$10], [%86, %$20] ; # X
  %95 = phi i64 [%29, %$10], [%87, %$20] ; # P
  %96 = phi i64 [%30, %$10], [%88, %$20] ; # Cnt
  %97 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$10], [%87, %$20] ; # ->
; # (drop *Safe)
  %98 = inttoptr i64 %19 to i64*
  %99 = getelementptr i64, i64* %98, i32 1
  %100 = load i64, i64* %99
  %101 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %100, i64* %101
  ret i64 %97
}

define i64 @idxPut(i64, i64, i64) align 8 {
$1:
; # (let X (val Var) (if (pair X) (loop (? (=0 (compare (car X) Key))...
; # (val Var)
  %3 = inttoptr i64 %0 to i64*
  %4 = load i64, i64* %3
; # (if (pair X) (loop (? (=0 (compare (car X) Key)) X) (let Y (cdr X...
; # (pair X)
  %5 = and i64 %4, 15
  %6 = icmp eq i64 %5, 0
  br i1 %6, label %$2, label %$3
$2:
  %7 = phi i64 [%4, %$1] ; # X
; # (loop (? (=0 (compare (car X) Key)) X) (let Y (cdr X) (cond ((lt0...
  br label %$5
$5:
  %8 = phi i64 [%7, %$2], [%302, %$9] ; # X
; # (? (=0 (compare (car X) Key)) X)
; # (car X)
  %9 = inttoptr i64 %8 to i64*
  %10 = load i64, i64* %9
; # (compare (car X) Key)
  %11 = call i64 @compare(i64 %10, i64 %1)
; # (=0 (compare (car X) Key))
  %12 = icmp eq i64 %11, 0
  br i1 %12, label %$8, label %$6
$8:
  %13 = phi i64 [%8, %$5] ; # X
  br label %$7
$6:
  %14 = phi i64 [%8, %$5] ; # X
; # (let Y (cdr X) (cond ((lt0 @) (? (atom Y) (if (or (t? Flg) (chanc...
; # (cdr X)
  %15 = inttoptr i64 %14 to i64*
  %16 = getelementptr i64, i64* %15, i32 1
  %17 = load i64, i64* %16
; # (cond ((lt0 @) (? (atom Y) (if (or (t? Flg) (chance 1)) (set 2 X ...
; # (lt0 @)
  %18 = icmp slt i64 %11, 0
  br i1 %18, label %$11, label %$10
$11:
  %19 = phi i64 [%14, %$6] ; # X
  %20 = phi i64 [%17, %$6] ; # Y
; # (? (atom Y) (if (or (t? Flg) (chance 1)) (set 2 X (cons $Nil (con...
; # (atom Y)
  %21 = and i64 %20, 15
  %22 = icmp ne i64 %21, 0
  br i1 %22, label %$13, label %$12
$13:
  %23 = phi i64 [%19, %$11] ; # X
  %24 = phi i64 [%20, %$11] ; # Y
; # (if (or (t? Flg) (chance 1)) (set 2 X (cons $Nil (cons Key $Nil))...
; # (or (t? Flg) (chance 1))
; # (t? Flg)
  %25 = icmp eq i64 %2, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %25, label %$14, label %$15
$15:
  %26 = phi i64 [%23, %$13] ; # X
  %27 = phi i64 [%24, %$13] ; # Y
; # (chance 1)
  %28 = call i1 @chance(i64 1)
  br label %$14
$14:
  %29 = phi i64 [%23, %$13], [%26, %$15] ; # X
  %30 = phi i64 [%24, %$13], [%27, %$15] ; # Y
  %31 = phi i1 [1, %$13], [%28, %$15] ; # ->
  br i1 %31, label %$16, label %$17
$16:
  %32 = phi i64 [%29, %$14] ; # X
  %33 = phi i64 [%30, %$14] ; # Y
; # (set 2 X (cons $Nil (cons Key $Nil)))
; # (cons Key $Nil)
  %34 = call i64 @cons(i64 %1, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (cons $Nil (cons Key $Nil))
  %35 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64 %34)
  %36 = inttoptr i64 %32 to i64*
  %37 = getelementptr i64, i64* %36, i32 1
  store i64 %35, i64* %37
  br label %$18
$17:
  %38 = phi i64 [%29, %$14] ; # X
  %39 = phi i64 [%30, %$14] ; # Y
; # (set 2 X (cons (cons (car X) $Nil) $Nil))
; # (car X)
  %40 = inttoptr i64 %38 to i64*
  %41 = load i64, i64* %40
; # (cons (car X) $Nil)
  %42 = call i64 @cons(i64 %41, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (cons (cons (car X) $Nil) $Nil)
  %43 = call i64 @cons(i64 %42, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %44 = inttoptr i64 %38 to i64*
  %45 = getelementptr i64, i64* %44, i32 1
  store i64 %43, i64* %45
; # (set X Key)
  %46 = inttoptr i64 %38 to i64*
  store i64 %1, i64* %46
  br label %$18
$18:
  %47 = phi i64 [%32, %$16], [%38, %$17] ; # X
  %48 = phi i64 [%33, %$16], [%39, %$17] ; # Y
  %49 = phi i64 [%35, %$16], [%1, %$17] ; # ->
  br label %$7
$12:
  %50 = phi i64 [%19, %$11] ; # X
  %51 = phi i64 [%20, %$11] ; # Y
; # (? (atom (setq Y (cdr Y))) (if (or (t? Flg) (chance 1)) (set 2 (c...
; # (cdr Y)
  %52 = inttoptr i64 %51 to i64*
  %53 = getelementptr i64, i64* %52, i32 1
  %54 = load i64, i64* %53
; # (atom (setq Y (cdr Y)))
  %55 = and i64 %54, 15
  %56 = icmp ne i64 %55, 0
  br i1 %56, label %$20, label %$19
$20:
  %57 = phi i64 [%50, %$12] ; # X
  %58 = phi i64 [%54, %$12] ; # Y
; # (if (or (t? Flg) (chance 1)) (set 2 (cdr X) (cons Key $Nil)) (set...
; # (or (t? Flg) (chance 1))
; # (t? Flg)
  %59 = icmp eq i64 %2, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %59, label %$21, label %$22
$22:
  %60 = phi i64 [%57, %$20] ; # X
  %61 = phi i64 [%58, %$20] ; # Y
; # (chance 1)
  %62 = call i1 @chance(i64 1)
  br label %$21
$21:
  %63 = phi i64 [%57, %$20], [%60, %$22] ; # X
  %64 = phi i64 [%58, %$20], [%61, %$22] ; # Y
  %65 = phi i1 [1, %$20], [%62, %$22] ; # ->
  br i1 %65, label %$23, label %$24
$23:
  %66 = phi i64 [%63, %$21] ; # X
  %67 = phi i64 [%64, %$21] ; # Y
; # (set 2 (cdr X) (cons Key $Nil))
; # (cdr X)
  %68 = inttoptr i64 %66 to i64*
  %69 = getelementptr i64, i64* %68, i32 1
  %70 = load i64, i64* %69
; # (cons Key $Nil)
  %71 = call i64 @cons(i64 %1, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %72 = inttoptr i64 %70 to i64*
  %73 = getelementptr i64, i64* %72, i32 1
  store i64 %71, i64* %73
  br label %$25
$24:
  %74 = phi i64 [%63, %$21] ; # X
  %75 = phi i64 [%64, %$21] ; # Y
; # (set (cdr X) (cons (car X) (cons (cadr X) $Nil)))
; # (cdr X)
  %76 = inttoptr i64 %74 to i64*
  %77 = getelementptr i64, i64* %76, i32 1
  %78 = load i64, i64* %77
; # (car X)
  %79 = inttoptr i64 %74 to i64*
  %80 = load i64, i64* %79
; # (cadr X)
  %81 = inttoptr i64 %74 to i64*
  %82 = getelementptr i64, i64* %81, i32 1
  %83 = load i64, i64* %82
  %84 = inttoptr i64 %83 to i64*
  %85 = load i64, i64* %84
; # (cons (cadr X) $Nil)
  %86 = call i64 @cons(i64 %85, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (cons (car X) (cons (cadr X) $Nil))
  %87 = call i64 @cons(i64 %80, i64 %86)
  %88 = inttoptr i64 %78 to i64*
  store i64 %87, i64* %88
; # (set X Key)
  %89 = inttoptr i64 %74 to i64*
  store i64 %1, i64* %89
  br label %$25
$25:
  %90 = phi i64 [%66, %$23], [%74, %$24] ; # X
  %91 = phi i64 [%67, %$23], [%75, %$24] ; # Y
  %92 = phi i64 [%71, %$23], [%1, %$24] ; # ->
  br label %$7
$19:
  %93 = phi i64 [%50, %$12] ; # X
  %94 = phi i64 [%54, %$12] ; # Y
; # (if (or (t? Flg) (atom (cdr Y)) (gt0 (compare (car Y) Key)) (chan...
; # (or (t? Flg) (atom (cdr Y)) (gt0 (compare (car Y) Key)) (chance (...
; # (t? Flg)
  %95 = icmp eq i64 %2, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %95, label %$26, label %$27
$27:
  %96 = phi i64 [%93, %$19] ; # X
  %97 = phi i64 [%94, %$19] ; # Y
; # (cdr Y)
  %98 = inttoptr i64 %97 to i64*
  %99 = getelementptr i64, i64* %98, i32 1
  %100 = load i64, i64* %99
; # (atom (cdr Y))
  %101 = and i64 %100, 15
  %102 = icmp ne i64 %101, 0
  br i1 %102, label %$26, label %$28
$28:
  %103 = phi i64 [%96, %$27] ; # X
  %104 = phi i64 [%97, %$27] ; # Y
; # (car Y)
  %105 = inttoptr i64 %104 to i64*
  %106 = load i64, i64* %105
; # (compare (car Y) Key)
  %107 = call i64 @compare(i64 %106, i64 %1)
; # (gt0 (compare (car Y) Key))
  %108 = icmp sgt i64 %107, 0
  br i1 %108, label %$26, label %$29
$29:
  %109 = phi i64 [%103, %$28] ; # X
  %110 = phi i64 [%104, %$28] ; # Y
; # (chance (hex "FFF"))
  %111 = call i1 @chance(i64 4095)
  br label %$26
$26:
  %112 = phi i64 [%93, %$19], [%96, %$27], [%103, %$28], [%109, %$29] ; # X
  %113 = phi i64 [%94, %$19], [%97, %$27], [%104, %$28], [%110, %$29] ; # Y
  %114 = phi i1 [1, %$19], [1, %$27], [1, %$28], [%111, %$29] ; # ->
  br i1 %114, label %$30, label %$31
$30:
  %115 = phi i64 [%112, %$26] ; # X
  %116 = phi i64 [%113, %$26] ; # Y
  br label %$32
$31:
  %117 = phi i64 [%112, %$26] ; # X
  %118 = phi i64 [%113, %$26] ; # Y
; # (xchg X Y)
  %119 = inttoptr i64 %117 to i64*
  %120 = load i64, i64* %119
  %121 = inttoptr i64 %118 to i64*
  %122 = load i64, i64* %121
  store i64 %122, i64* %119
  store i64 %120, i64* %121
; # (set 2 (cdr X) (cddr Y) 2 (cdr Y) (cadr Y) (cdr Y) (cadr X) (cdr ...
; # (cdr X)
  %123 = inttoptr i64 %117 to i64*
  %124 = getelementptr i64, i64* %123, i32 1
  %125 = load i64, i64* %124
; # (cddr Y)
  %126 = inttoptr i64 %118 to i64*
  %127 = getelementptr i64, i64* %126, i32 1
  %128 = load i64, i64* %127
  %129 = inttoptr i64 %128 to i64*
  %130 = getelementptr i64, i64* %129, i32 1
  %131 = load i64, i64* %130
  %132 = inttoptr i64 %125 to i64*
  %133 = getelementptr i64, i64* %132, i32 1
  store i64 %131, i64* %133
; # (cdr Y)
  %134 = inttoptr i64 %118 to i64*
  %135 = getelementptr i64, i64* %134, i32 1
  %136 = load i64, i64* %135
; # (cadr Y)
  %137 = inttoptr i64 %118 to i64*
  %138 = getelementptr i64, i64* %137, i32 1
  %139 = load i64, i64* %138
  %140 = inttoptr i64 %139 to i64*
  %141 = load i64, i64* %140
  %142 = inttoptr i64 %136 to i64*
  %143 = getelementptr i64, i64* %142, i32 1
  store i64 %141, i64* %143
; # (cdr Y)
  %144 = inttoptr i64 %118 to i64*
  %145 = getelementptr i64, i64* %144, i32 1
  %146 = load i64, i64* %145
; # (cadr X)
  %147 = inttoptr i64 %117 to i64*
  %148 = getelementptr i64, i64* %147, i32 1
  %149 = load i64, i64* %148
  %150 = inttoptr i64 %149 to i64*
  %151 = load i64, i64* %150
  %152 = inttoptr i64 %146 to i64*
  store i64 %151, i64* %152
; # (cdr X)
  %153 = inttoptr i64 %117 to i64*
  %154 = getelementptr i64, i64* %153, i32 1
  %155 = load i64, i64* %154
  %156 = inttoptr i64 %155 to i64*
  store i64 %118, i64* %156
  br label %$32
$32:
  %157 = phi i64 [%116, %$30], [%117, %$31] ; # X
  %158 = phi i64 [%116, %$30], [%118, %$31] ; # Y
  %159 = phi i64 [%116, %$30], [%118, %$31] ; # ->
  br label %$9
$10:
  %160 = phi i64 [%14, %$6] ; # X
  %161 = phi i64 [%17, %$6] ; # Y
; # (? (atom Y) (if (or (t? Flg) (chance 1)) (set 2 X (cons (cons Key...
; # (atom Y)
  %162 = and i64 %161, 15
  %163 = icmp ne i64 %162, 0
  br i1 %163, label %$34, label %$33
$34:
  %164 = phi i64 [%160, %$10] ; # X
  %165 = phi i64 [%161, %$10] ; # Y
; # (if (or (t? Flg) (chance 1)) (set 2 X (cons (cons Key $Nil) $Nil)...
; # (or (t? Flg) (chance 1))
; # (t? Flg)
  %166 = icmp eq i64 %2, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %166, label %$35, label %$36
$36:
  %167 = phi i64 [%164, %$34] ; # X
  %168 = phi i64 [%165, %$34] ; # Y
; # (chance 1)
  %169 = call i1 @chance(i64 1)
  br label %$35
$35:
  %170 = phi i64 [%164, %$34], [%167, %$36] ; # X
  %171 = phi i64 [%165, %$34], [%168, %$36] ; # Y
  %172 = phi i1 [1, %$34], [%169, %$36] ; # ->
  br i1 %172, label %$37, label %$38
$37:
  %173 = phi i64 [%170, %$35] ; # X
  %174 = phi i64 [%171, %$35] ; # Y
; # (set 2 X (cons (cons Key $Nil) $Nil))
; # (cons Key $Nil)
  %175 = call i64 @cons(i64 %1, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (cons (cons Key $Nil) $Nil)
  %176 = call i64 @cons(i64 %175, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %177 = inttoptr i64 %173 to i64*
  %178 = getelementptr i64, i64* %177, i32 1
  store i64 %176, i64* %178
  br label %$39
$38:
  %179 = phi i64 [%170, %$35] ; # X
  %180 = phi i64 [%171, %$35] ; # Y
; # (set 2 X (cons $Nil (cons (car X) $Nil)))
; # (car X)
  %181 = inttoptr i64 %179 to i64*
  %182 = load i64, i64* %181
; # (cons (car X) $Nil)
  %183 = call i64 @cons(i64 %182, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (cons $Nil (cons (car X) $Nil))
  %184 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64 %183)
  %185 = inttoptr i64 %179 to i64*
  %186 = getelementptr i64, i64* %185, i32 1
  store i64 %184, i64* %186
; # (set X Key)
  %187 = inttoptr i64 %179 to i64*
  store i64 %1, i64* %187
  br label %$39
$39:
  %188 = phi i64 [%173, %$37], [%179, %$38] ; # X
  %189 = phi i64 [%174, %$37], [%180, %$38] ; # Y
  %190 = phi i64 [%176, %$37], [%1, %$38] ; # ->
  br label %$7
$33:
  %191 = phi i64 [%160, %$10] ; # X
  %192 = phi i64 [%161, %$10] ; # Y
; # (? (atom (setq Y (car Y))) (if (or (t? Flg) (chance 1)) (set (cdr...
; # (car Y)
  %193 = inttoptr i64 %192 to i64*
  %194 = load i64, i64* %193
; # (atom (setq Y (car Y)))
  %195 = and i64 %194, 15
  %196 = icmp ne i64 %195, 0
  br i1 %196, label %$41, label %$40
$41:
  %197 = phi i64 [%191, %$33] ; # X
  %198 = phi i64 [%194, %$33] ; # Y
; # (if (or (t? Flg) (chance 1)) (set (cdr X) (cons Key $Nil)) (set 2...
; # (or (t? Flg) (chance 1))
; # (t? Flg)
  %199 = icmp eq i64 %2, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %199, label %$42, label %$43
$43:
  %200 = phi i64 [%197, %$41] ; # X
  %201 = phi i64 [%198, %$41] ; # Y
; # (chance 1)
  %202 = call i1 @chance(i64 1)
  br label %$42
$42:
  %203 = phi i64 [%197, %$41], [%200, %$43] ; # X
  %204 = phi i64 [%198, %$41], [%201, %$43] ; # Y
  %205 = phi i1 [1, %$41], [%202, %$43] ; # ->
  br i1 %205, label %$44, label %$45
$44:
  %206 = phi i64 [%203, %$42] ; # X
  %207 = phi i64 [%204, %$42] ; # Y
; # (set (cdr X) (cons Key $Nil))
; # (cdr X)
  %208 = inttoptr i64 %206 to i64*
  %209 = getelementptr i64, i64* %208, i32 1
  %210 = load i64, i64* %209
; # (cons Key $Nil)
  %211 = call i64 @cons(i64 %1, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %212 = inttoptr i64 %210 to i64*
  store i64 %211, i64* %212
  br label %$46
$45:
  %213 = phi i64 [%203, %$42] ; # X
  %214 = phi i64 [%204, %$42] ; # Y
; # (set 2 (cdr X) (cons (car X) (cons $Nil (cddr X))))
; # (cdr X)
  %215 = inttoptr i64 %213 to i64*
  %216 = getelementptr i64, i64* %215, i32 1
  %217 = load i64, i64* %216
; # (car X)
  %218 = inttoptr i64 %213 to i64*
  %219 = load i64, i64* %218
; # (cddr X)
  %220 = inttoptr i64 %213 to i64*
  %221 = getelementptr i64, i64* %220, i32 1
  %222 = load i64, i64* %221
  %223 = inttoptr i64 %222 to i64*
  %224 = getelementptr i64, i64* %223, i32 1
  %225 = load i64, i64* %224
; # (cons $Nil (cddr X))
  %226 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64 %225)
; # (cons (car X) (cons $Nil (cddr X)))
  %227 = call i64 @cons(i64 %219, i64 %226)
  %228 = inttoptr i64 %217 to i64*
  %229 = getelementptr i64, i64* %228, i32 1
  store i64 %227, i64* %229
; # (set X Key)
  %230 = inttoptr i64 %213 to i64*
  store i64 %1, i64* %230
  br label %$46
$46:
  %231 = phi i64 [%206, %$44], [%213, %$45] ; # X
  %232 = phi i64 [%207, %$44], [%214, %$45] ; # Y
  %233 = phi i64 [%211, %$44], [%1, %$45] ; # ->
  br label %$7
$40:
  %234 = phi i64 [%191, %$33] ; # X
  %235 = phi i64 [%194, %$33] ; # Y
; # (if (or (t? Flg) (atom (cdr Y)) (lt0 (compare (car Y) Key)) (chan...
; # (or (t? Flg) (atom (cdr Y)) (lt0 (compare (car Y) Key)) (chance (...
; # (t? Flg)
  %236 = icmp eq i64 %2, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %236, label %$47, label %$48
$48:
  %237 = phi i64 [%234, %$40] ; # X
  %238 = phi i64 [%235, %$40] ; # Y
; # (cdr Y)
  %239 = inttoptr i64 %238 to i64*
  %240 = getelementptr i64, i64* %239, i32 1
  %241 = load i64, i64* %240
; # (atom (cdr Y))
  %242 = and i64 %241, 15
  %243 = icmp ne i64 %242, 0
  br i1 %243, label %$47, label %$49
$49:
  %244 = phi i64 [%237, %$48] ; # X
  %245 = phi i64 [%238, %$48] ; # Y
; # (car Y)
  %246 = inttoptr i64 %245 to i64*
  %247 = load i64, i64* %246
; # (compare (car Y) Key)
  %248 = call i64 @compare(i64 %247, i64 %1)
; # (lt0 (compare (car Y) Key))
  %249 = icmp slt i64 %248, 0
  br i1 %249, label %$47, label %$50
$50:
  %250 = phi i64 [%244, %$49] ; # X
  %251 = phi i64 [%245, %$49] ; # Y
; # (chance (hex "FFF"))
  %252 = call i1 @chance(i64 4095)
  br label %$47
$47:
  %253 = phi i64 [%234, %$40], [%237, %$48], [%244, %$49], [%250, %$50] ; # X
  %254 = phi i64 [%235, %$40], [%238, %$48], [%245, %$49], [%251, %$50] ; # Y
  %255 = phi i1 [1, %$40], [1, %$48], [1, %$49], [%252, %$50] ; # ->
  br i1 %255, label %$51, label %$52
$51:
  %256 = phi i64 [%253, %$47] ; # X
  %257 = phi i64 [%254, %$47] ; # Y
  br label %$53
$52:
  %258 = phi i64 [%253, %$47] ; # X
  %259 = phi i64 [%254, %$47] ; # Y
; # (xchg X Y)
  %260 = inttoptr i64 %258 to i64*
  %261 = load i64, i64* %260
  %262 = inttoptr i64 %259 to i64*
  %263 = load i64, i64* %262
  store i64 %263, i64* %260
  store i64 %261, i64* %262
; # (set (cdr X) (cadr Y) (cdr Y) (cddr Y) 2 (cdr Y) (cddr X) 2 (cdr ...
; # (cdr X)
  %264 = inttoptr i64 %258 to i64*
  %265 = getelementptr i64, i64* %264, i32 1
  %266 = load i64, i64* %265
; # (cadr Y)
  %267 = inttoptr i64 %259 to i64*
  %268 = getelementptr i64, i64* %267, i32 1
  %269 = load i64, i64* %268
  %270 = inttoptr i64 %269 to i64*
  %271 = load i64, i64* %270
  %272 = inttoptr i64 %266 to i64*
  store i64 %271, i64* %272
; # (cdr Y)
  %273 = inttoptr i64 %259 to i64*
  %274 = getelementptr i64, i64* %273, i32 1
  %275 = load i64, i64* %274
; # (cddr Y)
  %276 = inttoptr i64 %259 to i64*
  %277 = getelementptr i64, i64* %276, i32 1
  %278 = load i64, i64* %277
  %279 = inttoptr i64 %278 to i64*
  %280 = getelementptr i64, i64* %279, i32 1
  %281 = load i64, i64* %280
  %282 = inttoptr i64 %275 to i64*
  store i64 %281, i64* %282
; # (cdr Y)
  %283 = inttoptr i64 %259 to i64*
  %284 = getelementptr i64, i64* %283, i32 1
  %285 = load i64, i64* %284
; # (cddr X)
  %286 = inttoptr i64 %258 to i64*
  %287 = getelementptr i64, i64* %286, i32 1
  %288 = load i64, i64* %287
  %289 = inttoptr i64 %288 to i64*
  %290 = getelementptr i64, i64* %289, i32 1
  %291 = load i64, i64* %290
  %292 = inttoptr i64 %285 to i64*
  %293 = getelementptr i64, i64* %292, i32 1
  store i64 %291, i64* %293
; # (cdr X)
  %294 = inttoptr i64 %258 to i64*
  %295 = getelementptr i64, i64* %294, i32 1
  %296 = load i64, i64* %295
  %297 = inttoptr i64 %296 to i64*
  %298 = getelementptr i64, i64* %297, i32 1
  store i64 %259, i64* %298
  br label %$53
$53:
  %299 = phi i64 [%257, %$51], [%258, %$52] ; # X
  %300 = phi i64 [%257, %$51], [%259, %$52] ; # Y
  %301 = phi i64 [%257, %$51], [%259, %$52] ; # ->
  br label %$9
$9:
  %302 = phi i64 [%157, %$32], [%299, %$53] ; # X
  %303 = phi i64 [%158, %$32], [%300, %$53] ; # Y
  %304 = phi i64 [%159, %$32], [%301, %$53] ; # ->
  br label %$5
$7:
  %305 = phi i64 [%13, %$8], [%47, %$18], [%90, %$25], [%188, %$39], [%231, %$46] ; # X
  %306 = phi i64 [%13, %$8], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$18], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$25], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$39], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$46] ; # ->
  br label %$4
$3:
  %307 = phi i64 [%4, %$1] ; # X
; # (set Var (cons Key $Nil))
; # (cons Key $Nil)
  %308 = call i64 @cons(i64 %1, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %309 = inttoptr i64 %0 to i64*
  store i64 %308, i64* %309
  br label %$4
$4:
  %310 = phi i64 [%305, %$7], [%307, %$3] ; # X
  %311 = phi i64 [%306, %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$3] ; # ->
  ret i64 %311
}

define i64 @idxGet(i64, i64) align 8 {
$1:
; # (let X (val Var) (cond ((nil? Key) (while (pair (cadr X)) (setq X...
; # (val Var)
  %2 = inttoptr i64 %0 to i64*
  %3 = load i64, i64* %2
; # (cond ((nil? Key) (while (pair (cadr X)) (setq X @)) X) ((t? Key)...
; # (nil? Key)
  %4 = icmp eq i64 %1, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %4, label %$4, label %$3
$4:
  %5 = phi i64 [%3, %$1] ; # X
; # (while (pair (cadr X)) (setq X @))
  br label %$5
$5:
  %6 = phi i64 [%5, %$4], [%11, %$6] ; # X
; # (cadr X)
  %7 = inttoptr i64 %6 to i64*
  %8 = getelementptr i64, i64* %7, i32 1
  %9 = load i64, i64* %8
  %10 = inttoptr i64 %9 to i64*
  %11 = load i64, i64* %10
; # (pair (cadr X))
  %12 = and i64 %11, 15
  %13 = icmp eq i64 %12, 0
  br i1 %13, label %$6, label %$7
$6:
  %14 = phi i64 [%6, %$5] ; # X
  br label %$5
$7:
  %15 = phi i64 [%6, %$5] ; # X
  br label %$2
$3:
  %16 = phi i64 [%3, %$1] ; # X
; # (t? Key)
  %17 = icmp eq i64 %1, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %17, label %$9, label %$8
$9:
  %18 = phi i64 [%16, %$3] ; # X
; # (while (pair (cddr X)) (setq X @))
  br label %$10
$10:
  %19 = phi i64 [%18, %$9], [%25, %$11] ; # X
; # (cddr X)
  %20 = inttoptr i64 %19 to i64*
  %21 = getelementptr i64, i64* %20, i32 1
  %22 = load i64, i64* %21
  %23 = inttoptr i64 %22 to i64*
  %24 = getelementptr i64, i64* %23, i32 1
  %25 = load i64, i64* %24
; # (pair (cddr X))
  %26 = and i64 %25, 15
  %27 = icmp eq i64 %26, 0
  br i1 %27, label %$11, label %$12
$11:
  %28 = phi i64 [%19, %$10] ; # X
  br label %$10
$12:
  %29 = phi i64 [%19, %$10] ; # X
  br label %$2
$8:
  %30 = phi i64 [%16, %$3] ; # X
; # (loop (? (atom X) $Nil) (? (=0 (compare (car X) Key)) X) (let Y (...
  br label %$13
$13:
  %31 = phi i64 [%30, %$8], [%54, %$21] ; # X
; # (? (atom X) $Nil)
; # (atom X)
  %32 = and i64 %31, 15
  %33 = icmp ne i64 %32, 0
  br i1 %33, label %$16, label %$14
$16:
  %34 = phi i64 [%31, %$13] ; # X
  br label %$15
$14:
  %35 = phi i64 [%31, %$13] ; # X
; # (? (=0 (compare (car X) Key)) X)
; # (car X)
  %36 = inttoptr i64 %35 to i64*
  %37 = load i64, i64* %36
; # (compare (car X) Key)
  %38 = call i64 @compare(i64 %37, i64 %1)
; # (=0 (compare (car X) Key))
  %39 = icmp eq i64 %38, 0
  br i1 %39, label %$18, label %$17
$18:
  %40 = phi i64 [%35, %$14] ; # X
  br label %$15
$17:
  %41 = phi i64 [%35, %$14] ; # X
; # (let Y (cdr X) (setq X (if (lt0 @) (cdr Y) (car Y))))
; # (cdr X)
  %42 = inttoptr i64 %41 to i64*
  %43 = getelementptr i64, i64* %42, i32 1
  %44 = load i64, i64* %43
; # (if (lt0 @) (cdr Y) (car Y))
; # (lt0 @)
  %45 = icmp slt i64 %38, 0
  br i1 %45, label %$19, label %$20
$19:
  %46 = phi i64 [%41, %$17] ; # X
; # (cdr Y)
  %47 = inttoptr i64 %44 to i64*
  %48 = getelementptr i64, i64* %47, i32 1
  %49 = load i64, i64* %48
  br label %$21
$20:
  %50 = phi i64 [%41, %$17] ; # X
; # (car Y)
  %51 = inttoptr i64 %44 to i64*
  %52 = load i64, i64* %51
  br label %$21
$21:
  %53 = phi i64 [%46, %$19], [%50, %$20] ; # X
  %54 = phi i64 [%49, %$19], [%52, %$20] ; # ->
  br label %$13
$15:
  %55 = phi i64 [%34, %$16], [%40, %$18] ; # X
  %56 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$16], [%40, %$18] ; # ->
  br label %$2
$2:
  %57 = phi i64 [%15, %$7], [%29, %$12], [%55, %$15] ; # X
  %58 = phi i64 [%15, %$7], [%29, %$12], [%56, %$15] ; # ->
  ret i64 %58
}

define i64 @idxDel(i64, i64) align 8 {
$1:
; # (loop (let X (val Var) (? (atom X) $Nil) (let Y (cdr X) (let I (c...
  br label %$2
$2:
  %2 = phi i64 [%0, %$1], [%126, %$21] ; # Var
; # (let X (val Var) (? (atom X) $Nil) (let Y (cdr X) (let I (compare...
; # (val Var)
  %3 = inttoptr i64 %2 to i64*
  %4 = load i64, i64* %3
; # (? (atom X) $Nil)
; # (atom X)
  %5 = and i64 %4, 15
  %6 = icmp ne i64 %5, 0
  br i1 %6, label %$5, label %$3
$5:
  %7 = phi i64 [%2, %$2] ; # Var
  br label %$4
$3:
  %8 = phi i64 [%2, %$2] ; # Var
; # (let Y (cdr X) (let I (compare (car X) Key) (? (=0 I) (cond ((ato...
; # (cdr X)
  %9 = inttoptr i64 %4 to i64*
  %10 = getelementptr i64, i64* %9, i32 1
  %11 = load i64, i64* %10
; # (let I (compare (car X) Key) (? (=0 I) (cond ((atom (car Y)) (set...
; # (car X)
  %12 = inttoptr i64 %4 to i64*
  %13 = load i64, i64* %12
; # (compare (car X) Key)
  %14 = call i64 @compare(i64 %13, i64 %1)
; # (? (=0 I) (cond ((atom (car Y)) (set Var (cdr Y))) ((atom (cdr Y)...
; # (=0 I)
  %15 = icmp eq i64 %14, 0
  br i1 %15, label %$7, label %$6
$7:
  %16 = phi i64 [%8, %$3] ; # Var
  %17 = phi i64 [%11, %$3] ; # Y
; # (cond ((atom (car Y)) (set Var (cdr Y))) ((atom (cdr Y)) (set Var...
; # (car Y)
  %18 = inttoptr i64 %17 to i64*
  %19 = load i64, i64* %18
; # (atom (car Y))
  %20 = and i64 %19, 15
  %21 = icmp ne i64 %20, 0
  br i1 %21, label %$10, label %$9
$10:
  %22 = phi i64 [%16, %$7] ; # Var
  %23 = phi i64 [%17, %$7] ; # Y
; # (set Var (cdr Y))
; # (cdr Y)
  %24 = inttoptr i64 %23 to i64*
  %25 = getelementptr i64, i64* %24, i32 1
  %26 = load i64, i64* %25
  %27 = inttoptr i64 %22 to i64*
  store i64 %26, i64* %27
  br label %$8
$9:
  %28 = phi i64 [%16, %$7] ; # Var
  %29 = phi i64 [%17, %$7] ; # Y
; # (cdr Y)
  %30 = inttoptr i64 %29 to i64*
  %31 = getelementptr i64, i64* %30, i32 1
  %32 = load i64, i64* %31
; # (atom (cdr Y))
  %33 = and i64 %32, 15
  %34 = icmp ne i64 %33, 0
  br i1 %34, label %$12, label %$11
$12:
  %35 = phi i64 [%28, %$9] ; # Var
  %36 = phi i64 [%29, %$9] ; # Y
; # (set Var (car Y))
; # (car Y)
  %37 = inttoptr i64 %36 to i64*
  %38 = load i64, i64* %37
  %39 = inttoptr i64 %35 to i64*
  store i64 %38, i64* %39
  br label %$8
$11:
  %40 = phi i64 [%28, %$9] ; # Var
  %41 = phi i64 [%29, %$9] ; # Y
; # (let Z (cdr (setq Y (cdr Y))) (if (atom (car Z)) (set X (car Y) 2...
; # (cdr Y)
  %42 = inttoptr i64 %41 to i64*
  %43 = getelementptr i64, i64* %42, i32 1
  %44 = load i64, i64* %43
; # (cdr (setq Y (cdr Y)))
  %45 = inttoptr i64 %44 to i64*
  %46 = getelementptr i64, i64* %45, i32 1
  %47 = load i64, i64* %46
; # (if (atom (car Z)) (set X (car Y) 2 (cdr X) (cdr Z)) (let L (cdr ...
; # (car Z)
  %48 = inttoptr i64 %47 to i64*
  %49 = load i64, i64* %48
; # (atom (car Z))
  %50 = and i64 %49, 15
  %51 = icmp ne i64 %50, 0
  br i1 %51, label %$13, label %$14
$13:
  %52 = phi i64 [%40, %$11] ; # Var
  %53 = phi i64 [%44, %$11] ; # Y
  %54 = phi i64 [%47, %$11] ; # Z
; # (set X (car Y) 2 (cdr X) (cdr Z))
; # (car Y)
  %55 = inttoptr i64 %53 to i64*
  %56 = load i64, i64* %55
  %57 = inttoptr i64 %4 to i64*
  store i64 %56, i64* %57
; # (cdr X)
  %58 = inttoptr i64 %4 to i64*
  %59 = getelementptr i64, i64* %58, i32 1
  %60 = load i64, i64* %59
; # (cdr Z)
  %61 = inttoptr i64 %54 to i64*
  %62 = getelementptr i64, i64* %61, i32 1
  %63 = load i64, i64* %62
  %64 = inttoptr i64 %60 to i64*
  %65 = getelementptr i64, i64* %64, i32 1
  store i64 %63, i64* %65
  br label %$15
$14:
  %66 = phi i64 [%40, %$11] ; # Var
  %67 = phi i64 [%44, %$11] ; # Y
  %68 = phi i64 [%47, %$11] ; # Z
; # (let L (cdr (setq Z (car Z))) (loop (? (atom (car L))) (setq Y Z ...
; # (car Z)
  %69 = inttoptr i64 %68 to i64*
  %70 = load i64, i64* %69
; # (cdr (setq Z (car Z)))
  %71 = inttoptr i64 %70 to i64*
  %72 = getelementptr i64, i64* %71, i32 1
  %73 = load i64, i64* %72
; # (loop (? (atom (car L))) (setq Y Z Z (car L) L (cdr Z)))
  br label %$16
$16:
  %74 = phi i64 [%66, %$14], [%82, %$17] ; # Var
  %75 = phi i64 [%67, %$14], [%84, %$17] ; # Y
  %76 = phi i64 [%70, %$14], [%87, %$17] ; # Z
  %77 = phi i64 [%73, %$14], [%90, %$17] ; # L
; # (? (atom (car L)))
; # (car L)
  %78 = inttoptr i64 %77 to i64*
  %79 = load i64, i64* %78
; # (atom (car L))
  %80 = and i64 %79, 15
  %81 = icmp ne i64 %80, 0
  br i1 %81, label %$18, label %$17
$17:
  %82 = phi i64 [%74, %$16] ; # Var
  %83 = phi i64 [%75, %$16] ; # Y
  %84 = phi i64 [%76, %$16] ; # Z
  %85 = phi i64 [%77, %$16] ; # L
; # (car L)
  %86 = inttoptr i64 %85 to i64*
  %87 = load i64, i64* %86
; # (cdr Z)
  %88 = inttoptr i64 %87 to i64*
  %89 = getelementptr i64, i64* %88, i32 1
  %90 = load i64, i64* %89
  br label %$16
$18:
  %91 = phi i64 [%74, %$16] ; # Var
  %92 = phi i64 [%75, %$16] ; # Y
  %93 = phi i64 [%76, %$16] ; # Z
  %94 = phi i64 [%77, %$16] ; # L
  %95 = phi i64 [0, %$16] ; # ->
; # (set X (car Z) (cdr Y) (cdr L))
; # (car Z)
  %96 = inttoptr i64 %93 to i64*
  %97 = load i64, i64* %96
  %98 = inttoptr i64 %4 to i64*
  store i64 %97, i64* %98
; # (cdr Y)
  %99 = inttoptr i64 %92 to i64*
  %100 = getelementptr i64, i64* %99, i32 1
  %101 = load i64, i64* %100
; # (cdr L)
  %102 = inttoptr i64 %94 to i64*
  %103 = getelementptr i64, i64* %102, i32 1
  %104 = load i64, i64* %103
  %105 = inttoptr i64 %101 to i64*
  store i64 %104, i64* %105
  br label %$15
$15:
  %106 = phi i64 [%52, %$13], [%91, %$18] ; # Var
  %107 = phi i64 [%53, %$13], [%92, %$18] ; # Y
  %108 = phi i64 [%54, %$13], [%93, %$18] ; # Z
  %109 = phi i64 [%63, %$13], [%104, %$18] ; # ->
  br label %$8
$8:
  %110 = phi i64 [%22, %$10], [%35, %$12], [%106, %$15] ; # Var
  %111 = phi i64 [%23, %$10], [%36, %$12], [%107, %$15] ; # Y
  %112 = phi i64 [%26, %$10], [%38, %$12], [%109, %$15] ; # ->
  br label %$4
$6:
  %113 = phi i64 [%8, %$3] ; # Var
  %114 = phi i64 [%11, %$3] ; # Y
; # (? (atom Y) $Nil)
; # (atom Y)
  %115 = and i64 %114, 15
  %116 = icmp ne i64 %115, 0
  br i1 %116, label %$20, label %$19
$20:
  %117 = phi i64 [%113, %$6] ; # Var
  %118 = phi i64 [%114, %$6] ; # Y
  br label %$4
$19:
  %119 = phi i64 [%113, %$6] ; # Var
  %120 = phi i64 [%114, %$6] ; # Y
; # (and (lt0 I) (setq Var (ofs Var 1)))
; # (lt0 I)
  %121 = icmp slt i64 %14, 0
  br i1 %121, label %$22, label %$21
$22:
  %122 = phi i64 [%120, %$19] ; # Var
  %123 = phi i64 [%120, %$19] ; # Y
; # (ofs Var 1)
  %124 = add i64 %122, 8
  %125 = icmp ne i64 %124, 0
  br label %$21
$21:
  %126 = phi i64 [%120, %$19], [%124, %$22] ; # Var
  %127 = phi i64 [%120, %$19], [%123, %$22] ; # Y
  %128 = phi i1 [0, %$19], [%125, %$22] ; # ->
  br label %$2
$4:
  %129 = phi i64 [%7, %$5], [%110, %$8], [%117, %$20] ; # Var
  %130 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$5], [%4, %$8], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$20] ; # ->
  ret i64 %130
}

define i64 @_Idx(i64) align 8 {
$1:
; # (let (X (cdr Exe) Var (needChkVar Exe (eval (++ X)))) (if (atom X...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (needChkVar Exe (eval (++ X)))
  %16 = and i64 %15, 6
  %17 = icmp ne i64 %16, 0
  br i1 %17, label %$7, label %$8
$7:
  call void @varErr(i64 %0, i64 %15)
  unreachable
$8:
  %18 = icmp uge i64 %15, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %18, label %$10, label %$9
$10:
  %19 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %15
  br label %$9
$9:
  %20 = phi i1 [0, %$8], [%19, %$10] ; # ->
  br i1 %20, label %$11, label %$12
$11:
  call void @protErr(i64 %0, i64 %15)
  unreachable
$12:
; # (if (atom X) (consTree (val Var) $Nil) (save Var (let Key (save (...
; # (atom X)
  %21 = and i64 %7, 15
  %22 = icmp ne i64 %21, 0
  br i1 %22, label %$13, label %$14
$13:
  %23 = phi i64 [%7, %$12] ; # X
; # (val Var)
  %24 = inttoptr i64 %15 to i64*
  %25 = load i64, i64* %24
; # (consTree (val Var) $Nil)
  %26 = call i64 @consTree(i64 %25, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  br label %$15
$14:
  %27 = phi i64 [%7, %$12] ; # X
; # (save Var (let Key (save (eval (++ X))) (cond ((atom X) (idxGet V...
  %28 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %29 = load i64, i64* %28
  %30 = alloca i64, i64 2, align 16
  %31 = ptrtoint i64* %30 to i64
  %32 = inttoptr i64 %31 to i64*
  store i64 %15, i64* %32
  %33 = add i64 %31, 8
  %34 = inttoptr i64 %33 to i64*
  store i64 %29, i64* %34
  %35 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %31, i64* %35
; # (let Key (save (eval (++ X))) (cond ((atom X) (idxGet Var Key)) (...
; # (++ X)
  %36 = inttoptr i64 %27 to i64*
  %37 = load i64, i64* %36
  %38 = getelementptr i64, i64* %36, i32 1
  %39 = load i64, i64* %38
; # (eval (++ X))
  %40 = and i64 %37, 6
  %41 = icmp ne i64 %40, 0
  br i1 %41, label %$18, label %$17
$18:
  br label %$16
$17:
  %42 = and i64 %37, 8
  %43 = icmp ne i64 %42, 0
  br i1 %43, label %$20, label %$19
$20:
  %44 = inttoptr i64 %37 to i64*
  %45 = load i64, i64* %44
  br label %$16
$19:
  %46 = call i64 @evList(i64 %37)
  br label %$16
$16:
  %47 = phi i64 [%37, %$18], [%45, %$20], [%46, %$19] ; # ->
; # (save (eval (++ X)))
  %48 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %49 = load i64, i64* %48
  %50 = alloca i64, i64 2, align 16
  %51 = ptrtoint i64* %50 to i64
  %52 = inttoptr i64 %51 to i64*
  store i64 %47, i64* %52
  %53 = add i64 %51, 8
  %54 = inttoptr i64 %53 to i64*
  store i64 %49, i64* %54
  %55 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %51, i64* %55
; # (cond ((atom X) (idxGet Var Key)) ((nil? (eval (car X))) (idxDel ...
; # (atom X)
  %56 = and i64 %39, 15
  %57 = icmp ne i64 %56, 0
  br i1 %57, label %$23, label %$22
$23:
  %58 = phi i64 [%39, %$16] ; # X
; # (idxGet Var Key)
  %59 = call i64 @idxGet(i64 %15, i64 %47)
  br label %$21
$22:
  %60 = phi i64 [%39, %$16] ; # X
; # (car X)
  %61 = inttoptr i64 %60 to i64*
  %62 = load i64, i64* %61
; # (eval (car X))
  %63 = and i64 %62, 6
  %64 = icmp ne i64 %63, 0
  br i1 %64, label %$26, label %$25
$26:
  br label %$24
$25:
  %65 = and i64 %62, 8
  %66 = icmp ne i64 %65, 0
  br i1 %66, label %$28, label %$27
$28:
  %67 = inttoptr i64 %62 to i64*
  %68 = load i64, i64* %67
  br label %$24
$27:
  %69 = call i64 @evList(i64 %62)
  br label %$24
$24:
  %70 = phi i64 [%62, %$26], [%68, %$28], [%69, %$27] ; # ->
; # (nil? (eval (car X)))
  %71 = icmp eq i64 %70, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %71, label %$30, label %$29
$30:
  %72 = phi i64 [%60, %$24] ; # X
; # (idxDel Var Key)
  %73 = call i64 @idxDel(i64 %15, i64 %47)
  br label %$21
$29:
  %74 = phi i64 [%60, %$24] ; # X
; # (idxPut Var Key @)
  %75 = call i64 @idxPut(i64 %15, i64 %47, i64 %70)
  br label %$21
$21:
  %76 = phi i64 [%58, %$23], [%72, %$30], [%74, %$29] ; # X
  %77 = phi i64 [%59, %$23], [%73, %$30], [%75, %$29] ; # ->
; # drop
  %78 = inttoptr i64 %31 to i64*
  %79 = getelementptr i64, i64* %78, i32 1
  %80 = load i64, i64* %79
  %81 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %80, i64* %81
  br label %$15
$15:
  %82 = phi i64 [%23, %$13], [%76, %$21] ; # X
  %83 = phi i64 [%26, %$13], [%77, %$21] ; # ->
  ret i64 %83
}

define i64 @_Lup(i64) align 8 {
$1:
; # (let (X (cdr Exe) P (save (eval (++ X)))) (if (atom P) P (let Key...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (save (eval (++ X)))
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %17 = load i64, i64* %16
  %18 = alloca i64, i64 2, align 16
  %19 = ptrtoint i64* %18 to i64
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = add i64 %19, 8
  %22 = inttoptr i64 %21 to i64*
  store i64 %17, i64* %22
  %23 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %19, i64* %23
; # (if (atom P) P (let Key (eval (++ X)) (if (atom X) (loop (let Y (...
; # (atom P)
  %24 = and i64 %15, 15
  %25 = icmp ne i64 %24, 0
  br i1 %25, label %$7, label %$8
$7:
  %26 = phi i64 [%7, %$2] ; # X
  %27 = phi i64 [%15, %$2] ; # P
  br label %$9
$8:
  %28 = phi i64 [%7, %$2] ; # X
  %29 = phi i64 [%15, %$2] ; # P
; # (let Key (eval (++ X)) (if (atom X) (loop (let Y (car P) (cond ((...
; # (++ X)
  %30 = inttoptr i64 %28 to i64*
  %31 = load i64, i64* %30
  %32 = getelementptr i64, i64* %30, i32 1
  %33 = load i64, i64* %32
; # (eval (++ X))
  %34 = and i64 %31, 6
  %35 = icmp ne i64 %34, 0
  br i1 %35, label %$12, label %$11
$12:
  br label %$10
$11:
  %36 = and i64 %31, 8
  %37 = icmp ne i64 %36, 0
  br i1 %37, label %$14, label %$13
$14:
  %38 = inttoptr i64 %31 to i64*
  %39 = load i64, i64* %38
  br label %$10
$13:
  %40 = call i64 @evList(i64 %31)
  br label %$10
$10:
  %41 = phi i64 [%31, %$12], [%39, %$14], [%40, %$13] ; # ->
; # (if (atom X) (loop (let Y (car P) (cond ((t? Y) (setq P (cadr P))...
; # (atom X)
  %42 = and i64 %33, 15
  %43 = icmp ne i64 %42, 0
  br i1 %43, label %$15, label %$16
$15:
  %44 = phi i64 [%33, %$10] ; # X
  %45 = phi i64 [%29, %$10] ; # P
; # (loop (let Y (car P) (cond ((t? Y) (setq P (cadr P))) ((atom Y) (...
  br label %$18
$18:
  %46 = phi i64 [%44, %$15], [%105, %$30] ; # X
  %47 = phi i64 [%45, %$15], [%106, %$30] ; # P
; # (let Y (car P) (cond ((t? Y) (setq P (cadr P))) ((atom Y) (setq P...
; # (car P)
  %48 = inttoptr i64 %47 to i64*
  %49 = load i64, i64* %48
; # (cond ((t? Y) (setq P (cadr P))) ((atom Y) (setq P (cddr P))) (T ...
; # (t? Y)
  %50 = icmp eq i64 %49, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %50, label %$21, label %$20
$21:
  %51 = phi i64 [%46, %$18] ; # X
  %52 = phi i64 [%47, %$18] ; # P
; # (cadr P)
  %53 = inttoptr i64 %52 to i64*
  %54 = getelementptr i64, i64* %53, i32 1
  %55 = load i64, i64* %54
  %56 = inttoptr i64 %55 to i64*
  %57 = load i64, i64* %56
  br label %$19
$20:
  %58 = phi i64 [%46, %$18] ; # X
  %59 = phi i64 [%47, %$18] ; # P
; # (atom Y)
  %60 = and i64 %49, 15
  %61 = icmp ne i64 %60, 0
  br i1 %61, label %$23, label %$22
$23:
  %62 = phi i64 [%58, %$20] ; # X
  %63 = phi i64 [%59, %$20] ; # P
; # (cddr P)
  %64 = inttoptr i64 %63 to i64*
  %65 = getelementptr i64, i64* %64, i32 1
  %66 = load i64, i64* %65
  %67 = inttoptr i64 %66 to i64*
  %68 = getelementptr i64, i64* %67, i32 1
  %69 = load i64, i64* %68
  br label %$19
$22:
  %70 = phi i64 [%58, %$20] ; # X
  %71 = phi i64 [%59, %$20] ; # P
; # (? (=0 (compare (car Y) Key)) (car P))
; # (car Y)
  %72 = inttoptr i64 %49 to i64*
  %73 = load i64, i64* %72
; # (compare (car Y) Key)
  %74 = call i64 @compare(i64 %73, i64 %41)
; # (=0 (compare (car Y) Key))
  %75 = icmp eq i64 %74, 0
  br i1 %75, label %$26, label %$24
$26:
  %76 = phi i64 [%70, %$22] ; # X
  %77 = phi i64 [%71, %$22] ; # P
; # (car P)
  %78 = inttoptr i64 %77 to i64*
  %79 = load i64, i64* %78
  br label %$25
$24:
  %80 = phi i64 [%70, %$22] ; # X
  %81 = phi i64 [%71, %$22] ; # P
; # (cdr P)
  %82 = inttoptr i64 %81 to i64*
  %83 = getelementptr i64, i64* %82, i32 1
  %84 = load i64, i64* %83
; # (if (lt0 @) (cdr P) (car P))
; # (lt0 @)
  %85 = icmp slt i64 %74, 0
  br i1 %85, label %$27, label %$28
$27:
  %86 = phi i64 [%80, %$24] ; # X
  %87 = phi i64 [%84, %$24] ; # P
; # (cdr P)
  %88 = inttoptr i64 %87 to i64*
  %89 = getelementptr i64, i64* %88, i32 1
  %90 = load i64, i64* %89
  br label %$29
$28:
  %91 = phi i64 [%80, %$24] ; # X
  %92 = phi i64 [%84, %$24] ; # P
; # (car P)
  %93 = inttoptr i64 %92 to i64*
  %94 = load i64, i64* %93
  br label %$29
$29:
  %95 = phi i64 [%86, %$27], [%91, %$28] ; # X
  %96 = phi i64 [%87, %$27], [%92, %$28] ; # P
  %97 = phi i64 [%90, %$27], [%94, %$28] ; # ->
  br label %$19
$19:
  %98 = phi i64 [%51, %$21], [%62, %$23], [%95, %$29] ; # X
  %99 = phi i64 [%57, %$21], [%69, %$23], [%97, %$29] ; # P
  %100 = phi i64 [%57, %$21], [%69, %$23], [%97, %$29] ; # ->
; # (? (atom P) $Nil)
; # (atom P)
  %101 = and i64 %99, 15
  %102 = icmp ne i64 %101, 0
  br i1 %102, label %$31, label %$30
$31:
  %103 = phi i64 [%98, %$19] ; # X
  %104 = phi i64 [%99, %$19] ; # P
  br label %$25
$30:
  %105 = phi i64 [%98, %$19] ; # X
  %106 = phi i64 [%99, %$19] ; # P
  br label %$18
$25:
  %107 = phi i64 [%76, %$26], [%103, %$31] ; # X
  %108 = phi i64 [%77, %$26], [%104, %$31] ; # P
  %109 = phi i64 [%79, %$26], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$31] ; # ->
  br label %$17
$16:
  %110 = phi i64 [%33, %$10] ; # X
  %111 = phi i64 [%29, %$10] ; # P
; # (save Key)
  %112 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %113 = load i64, i64* %112
  %114 = alloca i64, i64 2, align 16
  %115 = ptrtoint i64* %114 to i64
  %116 = inttoptr i64 %115 to i64*
  store i64 %41, i64* %116
  %117 = add i64 %115, 8
  %118 = inttoptr i64 %117 to i64*
  store i64 %113, i64* %118
  %119 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %115, i64* %119
; # (let (Key2 (save (eval (car X))) Q (link (push NIL NIL)) Tos (lin...
; # (car X)
  %120 = inttoptr i64 %110 to i64*
  %121 = load i64, i64* %120
; # (eval (car X))
  %122 = and i64 %121, 6
  %123 = icmp ne i64 %122, 0
  br i1 %123, label %$34, label %$33
$34:
  br label %$32
$33:
  %124 = and i64 %121, 8
  %125 = icmp ne i64 %124, 0
  br i1 %125, label %$36, label %$35
$36:
  %126 = inttoptr i64 %121 to i64*
  %127 = load i64, i64* %126
  br label %$32
$35:
  %128 = call i64 @evList(i64 %121)
  br label %$32
$32:
  %129 = phi i64 [%121, %$34], [%127, %$36], [%128, %$35] ; # ->
; # (save (eval (car X)))
  %130 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %131 = load i64, i64* %130
  %132 = alloca i64, i64 2, align 16
  %133 = ptrtoint i64* %132 to i64
  %134 = inttoptr i64 %133 to i64*
  store i64 %129, i64* %134
  %135 = add i64 %133, 8
  %136 = inttoptr i64 %135 to i64*
  store i64 %131, i64* %136
  %137 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %133, i64* %137
; # (push NIL NIL)
  %138 = alloca i64, i64 2, align 16
  %139 = ptrtoint i64* %138 to i64
; # (link (push NIL NIL))
  %140 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %141 = load i64, i64* %140
  %142 = inttoptr i64 %139 to i64*
  %143 = getelementptr i64, i64* %142, i32 1
  store i64 %141, i64* %143
  %144 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %139, i64* %144
; # (push -ZERO NIL)
  %145 = alloca i64, i64 2, align 16
  %146 = ptrtoint i64* %145 to i64
  %147 = inttoptr i64 %146 to i64*
  store i64 10, i64* %147
; # (link (push -ZERO NIL))
  %148 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %149 = load i64, i64* %148
  %150 = inttoptr i64 %146 to i64*
  %151 = getelementptr i64, i64* %150, i32 1
  store i64 %149, i64* %151
  %152 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %146, i64* %152
; # (loop (loop (let Y (cdr (setq X (cdr P))) (? (atom Y)) (let Z (ca...
  br label %$37
$37:
  %153 = phi i64 [%110, %$32], [%303, %$53] ; # X
  %154 = phi i64 [%111, %$32], [%304, %$53] ; # P
  %155 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$32], [%305, %$53] ; # R
; # (loop (let Y (cdr (setq X (cdr P))) (? (atom Y)) (let Z (car P) (...
  br label %$38
$38:
  %156 = phi i64 [%153, %$37], [%189, %$44] ; # X
  %157 = phi i64 [%154, %$37], [%164, %$44] ; # P
  %158 = phi i64 [%155, %$37], [%191, %$44] ; # R
; # (let Y (cdr (setq X (cdr P))) (? (atom Y)) (let Z (car P) (? (t? ...
; # (cdr P)
  %159 = inttoptr i64 %157 to i64*
  %160 = getelementptr i64, i64* %159, i32 1
  %161 = load i64, i64* %160
; # (cdr (setq X (cdr P)))
  %162 = inttoptr i64 %161 to i64*
  %163 = getelementptr i64, i64* %162, i32 1
  %164 = load i64, i64* %163
; # (? (atom Y))
; # (atom Y)
  %165 = and i64 %164, 15
  %166 = icmp ne i64 %165, 0
  br i1 %166, label %$40, label %$39
$39:
  %167 = phi i64 [%161, %$38] ; # X
  %168 = phi i64 [%157, %$38] ; # P
  %169 = phi i64 [%158, %$38] ; # R
; # (let Z (car P) (? (t? Z)) (? (and (pair Z) (gt0 (compare (car Z) ...
; # (car P)
  %170 = inttoptr i64 %168 to i64*
  %171 = load i64, i64* %170
; # (? (t? Z))
; # (t? Z)
  %172 = icmp eq i64 %171, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %172, label %$40, label %$41
$41:
  %173 = phi i64 [%167, %$39] ; # X
  %174 = phi i64 [%168, %$39] ; # P
  %175 = phi i64 [%169, %$39] ; # R
; # (? (and (pair Z) (gt0 (compare (car Z) Key2))))
; # (and (pair Z) (gt0 (compare (car Z) Key2)))
; # (pair Z)
  %176 = and i64 %171, 15
  %177 = icmp eq i64 %176, 0
  br i1 %177, label %$43, label %$42
$43:
  %178 = phi i64 [%173, %$41] ; # X
  %179 = phi i64 [%174, %$41] ; # P
  %180 = phi i64 [%175, %$41] ; # R
; # (car Z)
  %181 = inttoptr i64 %171 to i64*
  %182 = load i64, i64* %181
; # (compare (car Z) Key2)
  %183 = call i64 @compare(i64 %182, i64 %129)
; # (gt0 (compare (car Z) Key2))
  %184 = icmp sgt i64 %183, 0
  br label %$42
$42:
  %185 = phi i64 [%173, %$41], [%178, %$43] ; # X
  %186 = phi i64 [%174, %$41], [%179, %$43] ; # P
  %187 = phi i64 [%175, %$41], [%180, %$43] ; # R
  %188 = phi i1 [0, %$41], [%184, %$43] ; # ->
  br i1 %188, label %$40, label %$44
$44:
  %189 = phi i64 [%185, %$42] ; # X
  %190 = phi i64 [%186, %$42] ; # P
  %191 = phi i64 [%187, %$42] ; # R
; # (let Z P (setq P Y) (set 2 X (val Tos)) (set Tos Z))
; # (set 2 X (val Tos))
; # (val Tos)
  %192 = inttoptr i64 %146 to i64*
  %193 = load i64, i64* %192
  %194 = inttoptr i64 %189 to i64*
  %195 = getelementptr i64, i64* %194, i32 1
  store i64 %193, i64* %195
; # (set Tos Z)
  %196 = inttoptr i64 %146 to i64*
  store i64 %190, i64* %196
  br label %$38
$40:
  %197 = phi i64 [%161, %$38], [%167, %$39], [%185, %$42] ; # X
  %198 = phi i64 [%157, %$38], [%168, %$39], [%186, %$42] ; # P
  %199 = phi i64 [%158, %$38], [%169, %$39], [%187, %$42] ; # R
  %200 = phi i64 [0, %$38], [0, %$39], [0, %$42] ; # ->
; # (set Q P)
  %201 = inttoptr i64 %139 to i64*
  store i64 %198, i64* %201
; # (loop (when (and (pair (setq X (car P))) (ge0 (compare (car X) Ke...
  br label %$45
$45:
  %202 = phi i64 [%197, %$40], [%299, %$59] ; # X
  %203 = phi i64 [%198, %$40], [%300, %$59] ; # P
  %204 = phi i64 [%199, %$40], [%301, %$59] ; # R
; # (when (and (pair (setq X (car P))) (ge0 (compare (car X) Key))) (...
; # (and (pair (setq X (car P))) (ge0 (compare (car X) Key)))
; # (car P)
  %205 = inttoptr i64 %203 to i64*
  %206 = load i64, i64* %205
; # (pair (setq X (car P)))
  %207 = and i64 %206, 15
  %208 = icmp eq i64 %207, 0
  br i1 %208, label %$47, label %$46
$47:
  %209 = phi i64 [%206, %$45] ; # X
  %210 = phi i64 [%203, %$45] ; # P
  %211 = phi i64 [%204, %$45] ; # R
; # (car X)
  %212 = inttoptr i64 %209 to i64*
  %213 = load i64, i64* %212
; # (compare (car X) Key)
  %214 = call i64 @compare(i64 %213, i64 %41)
; # (ge0 (compare (car X) Key))
  %215 = icmp sge i64 %214, 0
  br label %$46
$46:
  %216 = phi i64 [%206, %$45], [%209, %$47] ; # X
  %217 = phi i64 [%203, %$45], [%210, %$47] ; # P
  %218 = phi i64 [%204, %$45], [%211, %$47] ; # R
  %219 = phi i1 [0, %$45], [%215, %$47] ; # ->
  br i1 %219, label %$48, label %$49
$48:
  %220 = phi i64 [%216, %$46] ; # X
  %221 = phi i64 [%217, %$46] ; # P
  %222 = phi i64 [%218, %$46] ; # R
; # (when (le0 (compare (car X) Key2)) (setq R (cons X R)))
; # (car X)
  %223 = inttoptr i64 %220 to i64*
  %224 = load i64, i64* %223
; # (compare (car X) Key2)
  %225 = call i64 @compare(i64 %224, i64 %129)
; # (le0 (compare (car X) Key2))
  %226 = icmp sle i64 %225, 0
  br i1 %226, label %$50, label %$51
$50:
  %227 = phi i64 [%220, %$48] ; # X
  %228 = phi i64 [%221, %$48] ; # P
  %229 = phi i64 [%222, %$48] ; # R
; # (cons X R)
  %230 = call i64 @cons(i64 %227, i64 %229)
  br label %$51
$51:
  %231 = phi i64 [%220, %$48], [%227, %$50] ; # X
  %232 = phi i64 [%221, %$48], [%228, %$50] ; # P
  %233 = phi i64 [%222, %$48], [%230, %$50] ; # R
; # (? (pair (car (setq X (cdr P)))) (let Z P (setq P @) (set X (val ...
; # (cdr P)
  %234 = inttoptr i64 %232 to i64*
  %235 = getelementptr i64, i64* %234, i32 1
  %236 = load i64, i64* %235
; # (car (setq X (cdr P)))
  %237 = inttoptr i64 %236 to i64*
  %238 = load i64, i64* %237
; # (pair (car (setq X (cdr P))))
  %239 = and i64 %238, 15
  %240 = icmp eq i64 %239, 0
  br i1 %240, label %$54, label %$52
$54:
  %241 = phi i64 [%236, %$51] ; # X
  %242 = phi i64 [%232, %$51] ; # P
  %243 = phi i64 [%233, %$51] ; # R
; # (let Z P (setq P @) (set X (val Tos)) (set Tos (| Z 8)) (set Q P)...
; # (set X (val Tos))
; # (val Tos)
  %244 = inttoptr i64 %146 to i64*
  %245 = load i64, i64* %244
  %246 = inttoptr i64 %241 to i64*
  store i64 %245, i64* %246
; # (set Tos (| Z 8))
; # (| Z 8)
  %247 = or i64 %242, 8
  %248 = inttoptr i64 %146 to i64*
  store i64 %247, i64* %248
; # (set Q P)
  %249 = inttoptr i64 %139 to i64*
  store i64 %238, i64* %249
  br label %$53
$52:
  %250 = phi i64 [%236, %$51] ; # X
  %251 = phi i64 [%232, %$51] ; # P
  %252 = phi i64 [%233, %$51] ; # R
  br label %$49
$49:
  %253 = phi i64 [%216, %$46], [%250, %$52] ; # X
  %254 = phi i64 [%217, %$46], [%251, %$52] ; # P
  %255 = phi i64 [%218, %$46], [%252, %$52] ; # R
; # (loop (when (== -ZERO (setq X (val Tos))) (ret R)) (? (=0 (& X 8)...
  br label %$55
$55:
  %256 = phi i64 [%253, %$49], [%290, %$58] ; # X
  %257 = phi i64 [%254, %$49], [%290, %$58] ; # P
  %258 = phi i64 [%255, %$49], [%289, %$58] ; # R
; # (when (== -ZERO (setq X (val Tos))) (ret R))
; # (val Tos)
  %259 = inttoptr i64 %146 to i64*
  %260 = load i64, i64* %259
; # (== -ZERO (setq X (val Tos)))
  %261 = icmp eq i64 10, %260
  br i1 %261, label %$56, label %$57
$56:
  %262 = phi i64 [%260, %$55] ; # X
  %263 = phi i64 [%257, %$55] ; # P
  %264 = phi i64 [%258, %$55] ; # R
; # (ret R)
; # (drop *Safe)
  %265 = inttoptr i64 %19 to i64*
  %266 = getelementptr i64, i64* %265, i32 1
  %267 = load i64, i64* %266
  %268 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %267, i64* %268
  ret i64 %264
$57:
  %269 = phi i64 [%260, %$55] ; # X
  %270 = phi i64 [%257, %$55] ; # P
  %271 = phi i64 [%258, %$55] ; # R
; # (? (=0 (& X 8)) (let Y (cdr X) (set Tos (cdr Y)) (set 2 Y P) (set...
; # (& X 8)
  %272 = and i64 %269, 8
; # (=0 (& X 8))
  %273 = icmp eq i64 %272, 0
  br i1 %273, label %$60, label %$58
$60:
  %274 = phi i64 [%269, %$57] ; # X
  %275 = phi i64 [%270, %$57] ; # P
  %276 = phi i64 [%271, %$57] ; # R
; # (let Y (cdr X) (set Tos (cdr Y)) (set 2 Y P) (setq P X) (set Q P)...
; # (cdr X)
  %277 = inttoptr i64 %274 to i64*
  %278 = getelementptr i64, i64* %277, i32 1
  %279 = load i64, i64* %278
; # (set Tos (cdr Y))
; # (cdr Y)
  %280 = inttoptr i64 %279 to i64*
  %281 = getelementptr i64, i64* %280, i32 1
  %282 = load i64, i64* %281
  %283 = inttoptr i64 %146 to i64*
  store i64 %282, i64* %283
; # (set 2 Y P)
  %284 = inttoptr i64 %279 to i64*
  %285 = getelementptr i64, i64* %284, i32 1
  store i64 %275, i64* %285
; # (set Q P)
  %286 = inttoptr i64 %139 to i64*
  store i64 %274, i64* %286
  br label %$59
$58:
  %287 = phi i64 [%269, %$57] ; # X
  %288 = phi i64 [%270, %$57] ; # P
  %289 = phi i64 [%271, %$57] ; # R
; # (& X -9)
  %290 = and i64 %287, -9
; # (let Y (cdr X) (set Tos (car Y)) (set Y P) (setq P X) (set Q P))
; # (cdr X)
  %291 = inttoptr i64 %290 to i64*
  %292 = getelementptr i64, i64* %291, i32 1
  %293 = load i64, i64* %292
; # (set Tos (car Y))
; # (car Y)
  %294 = inttoptr i64 %293 to i64*
  %295 = load i64, i64* %294
  %296 = inttoptr i64 %146 to i64*
  store i64 %295, i64* %296
; # (set Y P)
  %297 = inttoptr i64 %293 to i64*
  store i64 %288, i64* %297
; # (set Q P)
  %298 = inttoptr i64 %139 to i64*
  store i64 %290, i64* %298
  br label %$55
$59:
  %299 = phi i64 [%274, %$60] ; # X
  %300 = phi i64 [%274, %$60] ; # P
  %301 = phi i64 [%276, %$60] ; # R
  %302 = phi i64 [%274, %$60] ; # ->
  br label %$45
$53:
  %303 = phi i64 [%241, %$54] ; # X
  %304 = phi i64 [%238, %$54] ; # P
  %305 = phi i64 [%243, %$54] ; # R
  %306 = phi i64 [%238, %$54] ; # ->
  br label %$37
$17:
  %307 = phi i64 [%107, %$25] ; # X
  %308 = phi i64 [%108, %$25] ; # P
  %309 = phi i64 [%109, %$25] ; # ->
  br label %$9
$9:
  %310 = phi i64 [%26, %$7], [%307, %$17] ; # X
  %311 = phi i64 [%27, %$7], [%308, %$17] ; # P
  %312 = phi i64 [%27, %$7], [%309, %$17] ; # ->
; # (drop *Safe)
  %313 = inttoptr i64 %19 to i64*
  %314 = getelementptr i64, i64* %313, i32 1
  %315 = load i64, i64* %314
  %316 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %315, i64* %316
  ret i64 %312
}

define void @put(i64, i64, i64) align 8 {
$1:
; # (let Tail (val (tail Sym)) (unless (num? Tail) (let (L (any (& Ta...
; # (tail Sym)
  %3 = add i64 %0, -8
; # (val (tail Sym))
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (unless (num? Tail) (let (L (any (& Tail -9)) X (car L)) (if (ato...
; # (num? Tail)
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$3, label %$2
$2:
  %8 = phi i64 [%2, %$1] ; # Val
; # (let (L (any (& Tail -9)) X (car L)) (if (atom X) (when (== Key X...
; # (& Tail -9)
  %9 = and i64 %5, -9
; # (any (& Tail -9))
; # (car L)
  %10 = inttoptr i64 %9 to i64*
  %11 = load i64, i64* %10
; # (if (atom X) (when (== Key X) (cond ((nil? Val) (shift L) (set (t...
; # (atom X)
  %12 = and i64 %11, 15
  %13 = icmp ne i64 %12, 0
  br i1 %13, label %$4, label %$5
$4:
  %14 = phi i64 [%8, %$2] ; # Val
  %15 = phi i64 [%9, %$2] ; # L
  %16 = phi i64 [%11, %$2] ; # X
; # (when (== Key X) (cond ((nil? Val) (shift L) (set (tail Sym) (if ...
; # (== Key X)
  %17 = icmp eq i64 %1, %16
  br i1 %17, label %$7, label %$8
$7:
  %18 = phi i64 [%14, %$4] ; # Val
  %19 = phi i64 [%15, %$4] ; # L
  %20 = phi i64 [%16, %$4] ; # X
; # (cond ((nil? Val) (shift L) (set (tail Sym) (if (sym? Tail) (sym ...
; # (nil? Val)
  %21 = icmp eq i64 %18, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %21, label %$11, label %$10
$11:
  %22 = phi i64 [%18, %$7] ; # Val
  %23 = phi i64 [%19, %$7] ; # L
  %24 = phi i64 [%20, %$7] ; # X
; # (shift L)
  %25 = inttoptr i64 %23 to i64*
  %26 = getelementptr i64, i64* %25, i32 1
  %27 = load i64, i64* %26
; # (set (tail Sym) (if (sym? Tail) (sym L) L))
; # (tail Sym)
  %28 = add i64 %0, -8
; # (if (sym? Tail) (sym L) L)
; # (sym? Tail)
  %29 = and i64 %5, 8
  %30 = icmp ne i64 %29, 0
  br i1 %30, label %$12, label %$13
$12:
  %31 = phi i64 [%22, %$11] ; # Val
  %32 = phi i64 [%27, %$11] ; # L
  %33 = phi i64 [%24, %$11] ; # X
; # (sym L)
  %34 = or i64 %32, 8
  br label %$14
$13:
  %35 = phi i64 [%22, %$11] ; # Val
  %36 = phi i64 [%27, %$11] ; # L
  %37 = phi i64 [%24, %$11] ; # X
  br label %$14
$14:
  %38 = phi i64 [%31, %$12], [%35, %$13] ; # Val
  %39 = phi i64 [%32, %$12], [%36, %$13] ; # L
  %40 = phi i64 [%33, %$12], [%37, %$13] ; # X
  %41 = phi i64 [%34, %$12], [%36, %$13] ; # ->
  %42 = inttoptr i64 %28 to i64*
  store i64 %41, i64* %42
  br label %$9
$10:
  %43 = phi i64 [%18, %$7] ; # Val
  %44 = phi i64 [%19, %$7] ; # L
  %45 = phi i64 [%20, %$7] ; # X
; # (<> Val $T)
  %46 = icmp ne i64 %43, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %46, label %$16, label %$15
$16:
  %47 = phi i64 [%43, %$10] ; # Val
  %48 = phi i64 [%44, %$10] ; # L
  %49 = phi i64 [%45, %$10] ; # X
; # (set L (cons Val Key))
; # (cons Val Key)
  %50 = call i64 @cons(i64 %47, i64 %1)
  %51 = inttoptr i64 %48 to i64*
  store i64 %50, i64* %51
  br label %$9
$15:
  %52 = phi i64 [%43, %$10] ; # Val
  %53 = phi i64 [%44, %$10] ; # L
  %54 = phi i64 [%45, %$10] ; # X
  br label %$9
$9:
  %55 = phi i64 [%38, %$14], [%47, %$16], [%52, %$15] ; # Val
  %56 = phi i64 [%39, %$14], [%48, %$16], [%53, %$15] ; # L
  %57 = phi i64 [%40, %$14], [%49, %$16], [%54, %$15] ; # X
  %58 = phi i64 [%41, %$14], [%50, %$16], [0, %$15] ; # ->
; # (ret)
  ret void
$8:
  %59 = phi i64 [%14, %$4] ; # Val
  %60 = phi i64 [%15, %$4] ; # L
  %61 = phi i64 [%16, %$4] ; # X
  br label %$6
$5:
  %62 = phi i64 [%8, %$2] ; # Val
  %63 = phi i64 [%9, %$2] ; # L
  %64 = phi i64 [%11, %$2] ; # X
; # (when (== Key (cdr X)) (cond ((nil? Val) (shift L) (set (tail Sym...
; # (cdr X)
  %65 = inttoptr i64 %64 to i64*
  %66 = getelementptr i64, i64* %65, i32 1
  %67 = load i64, i64* %66
; # (== Key (cdr X))
  %68 = icmp eq i64 %1, %67
  br i1 %68, label %$17, label %$18
$17:
  %69 = phi i64 [%62, %$5] ; # Val
  %70 = phi i64 [%63, %$5] ; # L
  %71 = phi i64 [%64, %$5] ; # X
; # (cond ((nil? Val) (shift L) (set (tail Sym) (if (sym? Tail) (sym ...
; # (nil? Val)
  %72 = icmp eq i64 %69, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %72, label %$21, label %$20
$21:
  %73 = phi i64 [%69, %$17] ; # Val
  %74 = phi i64 [%70, %$17] ; # L
  %75 = phi i64 [%71, %$17] ; # X
; # (shift L)
  %76 = inttoptr i64 %74 to i64*
  %77 = getelementptr i64, i64* %76, i32 1
  %78 = load i64, i64* %77
; # (set (tail Sym) (if (sym? Tail) (sym L) L))
; # (tail Sym)
  %79 = add i64 %0, -8
; # (if (sym? Tail) (sym L) L)
; # (sym? Tail)
  %80 = and i64 %5, 8
  %81 = icmp ne i64 %80, 0
  br i1 %81, label %$22, label %$23
$22:
  %82 = phi i64 [%73, %$21] ; # Val
  %83 = phi i64 [%78, %$21] ; # L
  %84 = phi i64 [%75, %$21] ; # X
; # (sym L)
  %85 = or i64 %83, 8
  br label %$24
$23:
  %86 = phi i64 [%73, %$21] ; # Val
  %87 = phi i64 [%78, %$21] ; # L
  %88 = phi i64 [%75, %$21] ; # X
  br label %$24
$24:
  %89 = phi i64 [%82, %$22], [%86, %$23] ; # Val
  %90 = phi i64 [%83, %$22], [%87, %$23] ; # L
  %91 = phi i64 [%84, %$22], [%88, %$23] ; # X
  %92 = phi i64 [%85, %$22], [%87, %$23] ; # ->
  %93 = inttoptr i64 %79 to i64*
  store i64 %92, i64* %93
  br label %$19
$20:
  %94 = phi i64 [%69, %$17] ; # Val
  %95 = phi i64 [%70, %$17] ; # L
  %96 = phi i64 [%71, %$17] ; # X
; # (t? Val)
  %97 = icmp eq i64 %94, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %97, label %$26, label %$25
$26:
  %98 = phi i64 [%94, %$20] ; # Val
  %99 = phi i64 [%95, %$20] ; # L
  %100 = phi i64 [%96, %$20] ; # X
; # (set L Key)
  %101 = inttoptr i64 %99 to i64*
  store i64 %1, i64* %101
  br label %$19
$25:
  %102 = phi i64 [%94, %$20] ; # Val
  %103 = phi i64 [%95, %$20] ; # L
  %104 = phi i64 [%96, %$20] ; # X
; # (set X Val)
  %105 = inttoptr i64 %104 to i64*
  store i64 %102, i64* %105
  br label %$19
$19:
  %106 = phi i64 [%89, %$24], [%98, %$26], [%102, %$25] ; # Val
  %107 = phi i64 [%90, %$24], [%99, %$26], [%103, %$25] ; # L
  %108 = phi i64 [%91, %$24], [%100, %$26], [%104, %$25] ; # X
  %109 = phi i64 [%92, %$24], [%1, %$26], [%102, %$25] ; # ->
; # (ret)
  ret void
$18:
  %110 = phi i64 [%62, %$5] ; # Val
  %111 = phi i64 [%63, %$5] ; # L
  %112 = phi i64 [%64, %$5] ; # X
  br label %$6
$6:
  %113 = phi i64 [%59, %$8], [%110, %$18] ; # Val
  %114 = phi i64 [%60, %$8], [%111, %$18] ; # L
  %115 = phi i64 [%61, %$8], [%112, %$18] ; # X
; # (while (pair (setq X (cdr L))) (let Y (car X) (if (atom Y) (when ...
  br label %$27
$27:
  %116 = phi i64 [%113, %$6], [%258, %$32] ; # Val
  %117 = phi i64 [%114, %$6], [%260, %$32] ; # L
  %118 = phi i64 [%115, %$6], [%260, %$32] ; # X
; # (cdr L)
  %119 = inttoptr i64 %117 to i64*
  %120 = getelementptr i64, i64* %119, i32 1
  %121 = load i64, i64* %120
; # (pair (setq X (cdr L)))
  %122 = and i64 %121, 15
  %123 = icmp eq i64 %122, 0
  br i1 %123, label %$28, label %$29
$28:
  %124 = phi i64 [%116, %$27] ; # Val
  %125 = phi i64 [%117, %$27] ; # L
  %126 = phi i64 [%121, %$27] ; # X
; # (let Y (car X) (if (atom Y) (when (== Key Y) (if (nil? Val) (set ...
; # (car X)
  %127 = inttoptr i64 %126 to i64*
  %128 = load i64, i64* %127
; # (if (atom Y) (when (== Key Y) (if (nil? Val) (set 2 L (cdr X)) (u...
; # (atom Y)
  %129 = and i64 %128, 15
  %130 = icmp ne i64 %129, 0
  br i1 %130, label %$30, label %$31
$30:
  %131 = phi i64 [%124, %$28] ; # Val
  %132 = phi i64 [%125, %$28] ; # L
  %133 = phi i64 [%126, %$28] ; # X
; # (when (== Key Y) (if (nil? Val) (set 2 L (cdr X)) (unless (t? Val...
; # (== Key Y)
  %134 = icmp eq i64 %1, %128
  br i1 %134, label %$33, label %$34
$33:
  %135 = phi i64 [%131, %$30] ; # Val
  %136 = phi i64 [%132, %$30] ; # L
  %137 = phi i64 [%133, %$30] ; # X
; # (if (nil? Val) (set 2 L (cdr X)) (unless (t? Val) (set X (cons Va...
; # (nil? Val)
  %138 = icmp eq i64 %135, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %138, label %$35, label %$36
$35:
  %139 = phi i64 [%135, %$33] ; # Val
  %140 = phi i64 [%136, %$33] ; # L
  %141 = phi i64 [%137, %$33] ; # X
; # (set 2 L (cdr X))
; # (cdr X)
  %142 = inttoptr i64 %141 to i64*
  %143 = getelementptr i64, i64* %142, i32 1
  %144 = load i64, i64* %143
  %145 = inttoptr i64 %140 to i64*
  %146 = getelementptr i64, i64* %145, i32 1
  store i64 %144, i64* %146
  br label %$37
$36:
  %147 = phi i64 [%135, %$33] ; # Val
  %148 = phi i64 [%136, %$33] ; # L
  %149 = phi i64 [%137, %$33] ; # X
; # (unless (t? Val) (set X (cons Val Key)))
; # (t? Val)
  %150 = icmp eq i64 %147, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %150, label %$39, label %$38
$38:
  %151 = phi i64 [%147, %$36] ; # Val
  %152 = phi i64 [%148, %$36] ; # L
  %153 = phi i64 [%149, %$36] ; # X
; # (set X (cons Val Key))
; # (cons Val Key)
  %154 = call i64 @cons(i64 %151, i64 %1)
  %155 = inttoptr i64 %153 to i64*
  store i64 %154, i64* %155
  br label %$39
$39:
  %156 = phi i64 [%147, %$36], [%151, %$38] ; # Val
  %157 = phi i64 [%148, %$36], [%152, %$38] ; # L
  %158 = phi i64 [%149, %$36], [%153, %$38] ; # X
; # (set 2 L (cdr X))
; # (cdr X)
  %159 = inttoptr i64 %158 to i64*
  %160 = getelementptr i64, i64* %159, i32 1
  %161 = load i64, i64* %160
  %162 = inttoptr i64 %157 to i64*
  %163 = getelementptr i64, i64* %162, i32 1
  store i64 %161, i64* %163
; # (ifn (sym? Tail) (set 2 X Tail) (set 2 X (& Tail -9)) (setq X (sy...
; # (sym? Tail)
  %164 = and i64 %5, 8
  %165 = icmp ne i64 %164, 0
  br i1 %165, label %$41, label %$40
$40:
  %166 = phi i64 [%156, %$39] ; # Val
  %167 = phi i64 [%157, %$39] ; # L
  %168 = phi i64 [%158, %$39] ; # X
; # (set 2 X Tail)
  %169 = inttoptr i64 %168 to i64*
  %170 = getelementptr i64, i64* %169, i32 1
  store i64 %5, i64* %170
  br label %$42
$41:
  %171 = phi i64 [%156, %$39] ; # Val
  %172 = phi i64 [%157, %$39] ; # L
  %173 = phi i64 [%158, %$39] ; # X
; # (set 2 X (& Tail -9))
; # (& Tail -9)
  %174 = and i64 %5, -9
  %175 = inttoptr i64 %173 to i64*
  %176 = getelementptr i64, i64* %175, i32 1
  store i64 %174, i64* %176
; # (sym X)
  %177 = or i64 %173, 8
  br label %$42
$42:
  %178 = phi i64 [%166, %$40], [%171, %$41] ; # Val
  %179 = phi i64 [%167, %$40], [%172, %$41] ; # L
  %180 = phi i64 [%168, %$40], [%177, %$41] ; # X
  %181 = phi i64 [%5, %$40], [%177, %$41] ; # ->
; # (set (tail Sym) X)
; # (tail Sym)
  %182 = add i64 %0, -8
  %183 = inttoptr i64 %182 to i64*
  store i64 %180, i64* %183
  br label %$37
$37:
  %184 = phi i64 [%139, %$35], [%178, %$42] ; # Val
  %185 = phi i64 [%140, %$35], [%179, %$42] ; # L
  %186 = phi i64 [%141, %$35], [%180, %$42] ; # X
  %187 = phi i64 [%144, %$35], [%180, %$42] ; # ->
; # (ret)
  ret void
$34:
  %188 = phi i64 [%131, %$30] ; # Val
  %189 = phi i64 [%132, %$30] ; # L
  %190 = phi i64 [%133, %$30] ; # X
  br label %$32
$31:
  %191 = phi i64 [%124, %$28] ; # Val
  %192 = phi i64 [%125, %$28] ; # L
  %193 = phi i64 [%126, %$28] ; # X
; # (when (== Key (cdr Y)) (if (nil? Val) (set 2 L (cdr X)) (if (t? V...
; # (cdr Y)
  %194 = inttoptr i64 %128 to i64*
  %195 = getelementptr i64, i64* %194, i32 1
  %196 = load i64, i64* %195
; # (== Key (cdr Y))
  %197 = icmp eq i64 %1, %196
  br i1 %197, label %$43, label %$44
$43:
  %198 = phi i64 [%191, %$31] ; # Val
  %199 = phi i64 [%192, %$31] ; # L
  %200 = phi i64 [%193, %$31] ; # X
; # (if (nil? Val) (set 2 L (cdr X)) (if (t? Val) (set X Key) (set Y ...
; # (nil? Val)
  %201 = icmp eq i64 %198, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %201, label %$45, label %$46
$45:
  %202 = phi i64 [%198, %$43] ; # Val
  %203 = phi i64 [%199, %$43] ; # L
  %204 = phi i64 [%200, %$43] ; # X
; # (set 2 L (cdr X))
; # (cdr X)
  %205 = inttoptr i64 %204 to i64*
  %206 = getelementptr i64, i64* %205, i32 1
  %207 = load i64, i64* %206
  %208 = inttoptr i64 %203 to i64*
  %209 = getelementptr i64, i64* %208, i32 1
  store i64 %207, i64* %209
  br label %$47
$46:
  %210 = phi i64 [%198, %$43] ; # Val
  %211 = phi i64 [%199, %$43] ; # L
  %212 = phi i64 [%200, %$43] ; # X
; # (if (t? Val) (set X Key) (set Y Val))
; # (t? Val)
  %213 = icmp eq i64 %210, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %213, label %$48, label %$49
$48:
  %214 = phi i64 [%210, %$46] ; # Val
  %215 = phi i64 [%211, %$46] ; # L
  %216 = phi i64 [%212, %$46] ; # X
; # (set X Key)
  %217 = inttoptr i64 %216 to i64*
  store i64 %1, i64* %217
  br label %$50
$49:
  %218 = phi i64 [%210, %$46] ; # Val
  %219 = phi i64 [%211, %$46] ; # L
  %220 = phi i64 [%212, %$46] ; # X
; # (set Y Val)
  %221 = inttoptr i64 %128 to i64*
  store i64 %218, i64* %221
  br label %$50
$50:
  %222 = phi i64 [%214, %$48], [%218, %$49] ; # Val
  %223 = phi i64 [%215, %$48], [%219, %$49] ; # L
  %224 = phi i64 [%216, %$48], [%220, %$49] ; # X
  %225 = phi i64 [%1, %$48], [%218, %$49] ; # ->
; # (set 2 L (cdr X))
; # (cdr X)
  %226 = inttoptr i64 %224 to i64*
  %227 = getelementptr i64, i64* %226, i32 1
  %228 = load i64, i64* %227
  %229 = inttoptr i64 %223 to i64*
  %230 = getelementptr i64, i64* %229, i32 1
  store i64 %228, i64* %230
; # (ifn (sym? Tail) (set 2 X Tail) (set 2 X (& Tail -9)) (setq X (sy...
; # (sym? Tail)
  %231 = and i64 %5, 8
  %232 = icmp ne i64 %231, 0
  br i1 %232, label %$52, label %$51
$51:
  %233 = phi i64 [%222, %$50] ; # Val
  %234 = phi i64 [%223, %$50] ; # L
  %235 = phi i64 [%224, %$50] ; # X
; # (set 2 X Tail)
  %236 = inttoptr i64 %235 to i64*
  %237 = getelementptr i64, i64* %236, i32 1
  store i64 %5, i64* %237
  br label %$53
$52:
  %238 = phi i64 [%222, %$50] ; # Val
  %239 = phi i64 [%223, %$50] ; # L
  %240 = phi i64 [%224, %$50] ; # X
; # (set 2 X (& Tail -9))
; # (& Tail -9)
  %241 = and i64 %5, -9
  %242 = inttoptr i64 %240 to i64*
  %243 = getelementptr i64, i64* %242, i32 1
  store i64 %241, i64* %243
; # (sym X)
  %244 = or i64 %240, 8
  br label %$53
$53:
  %245 = phi i64 [%233, %$51], [%238, %$52] ; # Val
  %246 = phi i64 [%234, %$51], [%239, %$52] ; # L
  %247 = phi i64 [%235, %$51], [%244, %$52] ; # X
  %248 = phi i64 [%5, %$51], [%244, %$52] ; # ->
; # (set (tail Sym) X)
; # (tail Sym)
  %249 = add i64 %0, -8
  %250 = inttoptr i64 %249 to i64*
  store i64 %247, i64* %250
  br label %$47
$47:
  %251 = phi i64 [%202, %$45], [%245, %$53] ; # Val
  %252 = phi i64 [%203, %$45], [%246, %$53] ; # L
  %253 = phi i64 [%204, %$45], [%247, %$53] ; # X
  %254 = phi i64 [%207, %$45], [%247, %$53] ; # ->
; # (ret)
  ret void
$44:
  %255 = phi i64 [%191, %$31] ; # Val
  %256 = phi i64 [%192, %$31] ; # L
  %257 = phi i64 [%193, %$31] ; # X
  br label %$32
$32:
  %258 = phi i64 [%188, %$34], [%255, %$44] ; # Val
  %259 = phi i64 [%189, %$34], [%256, %$44] ; # L
  %260 = phi i64 [%190, %$34], [%257, %$44] ; # X
  br label %$27
$29:
  %261 = phi i64 [%116, %$27] ; # Val
  %262 = phi i64 [%117, %$27] ; # L
  %263 = phi i64 [%121, %$27] ; # X
  br label %$3
$3:
  %264 = phi i64 [%2, %$1], [%261, %$29] ; # Val
; # (unless (nil? Val) (setq Val (if (t? Val) Key (cons Val Key))) (s...
; # (nil? Val)
  %265 = icmp eq i64 %264, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %265, label %$55, label %$54
$54:
  %266 = phi i64 [%264, %$3] ; # Val
; # (if (t? Val) Key (cons Val Key))
; # (t? Val)
  %267 = icmp eq i64 %266, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %267, label %$56, label %$57
$56:
  %268 = phi i64 [%266, %$54] ; # Val
  br label %$58
$57:
  %269 = phi i64 [%266, %$54] ; # Val
; # (cons Val Key)
  %270 = call i64 @cons(i64 %269, i64 %1)
  br label %$58
$58:
  %271 = phi i64 [%268, %$56], [%269, %$57] ; # Val
  %272 = phi i64 [%1, %$56], [%270, %$57] ; # ->
; # (set (tail Sym) (if (sym? Tail) (sym (cons Val (& Tail -9))) (con...
; # (tail Sym)
  %273 = add i64 %0, -8
; # (if (sym? Tail) (sym (cons Val (& Tail -9))) (cons Val Tail))
; # (sym? Tail)
  %274 = and i64 %5, 8
  %275 = icmp ne i64 %274, 0
  br i1 %275, label %$59, label %$60
$59:
  %276 = phi i64 [%272, %$58] ; # Val
; # (& Tail -9)
  %277 = and i64 %5, -9
; # (cons Val (& Tail -9))
  %278 = call i64 @cons(i64 %276, i64 %277)
; # (sym (cons Val (& Tail -9)))
  %279 = or i64 %278, 8
  br label %$61
$60:
  %280 = phi i64 [%272, %$58] ; # Val
; # (cons Val Tail)
  %281 = call i64 @cons(i64 %280, i64 %5)
  br label %$61
$61:
  %282 = phi i64 [%276, %$59], [%280, %$60] ; # Val
  %283 = phi i64 [%279, %$59], [%281, %$60] ; # ->
  %284 = inttoptr i64 %273 to i64*
  store i64 %283, i64* %284
  br label %$55
$55:
  %285 = phi i64 [%264, %$3], [%282, %$61] ; # Val
  ret void
}

define void @putn(i64, i64, i64, i64) align 8 {
$1:
; # (nond ((num? Key) (loop (let X (car Lst) (? (and (pair X) (== Key...
; # (num? Key)
  %4 = and i64 %2, 6
  %5 = icmp ne i64 %4, 0
  br i1 %5, label %$3, label %$4
$4:
  %6 = phi i64 [%1, %$1] ; # Lst
; # (loop (let X (car Lst) (? (and (pair X) (== Key (car X))) (set 2 ...
  br label %$5
$5:
  %7 = phi i64 [%6, %$4], [%28, %$12] ; # Lst
; # (let X (car Lst) (? (and (pair X) (== Key (car X))) (set 2 X Val)...
; # (car Lst)
  %8 = inttoptr i64 %7 to i64*
  %9 = load i64, i64* %8
; # (? (and (pair X) (== Key (car X))) (set 2 X Val))
; # (and (pair X) (== Key (car X)))
; # (pair X)
  %10 = and i64 %9, 15
  %11 = icmp eq i64 %10, 0
  br i1 %11, label %$7, label %$6
$7:
  %12 = phi i64 [%7, %$5] ; # Lst
; # (car X)
  %13 = inttoptr i64 %9 to i64*
  %14 = load i64, i64* %13
; # (== Key (car X))
  %15 = icmp eq i64 %2, %14
  br label %$6
$6:
  %16 = phi i64 [%7, %$5], [%12, %$7] ; # Lst
  %17 = phi i1 [0, %$5], [%15, %$7] ; # ->
  br i1 %17, label %$10, label %$8
$10:
  %18 = phi i64 [%16, %$6] ; # Lst
; # (set 2 X Val)
  %19 = inttoptr i64 %9 to i64*
  %20 = getelementptr i64, i64* %19, i32 1
  store i64 %3, i64* %20
  br label %$9
$8:
  %21 = phi i64 [%16, %$6] ; # Lst
; # (when (atom (shift Lst)) (itemErr Exe Key))
; # (shift Lst)
  %22 = inttoptr i64 %21 to i64*
  %23 = getelementptr i64, i64* %22, i32 1
  %24 = load i64, i64* %23
; # (atom (shift Lst))
  %25 = and i64 %24, 15
  %26 = icmp ne i64 %25, 0
  br i1 %26, label %$11, label %$12
$11:
  %27 = phi i64 [%24, %$8] ; # Lst
; # (itemErr Exe Key)
  call void @itemErr(i64 %0, i64 %2)
  unreachable
$12:
  %28 = phi i64 [%24, %$8] ; # Lst
  br label %$5
$9:
  %29 = phi i64 [%18, %$10] ; # Lst
  %30 = phi i64 [%3, %$10] ; # ->
  br label %$2
$3:
  %31 = phi i64 [%1, %$1] ; # Lst
; # (== ZERO Key)
  %32 = icmp eq i64 2, %2
  br i1 %32, label %$13, label %$14
$14:
  %33 = phi i64 [%31, %$3] ; # Lst
; # (let Cnt (int Key) (while (dec 'Cnt) (when (atom (shift Lst)) (it...
; # (int Key)
  %34 = lshr i64 %2, 4
; # (while (dec 'Cnt) (when (atom (shift Lst)) (itemErr Exe Key)))
  br label %$15
$15:
  %35 = phi i64 [%33, %$14], [%48, %$19] ; # Lst
  %36 = phi i64 [%34, %$14], [%49, %$19] ; # Cnt
; # (dec 'Cnt)
  %37 = sub i64 %36, 1
  %38 = icmp ne i64 %37, 0
  br i1 %38, label %$16, label %$17
$16:
  %39 = phi i64 [%35, %$15] ; # Lst
  %40 = phi i64 [%37, %$15] ; # Cnt
; # (when (atom (shift Lst)) (itemErr Exe Key))
; # (shift Lst)
  %41 = inttoptr i64 %39 to i64*
  %42 = getelementptr i64, i64* %41, i32 1
  %43 = load i64, i64* %42
; # (atom (shift Lst))
  %44 = and i64 %43, 15
  %45 = icmp ne i64 %44, 0
  br i1 %45, label %$18, label %$19
$18:
  %46 = phi i64 [%43, %$16] ; # Lst
  %47 = phi i64 [%40, %$16] ; # Cnt
; # (itemErr Exe Key)
  call void @itemErr(i64 %0, i64 %2)
  unreachable
$19:
  %48 = phi i64 [%43, %$16] ; # Lst
  %49 = phi i64 [%40, %$16] ; # Cnt
  br label %$15
$17:
  %50 = phi i64 [%35, %$15] ; # Lst
  %51 = phi i64 [%37, %$15] ; # Cnt
; # (if (sign? Key) (set 2 Lst Val) (set Lst Val))
; # (sign? Key)
  %52 = and i64 %2, 8
  %53 = icmp ne i64 %52, 0
  br i1 %53, label %$20, label %$21
$20:
  %54 = phi i64 [%50, %$17] ; # Lst
; # (set 2 Lst Val)
  %55 = inttoptr i64 %54 to i64*
  %56 = getelementptr i64, i64* %55, i32 1
  store i64 %3, i64* %56
  br label %$22
$21:
  %57 = phi i64 [%50, %$17] ; # Lst
; # (set Lst Val)
  %58 = inttoptr i64 %57 to i64*
  store i64 %3, i64* %58
  br label %$22
$22:
  %59 = phi i64 [%54, %$20], [%57, %$21] ; # Lst
  %60 = phi i64 [%3, %$20], [%3, %$21] ; # ->
  br label %$2
$13:
  %61 = phi i64 [%31, %$3] ; # Lst
; # (argErr Exe Key)
  call void @argErr(i64 %0, i64 %2)
  unreachable
$2:
  %62 = phi i64 [%29, %$9], [%59, %$22] ; # Lst
  %63 = phi i64 [%30, %$9], [%60, %$22] ; # ->
  ret void
}

define i64 @get(i64, i64) align 8 {
$1:
; # (let Tail (val (tail Sym)) (unless (num? Tail) (let (L (any (& Ta...
; # (tail Sym)
  %2 = add i64 %0, -8
; # (val (tail Sym))
  %3 = inttoptr i64 %2 to i64*
  %4 = load i64, i64* %3
; # (unless (num? Tail) (let (L (any (& Tail -9)) X (car L)) (if (ato...
; # (num? Tail)
  %5 = and i64 %4, 6
  %6 = icmp ne i64 %5, 0
  br i1 %6, label %$3, label %$2
$2:
; # (let (L (any (& Tail -9)) X (car L)) (if (atom X) (when (== Key X...
; # (& Tail -9)
  %7 = and i64 %4, -9
; # (any (& Tail -9))
; # (car L)
  %8 = inttoptr i64 %7 to i64*
  %9 = load i64, i64* %8
; # (if (atom X) (when (== Key X) (ret $T)) (when (== Key (cdr X)) (r...
; # (atom X)
  %10 = and i64 %9, 15
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$4, label %$5
$4:
  %12 = phi i64 [%7, %$2] ; # L
  %13 = phi i64 [%9, %$2] ; # X
; # (when (== Key X) (ret $T))
; # (== Key X)
  %14 = icmp eq i64 %1, %13
  br i1 %14, label %$7, label %$8
$7:
  %15 = phi i64 [%12, %$4] ; # L
  %16 = phi i64 [%13, %$4] ; # X
; # (ret $T)
  ret i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
$8:
  %17 = phi i64 [%12, %$4] ; # L
  %18 = phi i64 [%13, %$4] ; # X
  br label %$6
$5:
  %19 = phi i64 [%7, %$2] ; # L
  %20 = phi i64 [%9, %$2] ; # X
; # (when (== Key (cdr X)) (ret (car X)))
; # (cdr X)
  %21 = inttoptr i64 %20 to i64*
  %22 = getelementptr i64, i64* %21, i32 1
  %23 = load i64, i64* %22
; # (== Key (cdr X))
  %24 = icmp eq i64 %1, %23
  br i1 %24, label %$9, label %$10
$9:
  %25 = phi i64 [%19, %$5] ; # L
  %26 = phi i64 [%20, %$5] ; # X
; # (car X)
  %27 = inttoptr i64 %26 to i64*
  %28 = load i64, i64* %27
; # (ret (car X))
  ret i64 %28
$10:
  %29 = phi i64 [%19, %$5] ; # L
  %30 = phi i64 [%20, %$5] ; # X
  br label %$6
$6:
  %31 = phi i64 [%17, %$8], [%29, %$10] ; # L
  %32 = phi i64 [%18, %$8], [%30, %$10] ; # X
; # (while (pair (setq X (cdr L))) (let Y (car X) (if (atom Y) (when ...
  br label %$11
$11:
  %33 = phi i64 [%31, %$6], [%110, %$16] ; # L
  %34 = phi i64 [%32, %$6], [%110, %$16] ; # X
; # (cdr L)
  %35 = inttoptr i64 %33 to i64*
  %36 = getelementptr i64, i64* %35, i32 1
  %37 = load i64, i64* %36
; # (pair (setq X (cdr L)))
  %38 = and i64 %37, 15
  %39 = icmp eq i64 %38, 0
  br i1 %39, label %$12, label %$13
$12:
  %40 = phi i64 [%33, %$11] ; # L
  %41 = phi i64 [%37, %$11] ; # X
; # (let Y (car X) (if (atom Y) (when (== Key Y) (set 2 L (cdr X)) (i...
; # (car X)
  %42 = inttoptr i64 %41 to i64*
  %43 = load i64, i64* %42
; # (if (atom Y) (when (== Key Y) (set 2 L (cdr X)) (ifn (sym? Tail) ...
; # (atom Y)
  %44 = and i64 %43, 15
  %45 = icmp ne i64 %44, 0
  br i1 %45, label %$14, label %$15
$14:
  %46 = phi i64 [%40, %$12] ; # L
  %47 = phi i64 [%41, %$12] ; # X
; # (when (== Key Y) (set 2 L (cdr X)) (ifn (sym? Tail) (set 2 X Tail...
; # (== Key Y)
  %48 = icmp eq i64 %1, %43
  br i1 %48, label %$17, label %$18
$17:
  %49 = phi i64 [%46, %$14] ; # L
  %50 = phi i64 [%47, %$14] ; # X
; # (set 2 L (cdr X))
; # (cdr X)
  %51 = inttoptr i64 %50 to i64*
  %52 = getelementptr i64, i64* %51, i32 1
  %53 = load i64, i64* %52
  %54 = inttoptr i64 %49 to i64*
  %55 = getelementptr i64, i64* %54, i32 1
  store i64 %53, i64* %55
; # (ifn (sym? Tail) (set 2 X Tail) (set 2 X (& Tail -9)) (setq X (sy...
; # (sym? Tail)
  %56 = and i64 %4, 8
  %57 = icmp ne i64 %56, 0
  br i1 %57, label %$20, label %$19
$19:
  %58 = phi i64 [%49, %$17] ; # L
  %59 = phi i64 [%50, %$17] ; # X
; # (set 2 X Tail)
  %60 = inttoptr i64 %59 to i64*
  %61 = getelementptr i64, i64* %60, i32 1
  store i64 %4, i64* %61
  br label %$21
$20:
  %62 = phi i64 [%49, %$17] ; # L
  %63 = phi i64 [%50, %$17] ; # X
; # (set 2 X (& Tail -9))
; # (& Tail -9)
  %64 = and i64 %4, -9
  %65 = inttoptr i64 %63 to i64*
  %66 = getelementptr i64, i64* %65, i32 1
  store i64 %64, i64* %66
; # (sym X)
  %67 = or i64 %63, 8
  br label %$21
$21:
  %68 = phi i64 [%58, %$19], [%62, %$20] ; # L
  %69 = phi i64 [%59, %$19], [%67, %$20] ; # X
  %70 = phi i64 [%4, %$19], [%67, %$20] ; # ->
; # (set (tail Sym) X)
; # (tail Sym)
  %71 = add i64 %0, -8
  %72 = inttoptr i64 %71 to i64*
  store i64 %69, i64* %72
; # (ret $T)
  ret i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
$18:
  %73 = phi i64 [%46, %$14] ; # L
  %74 = phi i64 [%47, %$14] ; # X
  br label %$16
$15:
  %75 = phi i64 [%40, %$12] ; # L
  %76 = phi i64 [%41, %$12] ; # X
; # (when (== Key (cdr Y)) (set 2 L (cdr X)) (ifn (sym? Tail) (set 2 ...
; # (cdr Y)
  %77 = inttoptr i64 %43 to i64*
  %78 = getelementptr i64, i64* %77, i32 1
  %79 = load i64, i64* %78
; # (== Key (cdr Y))
  %80 = icmp eq i64 %1, %79
  br i1 %80, label %$22, label %$23
$22:
  %81 = phi i64 [%75, %$15] ; # L
  %82 = phi i64 [%76, %$15] ; # X
; # (set 2 L (cdr X))
; # (cdr X)
  %83 = inttoptr i64 %82 to i64*
  %84 = getelementptr i64, i64* %83, i32 1
  %85 = load i64, i64* %84
  %86 = inttoptr i64 %81 to i64*
  %87 = getelementptr i64, i64* %86, i32 1
  store i64 %85, i64* %87
; # (ifn (sym? Tail) (set 2 X Tail) (set 2 X (& Tail -9)) (setq X (sy...
; # (sym? Tail)
  %88 = and i64 %4, 8
  %89 = icmp ne i64 %88, 0
  br i1 %89, label %$25, label %$24
$24:
  %90 = phi i64 [%81, %$22] ; # L
  %91 = phi i64 [%82, %$22] ; # X
; # (set 2 X Tail)
  %92 = inttoptr i64 %91 to i64*
  %93 = getelementptr i64, i64* %92, i32 1
  store i64 %4, i64* %93
  br label %$26
$25:
  %94 = phi i64 [%81, %$22] ; # L
  %95 = phi i64 [%82, %$22] ; # X
; # (set 2 X (& Tail -9))
; # (& Tail -9)
  %96 = and i64 %4, -9
  %97 = inttoptr i64 %95 to i64*
  %98 = getelementptr i64, i64* %97, i32 1
  store i64 %96, i64* %98
; # (sym X)
  %99 = or i64 %95, 8
  br label %$26
$26:
  %100 = phi i64 [%90, %$24], [%94, %$25] ; # L
  %101 = phi i64 [%91, %$24], [%99, %$25] ; # X
  %102 = phi i64 [%4, %$24], [%99, %$25] ; # ->
; # (set (tail Sym) X)
; # (tail Sym)
  %103 = add i64 %0, -8
  %104 = inttoptr i64 %103 to i64*
  store i64 %101, i64* %104
; # (car Y)
  %105 = inttoptr i64 %43 to i64*
  %106 = load i64, i64* %105
; # (ret (car Y))
  ret i64 %106
$23:
  %107 = phi i64 [%75, %$15] ; # L
  %108 = phi i64 [%76, %$15] ; # X
  br label %$16
$16:
  %109 = phi i64 [%73, %$18], [%107, %$23] ; # L
  %110 = phi i64 [%74, %$18], [%108, %$23] ; # X
  br label %$11
$13:
  %111 = phi i64 [%33, %$11] ; # L
  %112 = phi i64 [%37, %$11] ; # X
  br label %$3
$3:
  ret i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
}

define i64 @getn(i64, i64, i64) align 8 {
$1:
; # (when (num? X) (argErr Exe X))
; # (num? X)
  %3 = and i64 %1, 6
  %4 = icmp ne i64 %3, 0
  br i1 %4, label %$2, label %$3
$2:
  %5 = phi i64 [%1, %$1] ; # X
; # (argErr Exe X)
  call void @argErr(i64 %0, i64 %5)
  unreachable
$3:
  %6 = phi i64 [%1, %$1] ; # X
; # (if (pair X) (nond ((num? Key) (loop (let Y (car X) (? (and (pair...
; # (pair X)
  %7 = and i64 %6, 15
  %8 = icmp eq i64 %7, 0
  br i1 %8, label %$4, label %$5
$4:
  %9 = phi i64 [%6, %$3] ; # X
; # (nond ((num? Key) (loop (let Y (car X) (? (and (pair Y) (== Key (...
; # (num? Key)
  %10 = and i64 %2, 6
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$8, label %$9
$9:
  %12 = phi i64 [%9, %$4] ; # X
; # (loop (let Y (car X) (? (and (pair Y) (== Key (car Y))) (cdr Y)))...
  br label %$10
$10:
  %13 = phi i64 [%12, %$9], [%35, %$16] ; # X
; # (let Y (car X) (? (and (pair Y) (== Key (car Y))) (cdr Y)))
; # (car X)
  %14 = inttoptr i64 %13 to i64*
  %15 = load i64, i64* %14
; # (? (and (pair Y) (== Key (car Y))) (cdr Y))
; # (and (pair Y) (== Key (car Y)))
; # (pair Y)
  %16 = and i64 %15, 15
  %17 = icmp eq i64 %16, 0
  br i1 %17, label %$12, label %$11
$12:
  %18 = phi i64 [%13, %$10] ; # X
; # (car Y)
  %19 = inttoptr i64 %15 to i64*
  %20 = load i64, i64* %19
; # (== Key (car Y))
  %21 = icmp eq i64 %2, %20
  br label %$11
$11:
  %22 = phi i64 [%13, %$10], [%18, %$12] ; # X
  %23 = phi i1 [0, %$10], [%21, %$12] ; # ->
  br i1 %23, label %$15, label %$13
$15:
  %24 = phi i64 [%22, %$11] ; # X
; # (cdr Y)
  %25 = inttoptr i64 %15 to i64*
  %26 = getelementptr i64, i64* %25, i32 1
  %27 = load i64, i64* %26
  br label %$14
$13:
  %28 = phi i64 [%22, %$11] ; # X
; # (? (atom (shift X)) $Nil)
; # (shift X)
  %29 = inttoptr i64 %28 to i64*
  %30 = getelementptr i64, i64* %29, i32 1
  %31 = load i64, i64* %30
; # (atom (shift X))
  %32 = and i64 %31, 15
  %33 = icmp ne i64 %32, 0
  br i1 %33, label %$17, label %$16
$17:
  %34 = phi i64 [%31, %$13] ; # X
  br label %$14
$16:
  %35 = phi i64 [%31, %$13] ; # X
  br label %$10
$14:
  %36 = phi i64 [%24, %$15], [%34, %$17] ; # X
  %37 = phi i64 [%27, %$15], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$17] ; # ->
  br label %$7
$8:
  %38 = phi i64 [%9, %$4] ; # X
; # (== ZERO Key)
  %39 = icmp eq i64 2, %2
  br i1 %39, label %$18, label %$19
$19:
  %40 = phi i64 [%38, %$8] ; # X
; # (nth Key X)
  %41 = lshr i64 %2, 4
  br label %$20
$20:
  %42 = phi i64 [%40, %$19], [%50, %$21] ; # X
  %43 = phi i64 [%41, %$19], [%47, %$21] ; # C
  %44 = sub i64 %43, 1
  %45 = icmp ne i64 %44, 0
  br i1 %45, label %$21, label %$22
$21:
  %46 = phi i64 [%42, %$20] ; # X
  %47 = phi i64 [%44, %$20] ; # C
  %48 = inttoptr i64 %46 to i64*
  %49 = getelementptr i64, i64* %48, i32 1
  %50 = load i64, i64* %49
  br label %$20
$22:
  %51 = phi i64 [%42, %$20] ; # X
  %52 = phi i64 [%44, %$20] ; # C
  %53 = and i64 %2, 8
  %54 = icmp ne i64 %53, 0
  br i1 %54, label %$23, label %$24
$23:
  %55 = phi i64 [%51, %$22] ; # X
  %56 = phi i64 [%52, %$22] ; # C
  %57 = inttoptr i64 %55 to i64*
  %58 = getelementptr i64, i64* %57, i32 1
  %59 = load i64, i64* %58
  br label %$25
$24:
  %60 = phi i64 [%51, %$22] ; # X
  %61 = phi i64 [%52, %$22] ; # C
  %62 = inttoptr i64 %60 to i64*
  %63 = load i64, i64* %62
  br label %$25
$25:
  %64 = phi i64 [%55, %$23], [%60, %$24] ; # X
  %65 = phi i64 [%56, %$23], [%61, %$24] ; # C
  %66 = phi i64 [%59, %$23], [%63, %$24] ; # ->
  br label %$7
$18:
  %67 = phi i64 [%38, %$8] ; # X
  br label %$7
$7:
  %68 = phi i64 [%36, %$14], [%40, %$25], [%67, %$18] ; # X
  %69 = phi i64 [%37, %$14], [%66, %$25], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$18] ; # ->
  br label %$6
$5:
  %70 = phi i64 [%6, %$3] ; # X
; # (when (sym? (val (tail X))) (dbFetch Exe X))
; # (tail X)
  %71 = add i64 %70, -8
; # (val (tail X))
  %72 = inttoptr i64 %71 to i64*
  %73 = load i64, i64* %72
; # (sym? (val (tail X)))
  %74 = and i64 %73, 8
  %75 = icmp ne i64 %74, 0
  br i1 %75, label %$26, label %$27
$26:
  %76 = phi i64 [%70, %$5] ; # X
; # (dbFetch Exe X)
  call void @dbFetch(i64 %0, i64 %76)
  br label %$27
$27:
  %77 = phi i64 [%70, %$5], [%76, %$26] ; # X
; # (if (== Key ZERO) (val X) (tailcall (get X Key)))
; # (== Key ZERO)
  %78 = icmp eq i64 %2, 2
  br i1 %78, label %$28, label %$29
$28:
  %79 = phi i64 [%77, %$27] ; # X
; # (val X)
  %80 = inttoptr i64 %79 to i64*
  %81 = load i64, i64* %80
  br label %$30
$29:
  %82 = phi i64 [%77, %$27] ; # X
; # (get X Key)
  %83 = tail call i64 @get(i64 %82, i64 %2)
  br label %$30
$30:
  %84 = phi i64 [%79, %$28], [%82, %$29] ; # X
  %85 = phi i64 [%81, %$28], [%83, %$29] ; # ->
  br label %$6
$6:
  %86 = phi i64 [%68, %$7], [%84, %$30] ; # X
  %87 = phi i64 [%69, %$7], [%85, %$30] ; # ->
  ret i64 %87
}

define i64 @prop(i64, i64) align 8 {
$1:
; # (let Tail (val (tail Sym)) (unless (num? Tail) (let (L (any (& Ta...
; # (tail Sym)
  %2 = add i64 %0, -8
; # (val (tail Sym))
  %3 = inttoptr i64 %2 to i64*
  %4 = load i64, i64* %3
; # (unless (num? Tail) (let (L (any (& Tail -9)) X (car L)) (if (ato...
; # (num? Tail)
  %5 = and i64 %4, 6
  %6 = icmp ne i64 %5, 0
  br i1 %6, label %$3, label %$2
$2:
; # (let (L (any (& Tail -9)) X (car L)) (if (atom X) (when (== Key X...
; # (& Tail -9)
  %7 = and i64 %4, -9
; # (any (& Tail -9))
; # (car L)
  %8 = inttoptr i64 %7 to i64*
  %9 = load i64, i64* %8
; # (if (atom X) (when (== Key X) (ret Key)) (when (== Key (cdr X)) (...
; # (atom X)
  %10 = and i64 %9, 15
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$4, label %$5
$4:
  %12 = phi i64 [%7, %$2] ; # L
  %13 = phi i64 [%9, %$2] ; # X
; # (when (== Key X) (ret Key))
; # (== Key X)
  %14 = icmp eq i64 %1, %13
  br i1 %14, label %$7, label %$8
$7:
  %15 = phi i64 [%12, %$4] ; # L
  %16 = phi i64 [%13, %$4] ; # X
; # (ret Key)
  ret i64 %1
$8:
  %17 = phi i64 [%12, %$4] ; # L
  %18 = phi i64 [%13, %$4] ; # X
  br label %$6
$5:
  %19 = phi i64 [%7, %$2] ; # L
  %20 = phi i64 [%9, %$2] ; # X
; # (when (== Key (cdr X)) (ret X))
; # (cdr X)
  %21 = inttoptr i64 %20 to i64*
  %22 = getelementptr i64, i64* %21, i32 1
  %23 = load i64, i64* %22
; # (== Key (cdr X))
  %24 = icmp eq i64 %1, %23
  br i1 %24, label %$9, label %$10
$9:
  %25 = phi i64 [%19, %$5] ; # L
  %26 = phi i64 [%20, %$5] ; # X
; # (ret X)
  ret i64 %26
$10:
  %27 = phi i64 [%19, %$5] ; # L
  %28 = phi i64 [%20, %$5] ; # X
  br label %$6
$6:
  %29 = phi i64 [%17, %$8], [%27, %$10] ; # L
  %30 = phi i64 [%18, %$8], [%28, %$10] ; # X
; # (while (pair (setq X (cdr L))) (let Y (car X) (if (atom Y) (when ...
  br label %$11
$11:
  %31 = phi i64 [%29, %$6], [%106, %$16] ; # L
  %32 = phi i64 [%30, %$6], [%106, %$16] ; # X
; # (cdr L)
  %33 = inttoptr i64 %31 to i64*
  %34 = getelementptr i64, i64* %33, i32 1
  %35 = load i64, i64* %34
; # (pair (setq X (cdr L)))
  %36 = and i64 %35, 15
  %37 = icmp eq i64 %36, 0
  br i1 %37, label %$12, label %$13
$12:
  %38 = phi i64 [%31, %$11] ; # L
  %39 = phi i64 [%35, %$11] ; # X
; # (let Y (car X) (if (atom Y) (when (== Key Y) (set 2 L (cdr X)) (i...
; # (car X)
  %40 = inttoptr i64 %39 to i64*
  %41 = load i64, i64* %40
; # (if (atom Y) (when (== Key Y) (set 2 L (cdr X)) (ifn (sym? Tail) ...
; # (atom Y)
  %42 = and i64 %41, 15
  %43 = icmp ne i64 %42, 0
  br i1 %43, label %$14, label %$15
$14:
  %44 = phi i64 [%38, %$12] ; # L
  %45 = phi i64 [%39, %$12] ; # X
; # (when (== Key Y) (set 2 L (cdr X)) (ifn (sym? Tail) (set 2 X Tail...
; # (== Key Y)
  %46 = icmp eq i64 %1, %41
  br i1 %46, label %$17, label %$18
$17:
  %47 = phi i64 [%44, %$14] ; # L
  %48 = phi i64 [%45, %$14] ; # X
; # (set 2 L (cdr X))
; # (cdr X)
  %49 = inttoptr i64 %48 to i64*
  %50 = getelementptr i64, i64* %49, i32 1
  %51 = load i64, i64* %50
  %52 = inttoptr i64 %47 to i64*
  %53 = getelementptr i64, i64* %52, i32 1
  store i64 %51, i64* %53
; # (ifn (sym? Tail) (set 2 X Tail) (set 2 X (& Tail -9)) (setq X (sy...
; # (sym? Tail)
  %54 = and i64 %4, 8
  %55 = icmp ne i64 %54, 0
  br i1 %55, label %$20, label %$19
$19:
  %56 = phi i64 [%47, %$17] ; # L
  %57 = phi i64 [%48, %$17] ; # X
; # (set 2 X Tail)
  %58 = inttoptr i64 %57 to i64*
  %59 = getelementptr i64, i64* %58, i32 1
  store i64 %4, i64* %59
  br label %$21
$20:
  %60 = phi i64 [%47, %$17] ; # L
  %61 = phi i64 [%48, %$17] ; # X
; # (set 2 X (& Tail -9))
; # (& Tail -9)
  %62 = and i64 %4, -9
  %63 = inttoptr i64 %61 to i64*
  %64 = getelementptr i64, i64* %63, i32 1
  store i64 %62, i64* %64
; # (sym X)
  %65 = or i64 %61, 8
  br label %$21
$21:
  %66 = phi i64 [%56, %$19], [%60, %$20] ; # L
  %67 = phi i64 [%57, %$19], [%65, %$20] ; # X
  %68 = phi i64 [%4, %$19], [%65, %$20] ; # ->
; # (set (tail Sym) X)
; # (tail Sym)
  %69 = add i64 %0, -8
  %70 = inttoptr i64 %69 to i64*
  store i64 %67, i64* %70
; # (ret Key)
  ret i64 %1
$18:
  %71 = phi i64 [%44, %$14] ; # L
  %72 = phi i64 [%45, %$14] ; # X
  br label %$16
$15:
  %73 = phi i64 [%38, %$12] ; # L
  %74 = phi i64 [%39, %$12] ; # X
; # (when (== Key (cdr Y)) (set 2 L (cdr X)) (ifn (sym? Tail) (set 2 ...
; # (cdr Y)
  %75 = inttoptr i64 %41 to i64*
  %76 = getelementptr i64, i64* %75, i32 1
  %77 = load i64, i64* %76
; # (== Key (cdr Y))
  %78 = icmp eq i64 %1, %77
  br i1 %78, label %$22, label %$23
$22:
  %79 = phi i64 [%73, %$15] ; # L
  %80 = phi i64 [%74, %$15] ; # X
; # (set 2 L (cdr X))
; # (cdr X)
  %81 = inttoptr i64 %80 to i64*
  %82 = getelementptr i64, i64* %81, i32 1
  %83 = load i64, i64* %82
  %84 = inttoptr i64 %79 to i64*
  %85 = getelementptr i64, i64* %84, i32 1
  store i64 %83, i64* %85
; # (ifn (sym? Tail) (set 2 X Tail) (set 2 X (& Tail -9)) (setq X (sy...
; # (sym? Tail)
  %86 = and i64 %4, 8
  %87 = icmp ne i64 %86, 0
  br i1 %87, label %$25, label %$24
$24:
  %88 = phi i64 [%79, %$22] ; # L
  %89 = phi i64 [%80, %$22] ; # X
; # (set 2 X Tail)
  %90 = inttoptr i64 %89 to i64*
  %91 = getelementptr i64, i64* %90, i32 1
  store i64 %4, i64* %91
  br label %$26
$25:
  %92 = phi i64 [%79, %$22] ; # L
  %93 = phi i64 [%80, %$22] ; # X
; # (set 2 X (& Tail -9))
; # (& Tail -9)
  %94 = and i64 %4, -9
  %95 = inttoptr i64 %93 to i64*
  %96 = getelementptr i64, i64* %95, i32 1
  store i64 %94, i64* %96
; # (sym X)
  %97 = or i64 %93, 8
  br label %$26
$26:
  %98 = phi i64 [%88, %$24], [%92, %$25] ; # L
  %99 = phi i64 [%89, %$24], [%97, %$25] ; # X
  %100 = phi i64 [%4, %$24], [%97, %$25] ; # ->
; # (set (tail Sym) X)
; # (tail Sym)
  %101 = add i64 %0, -8
  %102 = inttoptr i64 %101 to i64*
  store i64 %99, i64* %102
; # (ret Y)
  ret i64 %41
$23:
  %103 = phi i64 [%73, %$15] ; # L
  %104 = phi i64 [%74, %$15] ; # X
  br label %$16
$16:
  %105 = phi i64 [%71, %$18], [%103, %$23] ; # L
  %106 = phi i64 [%72, %$18], [%104, %$23] ; # X
  br label %$11
$13:
  %107 = phi i64 [%31, %$11] ; # L
  %108 = phi i64 [%35, %$11] ; # X
  br label %$3
$3:
; # (let R (cons $Nil Key) (set (tail Sym) (if (sym? Tail) (sym (cons...
; # (cons $Nil Key)
  %109 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64 %1)
; # (set (tail Sym) (if (sym? Tail) (sym (cons R (& Tail -9))) (cons ...
; # (tail Sym)
  %110 = add i64 %0, -8
; # (if (sym? Tail) (sym (cons R (& Tail -9))) (cons R Tail))
; # (sym? Tail)
  %111 = and i64 %4, 8
  %112 = icmp ne i64 %111, 0
  br i1 %112, label %$27, label %$28
$27:
; # (& Tail -9)
  %113 = and i64 %4, -9
; # (cons R (& Tail -9))
  %114 = call i64 @cons(i64 %109, i64 %113)
; # (sym (cons R (& Tail -9)))
  %115 = or i64 %114, 8
  br label %$29
$28:
; # (cons R Tail)
  %116 = call i64 @cons(i64 %109, i64 %4)
  br label %$29
$29:
  %117 = phi i64 [%115, %$27], [%116, %$28] ; # ->
  %118 = inttoptr i64 %110 to i64*
  store i64 %117, i64* %118
  ret i64 %109
}

define i64 @_Put(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (save (eval (++ X))) Key T) (loop (setq Key (...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (save (eval (++ X)))
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %17 = load i64, i64* %16
  %18 = alloca i64, i64 2, align 16
  %19 = ptrtoint i64* %18 to i64
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = add i64 %19, 8
  %22 = inttoptr i64 %21 to i64*
  store i64 %17, i64* %22
  %23 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %19, i64* %23
; # (loop (setq Key (eval (++ X))) (? (atom (cdr X))) (setq Y (safe (...
  br label %$7
$7:
  %24 = phi i64 [%7, %$2], [%43, %$13] ; # X
  %25 = phi i64 [%15, %$2], [%46, %$13] ; # Y
; # (++ X)
  %26 = inttoptr i64 %24 to i64*
  %27 = load i64, i64* %26
  %28 = getelementptr i64, i64* %26, i32 1
  %29 = load i64, i64* %28
; # (eval (++ X))
  %30 = and i64 %27, 6
  %31 = icmp ne i64 %30, 0
  br i1 %31, label %$10, label %$9
$10:
  br label %$8
$9:
  %32 = and i64 %27, 8
  %33 = icmp ne i64 %32, 0
  br i1 %33, label %$12, label %$11
$12:
  %34 = inttoptr i64 %27 to i64*
  %35 = load i64, i64* %34
  br label %$8
$11:
  %36 = call i64 @evList(i64 %27)
  br label %$8
$8:
  %37 = phi i64 [%27, %$10], [%35, %$12], [%36, %$11] ; # ->
; # (? (atom (cdr X)))
; # (cdr X)
  %38 = inttoptr i64 %29 to i64*
  %39 = getelementptr i64, i64* %38, i32 1
  %40 = load i64, i64* %39
; # (atom (cdr X))
  %41 = and i64 %40, 15
  %42 = icmp ne i64 %41, 0
  br i1 %42, label %$14, label %$13
$13:
  %43 = phi i64 [%29, %$8] ; # X
  %44 = phi i64 [%25, %$8] ; # Y
  %45 = phi i64 [%37, %$8] ; # Key
; # (getn Exe Y Key)
  %46 = call i64 @getn(i64 %0, i64 %44, i64 %45)
; # (safe (getn Exe Y Key))
  %47 = inttoptr i64 %19 to i64*
  store i64 %46, i64* %47
  br label %$7
$14:
  %48 = phi i64 [%29, %$8] ; # X
  %49 = phi i64 [%25, %$8] ; # Y
  %50 = phi i64 [%37, %$8] ; # Key
  %51 = phi i64 [0, %$8] ; # ->
; # (when (num? Y) (argErr Exe Y))
; # (num? Y)
  %52 = and i64 %49, 6
  %53 = icmp ne i64 %52, 0
  br i1 %53, label %$15, label %$16
$15:
  %54 = phi i64 [%48, %$14] ; # X
  %55 = phi i64 [%49, %$14] ; # Y
  %56 = phi i64 [%50, %$14] ; # Key
; # (argErr Exe Y)
  call void @argErr(i64 %0, i64 %55)
  unreachable
$16:
  %57 = phi i64 [%48, %$14] ; # X
  %58 = phi i64 [%49, %$14] ; # Y
  %59 = phi i64 [%50, %$14] ; # Key
; # (push Key NIL)
  %60 = alloca i64, i64 2, align 16
  %61 = ptrtoint i64* %60 to i64
  %62 = inttoptr i64 %61 to i64*
  store i64 %59, i64* %62
; # (link (push Key NIL))
  %63 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %64 = load i64, i64* %63
  %65 = inttoptr i64 %61 to i64*
  %66 = getelementptr i64, i64* %65, i32 1
  store i64 %64, i64* %66
  %67 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %61, i64* %67
; # (let Val (eval (car X)) (if (pair Y) (putn Exe Y Key Val) (when (...
; # (car X)
  %68 = inttoptr i64 %57 to i64*
  %69 = load i64, i64* %68
; # (eval (car X))
  %70 = and i64 %69, 6
  %71 = icmp ne i64 %70, 0
  br i1 %71, label %$19, label %$18
$19:
  br label %$17
$18:
  %72 = and i64 %69, 8
  %73 = icmp ne i64 %72, 0
  br i1 %73, label %$21, label %$20
$21:
  %74 = inttoptr i64 %69 to i64*
  %75 = load i64, i64* %74
  br label %$17
$20:
  %76 = call i64 @evList(i64 %69)
  br label %$17
$17:
  %77 = phi i64 [%69, %$19], [%75, %$21], [%76, %$20] ; # ->
; # (if (pair Y) (putn Exe Y Key Val) (when (sym? (val (tail Y))) (if...
; # (pair Y)
  %78 = and i64 %58, 15
  %79 = icmp eq i64 %78, 0
  br i1 %79, label %$22, label %$23
$22:
  %80 = phi i64 [%57, %$17] ; # X
  %81 = phi i64 [%58, %$17] ; # Y
  %82 = phi i64 [%59, %$17] ; # Key
; # (putn Exe Y Key Val)
  call void @putn(i64 %0, i64 %81, i64 %82, i64 %77)
  br label %$24
$23:
  %83 = phi i64 [%57, %$17] ; # X
  %84 = phi i64 [%58, %$17] ; # Y
  %85 = phi i64 [%59, %$17] ; # Key
; # (when (sym? (val (tail Y))) (if (nil? Key) (dbFetch Exe Y) (dbTou...
; # (tail Y)
  %86 = add i64 %84, -8
; # (val (tail Y))
  %87 = inttoptr i64 %86 to i64*
  %88 = load i64, i64* %87
; # (sym? (val (tail Y)))
  %89 = and i64 %88, 8
  %90 = icmp ne i64 %89, 0
  br i1 %90, label %$25, label %$26
$25:
  %91 = phi i64 [%83, %$23] ; # X
  %92 = phi i64 [%84, %$23] ; # Y
  %93 = phi i64 [%85, %$23] ; # Key
; # (if (nil? Key) (dbFetch Exe Y) (dbTouch Exe Y))
; # (nil? Key)
  %94 = icmp eq i64 %93, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %94, label %$27, label %$28
$27:
  %95 = phi i64 [%91, %$25] ; # X
  %96 = phi i64 [%92, %$25] ; # Y
  %97 = phi i64 [%93, %$25] ; # Key
; # (dbFetch Exe Y)
  call void @dbFetch(i64 %0, i64 %96)
  br label %$29
$28:
  %98 = phi i64 [%91, %$25] ; # X
  %99 = phi i64 [%92, %$25] ; # Y
  %100 = phi i64 [%93, %$25] ; # Key
; # (dbTouch Exe Y)
  call void @dbTouch(i64 %0, i64 %99)
  br label %$29
$29:
  %101 = phi i64 [%95, %$27], [%98, %$28] ; # X
  %102 = phi i64 [%96, %$27], [%99, %$28] ; # Y
  %103 = phi i64 [%97, %$27], [%100, %$28] ; # Key
  br label %$26
$26:
  %104 = phi i64 [%83, %$23], [%101, %$29] ; # X
  %105 = phi i64 [%84, %$23], [%102, %$29] ; # Y
  %106 = phi i64 [%85, %$23], [%103, %$29] ; # Key
; # (if (== ZERO Key) (set (chkVar Exe Y) Val) (put Y Key Val))
; # (== ZERO Key)
  %107 = icmp eq i64 2, %106
  br i1 %107, label %$30, label %$31
$30:
  %108 = phi i64 [%104, %$26] ; # X
  %109 = phi i64 [%105, %$26] ; # Y
  %110 = phi i64 [%106, %$26] ; # Key
; # (set (chkVar Exe Y) Val)
; # (chkVar Exe Y)
  %111 = icmp uge i64 %109, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %111, label %$34, label %$33
$34:
  %112 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %109
  br label %$33
$33:
  %113 = phi i1 [0, %$30], [%112, %$34] ; # ->
  br i1 %113, label %$35, label %$36
$35:
  call void @protErr(i64 %0, i64 %109)
  unreachable
$36:
  %114 = inttoptr i64 %109 to i64*
  store i64 %77, i64* %114
  br label %$32
$31:
  %115 = phi i64 [%104, %$26] ; # X
  %116 = phi i64 [%105, %$26] ; # Y
  %117 = phi i64 [%106, %$26] ; # Key
; # (put Y Key Val)
  call void @put(i64 %116, i64 %117, i64 %77)
  br label %$32
$32:
  %118 = phi i64 [%108, %$36], [%115, %$31] ; # X
  %119 = phi i64 [%109, %$36], [%116, %$31] ; # Y
  %120 = phi i64 [%110, %$36], [%117, %$31] ; # Key
  br label %$24
$24:
  %121 = phi i64 [%80, %$22], [%118, %$32] ; # X
  %122 = phi i64 [%81, %$22], [%119, %$32] ; # Y
  %123 = phi i64 [%82, %$22], [%120, %$32] ; # Key
; # (drop *Safe)
  %124 = inttoptr i64 %19 to i64*
  %125 = getelementptr i64, i64* %124, i32 1
  %126 = load i64, i64* %125
  %127 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %126, i64* %127
  ret i64 %77
}

define i64 @_Get(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (eval (++ X))) (when (pair X) (save Y (loop (...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (when (pair X) (save Y (loop (setq Y (getn Exe Y (eval (++ X)))) ...
; # (pair X)
  %16 = and i64 %7, 15
  %17 = icmp eq i64 %16, 0
  br i1 %17, label %$7, label %$8
$7:
  %18 = phi i64 [%7, %$2] ; # X
  %19 = phi i64 [%15, %$2] ; # Y
; # (save Y (loop (setq Y (getn Exe Y (eval (++ X)))) (? (atom X)) (s...
  %20 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %21 = load i64, i64* %20
  %22 = alloca i64, i64 2, align 16
  %23 = ptrtoint i64* %22 to i64
  %24 = inttoptr i64 %23 to i64*
  store i64 %19, i64* %24
  %25 = add i64 %23, 8
  %26 = inttoptr i64 %25 to i64*
  store i64 %21, i64* %26
  %27 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %23, i64* %27
; # (loop (setq Y (getn Exe Y (eval (++ X)))) (? (atom X)) (safe Y))
  br label %$9
$9:
  %28 = phi i64 [%18, %$7], [%45, %$15] ; # X
  %29 = phi i64 [%19, %$7], [%46, %$15] ; # Y
; # (++ X)
  %30 = inttoptr i64 %28 to i64*
  %31 = load i64, i64* %30
  %32 = getelementptr i64, i64* %30, i32 1
  %33 = load i64, i64* %32
; # (eval (++ X))
  %34 = and i64 %31, 6
  %35 = icmp ne i64 %34, 0
  br i1 %35, label %$12, label %$11
$12:
  br label %$10
$11:
  %36 = and i64 %31, 8
  %37 = icmp ne i64 %36, 0
  br i1 %37, label %$14, label %$13
$14:
  %38 = inttoptr i64 %31 to i64*
  %39 = load i64, i64* %38
  br label %$10
$13:
  %40 = call i64 @evList(i64 %31)
  br label %$10
$10:
  %41 = phi i64 [%31, %$12], [%39, %$14], [%40, %$13] ; # ->
; # (getn Exe Y (eval (++ X)))
  %42 = call i64 @getn(i64 %0, i64 %29, i64 %41)
; # (? (atom X))
; # (atom X)
  %43 = and i64 %33, 15
  %44 = icmp ne i64 %43, 0
  br i1 %44, label %$16, label %$15
$15:
  %45 = phi i64 [%33, %$10] ; # X
  %46 = phi i64 [%42, %$10] ; # Y
; # (safe Y)
  %47 = inttoptr i64 %23 to i64*
  store i64 %46, i64* %47
  br label %$9
$16:
  %48 = phi i64 [%33, %$10] ; # X
  %49 = phi i64 [%42, %$10] ; # Y
  %50 = phi i64 [0, %$10] ; # ->
; # drop
  %51 = inttoptr i64 %23 to i64*
  %52 = getelementptr i64, i64* %51, i32 1
  %53 = load i64, i64* %52
  %54 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %53, i64* %54
  br label %$8
$8:
  %55 = phi i64 [%7, %$2], [%48, %$16] ; # X
  %56 = phi i64 [%15, %$2], [%49, %$16] ; # Y
  ret i64 %56
}

define i64 @_Prop(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (save (eval (++ X))) Key T) (loop (setq Key (...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (save (eval (++ X)))
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %17 = load i64, i64* %16
  %18 = alloca i64, i64 2, align 16
  %19 = ptrtoint i64* %18 to i64
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = add i64 %19, 8
  %22 = inttoptr i64 %21 to i64*
  store i64 %17, i64* %22
  %23 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %19, i64* %23
; # (loop (setq Key (eval (++ X))) (? (atom X)) (setq Y (safe (getn E...
  br label %$7
$7:
  %24 = phi i64 [%7, %$2], [%40, %$13] ; # X
  %25 = phi i64 [%15, %$2], [%43, %$13] ; # Y
; # (++ X)
  %26 = inttoptr i64 %24 to i64*
  %27 = load i64, i64* %26
  %28 = getelementptr i64, i64* %26, i32 1
  %29 = load i64, i64* %28
; # (eval (++ X))
  %30 = and i64 %27, 6
  %31 = icmp ne i64 %30, 0
  br i1 %31, label %$10, label %$9
$10:
  br label %$8
$9:
  %32 = and i64 %27, 8
  %33 = icmp ne i64 %32, 0
  br i1 %33, label %$12, label %$11
$12:
  %34 = inttoptr i64 %27 to i64*
  %35 = load i64, i64* %34
  br label %$8
$11:
  %36 = call i64 @evList(i64 %27)
  br label %$8
$8:
  %37 = phi i64 [%27, %$10], [%35, %$12], [%36, %$11] ; # ->
; # (? (atom X))
; # (atom X)
  %38 = and i64 %29, 15
  %39 = icmp ne i64 %38, 0
  br i1 %39, label %$14, label %$13
$13:
  %40 = phi i64 [%29, %$8] ; # X
  %41 = phi i64 [%25, %$8] ; # Y
  %42 = phi i64 [%37, %$8] ; # Key
; # (getn Exe Y Key)
  %43 = call i64 @getn(i64 %0, i64 %41, i64 %42)
; # (safe (getn Exe Y Key))
  %44 = inttoptr i64 %19 to i64*
  store i64 %43, i64* %44
  br label %$7
$14:
  %45 = phi i64 [%29, %$8] ; # X
  %46 = phi i64 [%25, %$8] ; # Y
  %47 = phi i64 [%37, %$8] ; # Key
  %48 = phi i64 [0, %$8] ; # ->
; # (needSymb Exe Y)
  %49 = xor i64 %46, 8
  %50 = and i64 %49, 14
  %51 = icmp eq i64 %50, 0
  br i1 %51, label %$16, label %$15
$15:
  call void @symErr(i64 %0, i64 %46)
  unreachable
$16:
; # (push Key NIL)
  %52 = alloca i64, i64 2, align 16
  %53 = ptrtoint i64* %52 to i64
  %54 = inttoptr i64 %53 to i64*
  store i64 %47, i64* %54
; # (link (push Key NIL))
  %55 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %56 = load i64, i64* %55
  %57 = inttoptr i64 %53 to i64*
  %58 = getelementptr i64, i64* %57, i32 1
  store i64 %56, i64* %58
  %59 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %53, i64* %59
; # (when (sym? (val (tail Y))) (if (nil? Key) (dbFetch Exe Y) (dbTou...
; # (tail Y)
  %60 = add i64 %46, -8
; # (val (tail Y))
  %61 = inttoptr i64 %60 to i64*
  %62 = load i64, i64* %61
; # (sym? (val (tail Y)))
  %63 = and i64 %62, 8
  %64 = icmp ne i64 %63, 0
  br i1 %64, label %$17, label %$18
$17:
  %65 = phi i64 [%45, %$16] ; # X
  %66 = phi i64 [%46, %$16] ; # Y
  %67 = phi i64 [%47, %$16] ; # Key
; # (if (nil? Key) (dbFetch Exe Y) (dbTouch Exe Y))
; # (nil? Key)
  %68 = icmp eq i64 %67, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %68, label %$19, label %$20
$19:
  %69 = phi i64 [%65, %$17] ; # X
  %70 = phi i64 [%66, %$17] ; # Y
  %71 = phi i64 [%67, %$17] ; # Key
; # (dbFetch Exe Y)
  call void @dbFetch(i64 %0, i64 %70)
  br label %$21
$20:
  %72 = phi i64 [%65, %$17] ; # X
  %73 = phi i64 [%66, %$17] ; # Y
  %74 = phi i64 [%67, %$17] ; # Key
; # (dbTouch Exe Y)
  call void @dbTouch(i64 %0, i64 %73)
  br label %$21
$21:
  %75 = phi i64 [%69, %$19], [%72, %$20] ; # X
  %76 = phi i64 [%70, %$19], [%73, %$20] ; # Y
  %77 = phi i64 [%71, %$19], [%74, %$20] ; # Key
  br label %$18
$18:
  %78 = phi i64 [%45, %$16], [%75, %$21] ; # X
  %79 = phi i64 [%46, %$16], [%76, %$21] ; # Y
  %80 = phi i64 [%47, %$16], [%77, %$21] ; # Key
; # (prop Y Key)
  %81 = call i64 @prop(i64 %79, i64 %80)
; # (drop *Safe)
  %82 = inttoptr i64 %19 to i64*
  %83 = getelementptr i64, i64* %82, i32 1
  %84 = load i64, i64* %83
  %85 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %84, i64* %85
  ret i64 %81
}

define i64 @_Semicol(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (eval (++ X))) (when (pair X) (save Y (loop (...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (when (pair X) (save Y (loop (setq Y (getn Exe Y (++ X))) (? (ato...
; # (pair X)
  %16 = and i64 %7, 15
  %17 = icmp eq i64 %16, 0
  br i1 %17, label %$7, label %$8
$7:
  %18 = phi i64 [%7, %$2] ; # X
  %19 = phi i64 [%15, %$2] ; # Y
; # (save Y (loop (setq Y (getn Exe Y (++ X))) (? (atom X)) (safe Y))...
  %20 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %21 = load i64, i64* %20
  %22 = alloca i64, i64 2, align 16
  %23 = ptrtoint i64* %22 to i64
  %24 = inttoptr i64 %23 to i64*
  store i64 %19, i64* %24
  %25 = add i64 %23, 8
  %26 = inttoptr i64 %25 to i64*
  store i64 %21, i64* %26
  %27 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %23, i64* %27
; # (loop (setq Y (getn Exe Y (++ X))) (? (atom X)) (safe Y))
  br label %$9
$9:
  %28 = phi i64 [%18, %$7], [%37, %$10] ; # X
  %29 = phi i64 [%19, %$7], [%38, %$10] ; # Y
; # (++ X)
  %30 = inttoptr i64 %28 to i64*
  %31 = load i64, i64* %30
  %32 = getelementptr i64, i64* %30, i32 1
  %33 = load i64, i64* %32
; # (getn Exe Y (++ X))
  %34 = call i64 @getn(i64 %0, i64 %29, i64 %31)
; # (? (atom X))
; # (atom X)
  %35 = and i64 %33, 15
  %36 = icmp ne i64 %35, 0
  br i1 %36, label %$11, label %$10
$10:
  %37 = phi i64 [%33, %$9] ; # X
  %38 = phi i64 [%34, %$9] ; # Y
; # (safe Y)
  %39 = inttoptr i64 %23 to i64*
  store i64 %38, i64* %39
  br label %$9
$11:
  %40 = phi i64 [%33, %$9] ; # X
  %41 = phi i64 [%34, %$9] ; # Y
  %42 = phi i64 [0, %$9] ; # ->
; # drop
  %43 = inttoptr i64 %23 to i64*
  %44 = getelementptr i64, i64* %43, i32 1
  %45 = load i64, i64* %44
  %46 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %45, i64* %46
  br label %$8
$8:
  %47 = phi i64 [%7, %$2], [%40, %$11] ; # X
  %48 = phi i64 [%15, %$2], [%41, %$11] ; # Y
  ret i64 %48
}

define i64 @_SetCol(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (val $This) Key T) (loop (setq Key (++ X)) (?...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (val $This)
  %4 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 488) to i64) to i64*
  %5 = load i64, i64* %4
; # (loop (setq Key (++ X)) (? (atom (cdr X))) (setq Y (getn Exe Y Ke...
  br label %$2
$2:
  %6 = phi i64 [%3, %$1], [%17, %$3] ; # X
  %7 = phi i64 [%5, %$1], [%20, %$3] ; # Y
; # (++ X)
  %8 = inttoptr i64 %6 to i64*
  %9 = load i64, i64* %8
  %10 = getelementptr i64, i64* %8, i32 1
  %11 = load i64, i64* %10
; # (? (atom (cdr X)))
; # (cdr X)
  %12 = inttoptr i64 %11 to i64*
  %13 = getelementptr i64, i64* %12, i32 1
  %14 = load i64, i64* %13
; # (atom (cdr X))
  %15 = and i64 %14, 15
  %16 = icmp ne i64 %15, 0
  br i1 %16, label %$4, label %$3
$3:
  %17 = phi i64 [%11, %$2] ; # X
  %18 = phi i64 [%7, %$2] ; # Y
  %19 = phi i64 [%9, %$2] ; # Key
; # (getn Exe Y Key)
  %20 = call i64 @getn(i64 %0, i64 %18, i64 %19)
  br label %$2
$4:
  %21 = phi i64 [%11, %$2] ; # X
  %22 = phi i64 [%7, %$2] ; # Y
  %23 = phi i64 [%9, %$2] ; # Key
  %24 = phi i64 [0, %$2] ; # ->
; # (when (num? Y) (argErr Exe Y))
; # (num? Y)
  %25 = and i64 %22, 6
  %26 = icmp ne i64 %25, 0
  br i1 %26, label %$5, label %$6
$5:
  %27 = phi i64 [%21, %$4] ; # X
  %28 = phi i64 [%22, %$4] ; # Y
  %29 = phi i64 [%23, %$4] ; # Key
; # (argErr Exe Y)
  call void @argErr(i64 %0, i64 %28)
  unreachable
$6:
  %30 = phi i64 [%21, %$4] ; # X
  %31 = phi i64 [%22, %$4] ; # Y
  %32 = phi i64 [%23, %$4] ; # Key
; # (let Val (eval (car X)) (if (pair Y) (putn Exe Y Key Val) (when (...
; # (car X)
  %33 = inttoptr i64 %30 to i64*
  %34 = load i64, i64* %33
; # (eval (car X))
  %35 = and i64 %34, 6
  %36 = icmp ne i64 %35, 0
  br i1 %36, label %$9, label %$8
$9:
  br label %$7
$8:
  %37 = and i64 %34, 8
  %38 = icmp ne i64 %37, 0
  br i1 %38, label %$11, label %$10
$11:
  %39 = inttoptr i64 %34 to i64*
  %40 = load i64, i64* %39
  br label %$7
$10:
  %41 = call i64 @evList(i64 %34)
  br label %$7
$7:
  %42 = phi i64 [%34, %$9], [%40, %$11], [%41, %$10] ; # ->
; # (if (pair Y) (putn Exe Y Key Val) (when (sym? (val (tail Y))) (if...
; # (pair Y)
  %43 = and i64 %31, 15
  %44 = icmp eq i64 %43, 0
  br i1 %44, label %$12, label %$13
$12:
  %45 = phi i64 [%30, %$7] ; # X
  %46 = phi i64 [%31, %$7] ; # Y
  %47 = phi i64 [%32, %$7] ; # Key
; # (putn Exe Y Key Val)
  call void @putn(i64 %0, i64 %46, i64 %47, i64 %42)
  br label %$14
$13:
  %48 = phi i64 [%30, %$7] ; # X
  %49 = phi i64 [%31, %$7] ; # Y
  %50 = phi i64 [%32, %$7] ; # Key
; # (when (sym? (val (tail Y))) (if (nil? Key) (dbFetch Exe Y) (dbTou...
; # (tail Y)
  %51 = add i64 %49, -8
; # (val (tail Y))
  %52 = inttoptr i64 %51 to i64*
  %53 = load i64, i64* %52
; # (sym? (val (tail Y)))
  %54 = and i64 %53, 8
  %55 = icmp ne i64 %54, 0
  br i1 %55, label %$15, label %$16
$15:
  %56 = phi i64 [%48, %$13] ; # X
  %57 = phi i64 [%49, %$13] ; # Y
  %58 = phi i64 [%50, %$13] ; # Key
; # (if (nil? Key) (dbFetch Exe Y) (dbTouch Exe Y))
; # (nil? Key)
  %59 = icmp eq i64 %58, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %59, label %$17, label %$18
$17:
  %60 = phi i64 [%56, %$15] ; # X
  %61 = phi i64 [%57, %$15] ; # Y
  %62 = phi i64 [%58, %$15] ; # Key
; # (dbFetch Exe Y)
  call void @dbFetch(i64 %0, i64 %61)
  br label %$19
$18:
  %63 = phi i64 [%56, %$15] ; # X
  %64 = phi i64 [%57, %$15] ; # Y
  %65 = phi i64 [%58, %$15] ; # Key
; # (dbTouch Exe Y)
  call void @dbTouch(i64 %0, i64 %64)
  br label %$19
$19:
  %66 = phi i64 [%60, %$17], [%63, %$18] ; # X
  %67 = phi i64 [%61, %$17], [%64, %$18] ; # Y
  %68 = phi i64 [%62, %$17], [%65, %$18] ; # Key
  br label %$16
$16:
  %69 = phi i64 [%48, %$13], [%66, %$19] ; # X
  %70 = phi i64 [%49, %$13], [%67, %$19] ; # Y
  %71 = phi i64 [%50, %$13], [%68, %$19] ; # Key
; # (if (== ZERO Key) (set (chkVar Exe Y) Val) (put Y Key Val))
; # (== ZERO Key)
  %72 = icmp eq i64 2, %71
  br i1 %72, label %$20, label %$21
$20:
  %73 = phi i64 [%69, %$16] ; # X
  %74 = phi i64 [%70, %$16] ; # Y
  %75 = phi i64 [%71, %$16] ; # Key
; # (set (chkVar Exe Y) Val)
; # (chkVar Exe Y)
  %76 = icmp uge i64 %74, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %76, label %$24, label %$23
$24:
  %77 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %74
  br label %$23
$23:
  %78 = phi i1 [0, %$20], [%77, %$24] ; # ->
  br i1 %78, label %$25, label %$26
$25:
  call void @protErr(i64 %0, i64 %74)
  unreachable
$26:
  %79 = inttoptr i64 %74 to i64*
  store i64 %42, i64* %79
  br label %$22
$21:
  %80 = phi i64 [%69, %$16] ; # X
  %81 = phi i64 [%70, %$16] ; # Y
  %82 = phi i64 [%71, %$16] ; # Key
; # (put Y Key Val)
  call void @put(i64 %81, i64 %82, i64 %42)
  br label %$22
$22:
  %83 = phi i64 [%73, %$26], [%80, %$21] ; # X
  %84 = phi i64 [%74, %$26], [%81, %$21] ; # Y
  %85 = phi i64 [%75, %$26], [%82, %$21] ; # Key
  br label %$14
$14:
  %86 = phi i64 [%45, %$12], [%83, %$22] ; # X
  %87 = phi i64 [%46, %$12], [%84, %$22] ; # Y
  %88 = phi i64 [%47, %$12], [%85, %$22] ; # Key
  ret i64 %42
}

define i64 @_Col(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (val $This)) (loop (setq Y (getn Exe Y (++ X)...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (val $This)
  %4 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 488) to i64) to i64*
  %5 = load i64, i64* %4
; # (loop (setq Y (getn Exe Y (++ X))) (? (atom X) Y))
  br label %$2
$2:
  %6 = phi i64 [%3, %$1], [%17, %$3] ; # X
  %7 = phi i64 [%5, %$1], [%18, %$3] ; # Y
; # (++ X)
  %8 = inttoptr i64 %6 to i64*
  %9 = load i64, i64* %8
  %10 = getelementptr i64, i64* %8, i32 1
  %11 = load i64, i64* %10
; # (getn Exe Y (++ X))
  %12 = call i64 @getn(i64 %0, i64 %7, i64 %9)
; # (? (atom X) Y)
; # (atom X)
  %13 = and i64 %11, 15
  %14 = icmp ne i64 %13, 0
  br i1 %14, label %$5, label %$3
$5:
  %15 = phi i64 [%11, %$2] ; # X
  %16 = phi i64 [%12, %$2] ; # Y
  br label %$4
$3:
  %17 = phi i64 [%11, %$2] ; # X
  %18 = phi i64 [%12, %$2] ; # Y
  br label %$2
$4:
  %19 = phi i64 [%15, %$5] ; # X
  %20 = phi i64 [%16, %$5] ; # Y
  %21 = phi i64 [%16, %$5] ; # ->
  ret i64 %21
}

define i64 @_PropCol(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (val $This) Key T) (loop (setq Key (++ X)) (?...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (val $This)
  %4 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 488) to i64) to i64*
  %5 = load i64, i64* %4
; # (loop (setq Key (++ X)) (? (atom X)) (setq Y (getn Exe Y Key)))
  br label %$2
$2:
  %6 = phi i64 [%3, %$1], [%14, %$3] ; # X
  %7 = phi i64 [%5, %$1], [%17, %$3] ; # Y
; # (++ X)
  %8 = inttoptr i64 %6 to i64*
  %9 = load i64, i64* %8
  %10 = getelementptr i64, i64* %8, i32 1
  %11 = load i64, i64* %10
; # (? (atom X))
; # (atom X)
  %12 = and i64 %11, 15
  %13 = icmp ne i64 %12, 0
  br i1 %13, label %$4, label %$3
$3:
  %14 = phi i64 [%11, %$2] ; # X
  %15 = phi i64 [%7, %$2] ; # Y
  %16 = phi i64 [%9, %$2] ; # Key
; # (getn Exe Y Key)
  %17 = call i64 @getn(i64 %0, i64 %15, i64 %16)
  br label %$2
$4:
  %18 = phi i64 [%11, %$2] ; # X
  %19 = phi i64 [%7, %$2] ; # Y
  %20 = phi i64 [%9, %$2] ; # Key
  %21 = phi i64 [0, %$2] ; # ->
; # (needSymb Exe Y)
  %22 = xor i64 %19, 8
  %23 = and i64 %22, 14
  %24 = icmp eq i64 %23, 0
  br i1 %24, label %$6, label %$5
$5:
  call void @symErr(i64 %0, i64 %19)
  unreachable
$6:
; # (when (sym? (val (tail Y))) (if (nil? Key) (dbFetch Exe Y) (dbTou...
; # (tail Y)
  %25 = add i64 %19, -8
; # (val (tail Y))
  %26 = inttoptr i64 %25 to i64*
  %27 = load i64, i64* %26
; # (sym? (val (tail Y)))
  %28 = and i64 %27, 8
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %$7, label %$8
$7:
  %30 = phi i64 [%18, %$6] ; # X
  %31 = phi i64 [%19, %$6] ; # Y
  %32 = phi i64 [%20, %$6] ; # Key
; # (if (nil? Key) (dbFetch Exe Y) (dbTouch Exe Y))
; # (nil? Key)
  %33 = icmp eq i64 %32, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %33, label %$9, label %$10
$9:
  %34 = phi i64 [%30, %$7] ; # X
  %35 = phi i64 [%31, %$7] ; # Y
  %36 = phi i64 [%32, %$7] ; # Key
; # (dbFetch Exe Y)
  call void @dbFetch(i64 %0, i64 %35)
  br label %$11
$10:
  %37 = phi i64 [%30, %$7] ; # X
  %38 = phi i64 [%31, %$7] ; # Y
  %39 = phi i64 [%32, %$7] ; # Key
; # (dbTouch Exe Y)
  call void @dbTouch(i64 %0, i64 %38)
  br label %$11
$11:
  %40 = phi i64 [%34, %$9], [%37, %$10] ; # X
  %41 = phi i64 [%35, %$9], [%38, %$10] ; # Y
  %42 = phi i64 [%36, %$9], [%39, %$10] ; # Key
  br label %$8
$8:
  %43 = phi i64 [%18, %$6], [%40, %$11] ; # X
  %44 = phi i64 [%19, %$6], [%41, %$11] ; # Y
  %45 = phi i64 [%20, %$6], [%42, %$11] ; # Key
; # (prop Y Key)
  %46 = call i64 @prop(i64 %44, i64 %45)
  ret i64 %46
}

define i64 @_Putl(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (save (eval (++ X))) Z T) (loop (setq Z (eval...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (save (eval (++ X)))
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %17 = load i64, i64* %16
  %18 = alloca i64, i64 2, align 16
  %19 = ptrtoint i64* %18 to i64
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = add i64 %19, 8
  %22 = inttoptr i64 %21 to i64*
  store i64 %17, i64* %22
  %23 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %19, i64* %23
; # (loop (setq Z (eval (++ X))) (? (atom X)) (setq Y (safe (getn Exe...
  br label %$7
$7:
  %24 = phi i64 [%7, %$2], [%40, %$13] ; # X
  %25 = phi i64 [%15, %$2], [%43, %$13] ; # Y
; # (++ X)
  %26 = inttoptr i64 %24 to i64*
  %27 = load i64, i64* %26
  %28 = getelementptr i64, i64* %26, i32 1
  %29 = load i64, i64* %28
; # (eval (++ X))
  %30 = and i64 %27, 6
  %31 = icmp ne i64 %30, 0
  br i1 %31, label %$10, label %$9
$10:
  br label %$8
$9:
  %32 = and i64 %27, 8
  %33 = icmp ne i64 %32, 0
  br i1 %33, label %$12, label %$11
$12:
  %34 = inttoptr i64 %27 to i64*
  %35 = load i64, i64* %34
  br label %$8
$11:
  %36 = call i64 @evList(i64 %27)
  br label %$8
$8:
  %37 = phi i64 [%27, %$10], [%35, %$12], [%36, %$11] ; # ->
; # (? (atom X))
; # (atom X)
  %38 = and i64 %29, 15
  %39 = icmp ne i64 %38, 0
  br i1 %39, label %$14, label %$13
$13:
  %40 = phi i64 [%29, %$8] ; # X
  %41 = phi i64 [%25, %$8] ; # Y
  %42 = phi i64 [%37, %$8] ; # Z
; # (getn Exe Y Z)
  %43 = call i64 @getn(i64 %0, i64 %41, i64 %42)
; # (safe (getn Exe Y Z))
  %44 = inttoptr i64 %19 to i64*
  store i64 %43, i64* %44
  br label %$7
$14:
  %45 = phi i64 [%29, %$8] ; # X
  %46 = phi i64 [%25, %$8] ; # Y
  %47 = phi i64 [%37, %$8] ; # Z
  %48 = phi i64 [0, %$8] ; # ->
; # (let (R (save Z) Tail (val (tail (needSymb Exe Y)))) (when (sym? ...
; # (save Z)
  %49 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %50 = load i64, i64* %49
  %51 = alloca i64, i64 2, align 16
  %52 = ptrtoint i64* %51 to i64
  %53 = inttoptr i64 %52 to i64*
  store i64 %47, i64* %53
  %54 = add i64 %52, 8
  %55 = inttoptr i64 %54 to i64*
  store i64 %50, i64* %55
  %56 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %52, i64* %56
; # (needSymb Exe Y)
  %57 = xor i64 %46, 8
  %58 = and i64 %57, 14
  %59 = icmp eq i64 %58, 0
  br i1 %59, label %$16, label %$15
$15:
  call void @symErr(i64 %0, i64 %46)
  unreachable
$16:
; # (tail (needSymb Exe Y))
  %60 = add i64 %46, -8
; # (val (tail (needSymb Exe Y)))
  %61 = inttoptr i64 %60 to i64*
  %62 = load i64, i64* %61
; # (when (sym? (setq X Tail)) (dbTouch Exe Y) (setq X (& (val (tail ...
; # (sym? (setq X Tail))
  %63 = and i64 %62, 8
  %64 = icmp ne i64 %63, 0
  br i1 %64, label %$17, label %$18
$17:
  %65 = phi i64 [%62, %$16] ; # X
  %66 = phi i64 [%46, %$16] ; # Y
  %67 = phi i64 [%47, %$16] ; # Z
; # (dbTouch Exe Y)
  call void @dbTouch(i64 %0, i64 %66)
; # (tail Y)
  %68 = add i64 %66, -8
; # (val (tail Y))
  %69 = inttoptr i64 %68 to i64*
  %70 = load i64, i64* %69
; # (& (val (tail Y)) -9)
  %71 = and i64 %70, -9
  br label %$18
$18:
  %72 = phi i64 [%62, %$16], [%71, %$17] ; # X
  %73 = phi i64 [%46, %$16], [%66, %$17] ; # Y
  %74 = phi i64 [%47, %$16], [%67, %$17] ; # Z
; # (until (num? X) (shift X))
  br label %$19
$19:
  %75 = phi i64 [%72, %$18], [%85, %$20] ; # X
  %76 = phi i64 [%73, %$18], [%81, %$20] ; # Y
  %77 = phi i64 [%74, %$18], [%82, %$20] ; # Z
; # (num? X)
  %78 = and i64 %75, 6
  %79 = icmp ne i64 %78, 0
  br i1 %79, label %$21, label %$20
$20:
  %80 = phi i64 [%75, %$19] ; # X
  %81 = phi i64 [%76, %$19] ; # Y
  %82 = phi i64 [%77, %$19] ; # Z
; # (shift X)
  %83 = inttoptr i64 %80 to i64*
  %84 = getelementptr i64, i64* %83, i32 1
  %85 = load i64, i64* %84
  br label %$19
$21:
  %86 = phi i64 [%75, %$19] ; # X
  %87 = phi i64 [%76, %$19] ; # Y
  %88 = phi i64 [%77, %$19] ; # Z
; # (while (pair Z) (let P (++ Z) (if (atom P) (setq X (cons P X)) (u...
  br label %$22
$22:
  %89 = phi i64 [%86, %$21], [%138, %$27] ; # X
  %90 = phi i64 [%87, %$21], [%139, %$27] ; # Y
  %91 = phi i64 [%88, %$21], [%140, %$27] ; # Z
; # (pair Z)
  %92 = and i64 %91, 15
  %93 = icmp eq i64 %92, 0
  br i1 %93, label %$23, label %$24
$23:
  %94 = phi i64 [%89, %$22] ; # X
  %95 = phi i64 [%90, %$22] ; # Y
  %96 = phi i64 [%91, %$22] ; # Z
; # (let P (++ Z) (if (atom P) (setq X (cons P X)) (unless (nil? (car...
; # (++ Z)
  %97 = inttoptr i64 %96 to i64*
  %98 = load i64, i64* %97
  %99 = getelementptr i64, i64* %97, i32 1
  %100 = load i64, i64* %99
; # (if (atom P) (setq X (cons P X)) (unless (nil? (car P)) (when (t?...
; # (atom P)
  %101 = and i64 %98, 15
  %102 = icmp ne i64 %101, 0
  br i1 %102, label %$25, label %$26
$25:
  %103 = phi i64 [%94, %$23] ; # X
  %104 = phi i64 [%95, %$23] ; # Y
  %105 = phi i64 [%100, %$23] ; # Z
  %106 = phi i64 [%98, %$23] ; # P
; # (cons P X)
  %107 = call i64 @cons(i64 %106, i64 %103)
  br label %$27
$26:
  %108 = phi i64 [%94, %$23] ; # X
  %109 = phi i64 [%95, %$23] ; # Y
  %110 = phi i64 [%100, %$23] ; # Z
  %111 = phi i64 [%98, %$23] ; # P
; # (unless (nil? (car P)) (when (t? (car P)) (setq P (cdr P))) (setq...
; # (car P)
  %112 = inttoptr i64 %111 to i64*
  %113 = load i64, i64* %112
; # (nil? (car P))
  %114 = icmp eq i64 %113, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %114, label %$29, label %$28
$28:
  %115 = phi i64 [%108, %$26] ; # X
  %116 = phi i64 [%109, %$26] ; # Y
  %117 = phi i64 [%110, %$26] ; # Z
  %118 = phi i64 [%111, %$26] ; # P
; # (when (t? (car P)) (setq P (cdr P)))
; # (car P)
  %119 = inttoptr i64 %118 to i64*
  %120 = load i64, i64* %119
; # (t? (car P))
  %121 = icmp eq i64 %120, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %121, label %$30, label %$31
$30:
  %122 = phi i64 [%115, %$28] ; # X
  %123 = phi i64 [%116, %$28] ; # Y
  %124 = phi i64 [%117, %$28] ; # Z
  %125 = phi i64 [%118, %$28] ; # P
; # (cdr P)
  %126 = inttoptr i64 %125 to i64*
  %127 = getelementptr i64, i64* %126, i32 1
  %128 = load i64, i64* %127
  br label %$31
$31:
  %129 = phi i64 [%115, %$28], [%122, %$30] ; # X
  %130 = phi i64 [%116, %$28], [%123, %$30] ; # Y
  %131 = phi i64 [%117, %$28], [%124, %$30] ; # Z
  %132 = phi i64 [%118, %$28], [%128, %$30] ; # P
; # (cons P X)
  %133 = call i64 @cons(i64 %132, i64 %129)
  br label %$29
$29:
  %134 = phi i64 [%108, %$26], [%133, %$31] ; # X
  %135 = phi i64 [%109, %$26], [%130, %$31] ; # Y
  %136 = phi i64 [%110, %$26], [%131, %$31] ; # Z
  %137 = phi i64 [%111, %$26], [%132, %$31] ; # P
  br label %$27
$27:
  %138 = phi i64 [%107, %$25], [%134, %$29] ; # X
  %139 = phi i64 [%104, %$25], [%135, %$29] ; # Y
  %140 = phi i64 [%105, %$25], [%136, %$29] ; # Z
  %141 = phi i64 [%106, %$25], [%137, %$29] ; # P
  br label %$22
$24:
  %142 = phi i64 [%89, %$22] ; # X
  %143 = phi i64 [%90, %$22] ; # Y
  %144 = phi i64 [%91, %$22] ; # Z
; # (set (tail Y) (if (sym? Tail) (sym X) X))
; # (tail Y)
  %145 = add i64 %143, -8
; # (if (sym? Tail) (sym X) X)
; # (sym? Tail)
  %146 = and i64 %62, 8
  %147 = icmp ne i64 %146, 0
  br i1 %147, label %$32, label %$33
$32:
  %148 = phi i64 [%142, %$24] ; # X
  %149 = phi i64 [%143, %$24] ; # Y
  %150 = phi i64 [%144, %$24] ; # Z
; # (sym X)
  %151 = or i64 %148, 8
  br label %$34
$33:
  %152 = phi i64 [%142, %$24] ; # X
  %153 = phi i64 [%143, %$24] ; # Y
  %154 = phi i64 [%144, %$24] ; # Z
  br label %$34
$34:
  %155 = phi i64 [%148, %$32], [%152, %$33] ; # X
  %156 = phi i64 [%149, %$32], [%153, %$33] ; # Y
  %157 = phi i64 [%150, %$32], [%154, %$33] ; # Z
  %158 = phi i64 [%151, %$32], [%152, %$33] ; # ->
  %159 = inttoptr i64 %145 to i64*
  store i64 %158, i64* %159
; # (drop *Safe)
  %160 = inttoptr i64 %19 to i64*
  %161 = getelementptr i64, i64* %160, i32 1
  %162 = load i64, i64* %161
  %163 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %162, i64* %163
  ret i64 %47
}

define i64 @_Getl(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (save (eval (car X)))) (while (pair (shift X)...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (car X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (car X))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (save (eval (car X)))
  %14 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %15 = load i64, i64* %14
  %16 = alloca i64, i64 2, align 16
  %17 = ptrtoint i64* %16 to i64
  %18 = inttoptr i64 %17 to i64*
  store i64 %13, i64* %18
  %19 = add i64 %17, 8
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %17, i64* %21
; # (while (pair (shift X)) (setq Y (safe (getn Exe Y (eval (car X)))...
  br label %$7
$7:
  %22 = phi i64 [%3, %$2], [%29, %$10] ; # X
  %23 = phi i64 [%13, %$2], [%41, %$10] ; # Y
; # (shift X)
  %24 = inttoptr i64 %22 to i64*
  %25 = getelementptr i64, i64* %24, i32 1
  %26 = load i64, i64* %25
; # (pair (shift X))
  %27 = and i64 %26, 15
  %28 = icmp eq i64 %27, 0
  br i1 %28, label %$8, label %$9
$8:
  %29 = phi i64 [%26, %$7] ; # X
  %30 = phi i64 [%23, %$7] ; # Y
; # (car X)
  %31 = inttoptr i64 %29 to i64*
  %32 = load i64, i64* %31
; # (eval (car X))
  %33 = and i64 %32, 6
  %34 = icmp ne i64 %33, 0
  br i1 %34, label %$12, label %$11
$12:
  br label %$10
$11:
  %35 = and i64 %32, 8
  %36 = icmp ne i64 %35, 0
  br i1 %36, label %$14, label %$13
$14:
  %37 = inttoptr i64 %32 to i64*
  %38 = load i64, i64* %37
  br label %$10
$13:
  %39 = call i64 @evList(i64 %32)
  br label %$10
$10:
  %40 = phi i64 [%32, %$12], [%38, %$14], [%39, %$13] ; # ->
; # (getn Exe Y (eval (car X)))
  %41 = call i64 @getn(i64 %0, i64 %30, i64 %40)
; # (safe (getn Exe Y (eval (car X))))
  %42 = inttoptr i64 %17 to i64*
  store i64 %41, i64* %42
  br label %$7
$9:
  %43 = phi i64 [%26, %$7] ; # X
  %44 = phi i64 [%23, %$7] ; # Y
; # (when (sym? (setq X (val (tail (needSymb Exe Y))))) (dbFetch Exe ...
; # (needSymb Exe Y)
  %45 = xor i64 %44, 8
  %46 = and i64 %45, 14
  %47 = icmp eq i64 %46, 0
  br i1 %47, label %$16, label %$15
$15:
  call void @symErr(i64 %0, i64 %44)
  unreachable
$16:
; # (tail (needSymb Exe Y))
  %48 = add i64 %44, -8
; # (val (tail (needSymb Exe Y)))
  %49 = inttoptr i64 %48 to i64*
  %50 = load i64, i64* %49
; # (sym? (setq X (val (tail (needSymb Exe Y)))))
  %51 = and i64 %50, 8
  %52 = icmp ne i64 %51, 0
  br i1 %52, label %$17, label %$18
$17:
  %53 = phi i64 [%50, %$16] ; # X
  %54 = phi i64 [%44, %$16] ; # Y
; # (dbFetch Exe Y)
  call void @dbFetch(i64 %0, i64 %54)
; # (tail Y)
  %55 = add i64 %54, -8
; # (val (tail Y))
  %56 = inttoptr i64 %55 to i64*
  %57 = load i64, i64* %56
; # (& (val (tail Y)) -9)
  %58 = and i64 %57, -9
  br label %$18
$18:
  %59 = phi i64 [%50, %$16], [%58, %$17] ; # X
  %60 = phi i64 [%44, %$16], [%54, %$17] ; # Y
; # (if (num? X) $Nil (let R (setq Y (cons (car X) $Nil)) (link (push...
; # (num? X)
  %61 = and i64 %59, 6
  %62 = icmp ne i64 %61, 0
  br i1 %62, label %$19, label %$20
$19:
  %63 = phi i64 [%59, %$18] ; # X
  %64 = phi i64 [%60, %$18] ; # Y
  br label %$21
$20:
  %65 = phi i64 [%59, %$18] ; # X
  %66 = phi i64 [%60, %$18] ; # Y
; # (let R (setq Y (cons (car X) $Nil)) (link (push R NIL)) (while (p...
; # (car X)
  %67 = inttoptr i64 %65 to i64*
  %68 = load i64, i64* %67
; # (cons (car X) $Nil)
  %69 = call i64 @cons(i64 %68, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (push R NIL)
  %70 = alloca i64, i64 2, align 16
  %71 = ptrtoint i64* %70 to i64
  %72 = inttoptr i64 %71 to i64*
  store i64 %69, i64* %72
; # (link (push R NIL))
  %73 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %74 = load i64, i64* %73
  %75 = inttoptr i64 %71 to i64*
  %76 = getelementptr i64, i64* %75, i32 1
  store i64 %74, i64* %76
  %77 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %71, i64* %77
; # (while (pair (shift X)) (setq Y (set 2 Y (cons (car X) $Nil))))
  br label %$22
$22:
  %78 = phi i64 [%65, %$20], [%85, %$23] ; # X
  %79 = phi i64 [%69, %$20], [%89, %$23] ; # Y
; # (shift X)
  %80 = inttoptr i64 %78 to i64*
  %81 = getelementptr i64, i64* %80, i32 1
  %82 = load i64, i64* %81
; # (pair (shift X))
  %83 = and i64 %82, 15
  %84 = icmp eq i64 %83, 0
  br i1 %84, label %$23, label %$24
$23:
  %85 = phi i64 [%82, %$22] ; # X
  %86 = phi i64 [%79, %$22] ; # Y
; # (set 2 Y (cons (car X) $Nil))
; # (car X)
  %87 = inttoptr i64 %85 to i64*
  %88 = load i64, i64* %87
; # (cons (car X) $Nil)
  %89 = call i64 @cons(i64 %88, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %90 = inttoptr i64 %86 to i64*
  %91 = getelementptr i64, i64* %90, i32 1
  store i64 %89, i64* %91
  br label %$22
$24:
  %92 = phi i64 [%82, %$22] ; # X
  %93 = phi i64 [%79, %$22] ; # Y
  br label %$21
$21:
  %94 = phi i64 [%63, %$19], [%92, %$24] ; # X
  %95 = phi i64 [%64, %$19], [%93, %$24] ; # Y
  %96 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$19], [%69, %$24] ; # ->
; # (drop *Safe)
  %97 = inttoptr i64 %17 to i64*
  %98 = getelementptr i64, i64* %97, i32 1
  %99 = load i64, i64* %98
  %100 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %99, i64* %100
  ret i64 %96
}

define void @wipe(i64, i64) align 8 {
$1:
; # (let (Tail (val (tail (needSymb Exe X))) Nm (name (& Tail -9))) (...
; # (needSymb Exe X)
  %2 = xor i64 %1, 8
  %3 = and i64 %2, 14
  %4 = icmp eq i64 %3, 0
  br i1 %4, label %$3, label %$2
$2:
  call void @symErr(i64 %0, i64 %1)
  unreachable
$3:
; # (tail (needSymb Exe X))
  %5 = add i64 %1, -8
; # (val (tail (needSymb Exe X)))
  %6 = inttoptr i64 %5 to i64*
  %7 = load i64, i64* %6
; # (& Tail -9)
  %8 = and i64 %7, -9
; # (name (& Tail -9))
  br label %$4
$4:
  %9 = phi i64 [%8, %$3], [%15, %$5] ; # Tail
  %10 = and i64 %9, 6
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$5:
  %12 = phi i64 [%9, %$4] ; # Tail
  %13 = inttoptr i64 %12 to i64*
  %14 = getelementptr i64, i64* %13, i32 1
  %15 = load i64, i64* %14
  br label %$4
$6:
  %16 = phi i64 [%9, %$4] ; # Tail
; # (ifn (sym? Tail) (set X $Nil (tail X) Nm) (setq Nm (add Nm Nm)) (...
; # (sym? Tail)
  %17 = and i64 %7, 8
  %18 = icmp ne i64 %17, 0
  br i1 %18, label %$8, label %$7
$7:
  %19 = phi i64 [%16, %$6] ; # Nm
; # (set X $Nil (tail X) Nm)
  %20 = inttoptr i64 %1 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %20
; # (tail X)
  %21 = add i64 %1, -8
  %22 = inttoptr i64 %21 to i64*
  store i64 %19, i64* %22
  br label %$9
$8:
  %23 = phi i64 [%16, %$6] ; # Nm
; # (add Nm Nm)
  %24 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %23, i64 %23)
  %25 = extractvalue {i64, i1} %24, 1
  %26 = extractvalue {i64, i1} %24, 0
; # (unless @@ (setq Nm (add Nm Nm)) (when @@ (set X $Nil (tail X) (s...
  br i1 %25, label %$11, label %$10
$10:
  %27 = phi i64 [%26, %$8] ; # Nm
; # (add Nm Nm)
  %28 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %27, i64 %27)
  %29 = extractvalue {i64, i1} %28, 1
  %30 = extractvalue {i64, i1} %28, 0
; # (when @@ (set X $Nil (tail X) (sym (shr Nm 2))))
  br i1 %29, label %$12, label %$13
$12:
  %31 = phi i64 [%30, %$10] ; # Nm
; # (set X $Nil (tail X) (sym (shr Nm 2)))
  %32 = inttoptr i64 %1 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %32
; # (tail X)
  %33 = add i64 %1, -8
; # (shr Nm 2)
  %34 = lshr i64 %31, 2
; # (sym (shr Nm 2))
  %35 = or i64 %34, 8
  %36 = inttoptr i64 %33 to i64*
  store i64 %35, i64* %36
  br label %$13
$13:
  %37 = phi i64 [%30, %$10], [%31, %$12] ; # Nm
  br label %$11
$11:
  %38 = phi i64 [%26, %$8], [%37, %$13] ; # Nm
  br label %$9
$9:
  %39 = phi i64 [%19, %$7], [%38, %$11] ; # Nm
  ret void
}

define i64 @_Wipe(i64) align 8 {
$1:
; # (let X (eval (cadr Exe)) (unless (nil? X) (if (atom X) (wipe Exe ...
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (unless (nil? X) (if (atom X) (wipe Exe X) (let Y X (loop (wipe E...
; # (nil? X)
  %14 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %14, label %$8, label %$7
$7:
; # (if (atom X) (wipe Exe X) (let Y X (loop (wipe Exe (++ Y)) (? (at...
; # (atom X)
  %15 = and i64 %13, 15
  %16 = icmp ne i64 %15, 0
  br i1 %16, label %$9, label %$10
$9:
; # (wipe Exe X)
  call void @wipe(i64 %0, i64 %13)
  br label %$11
$10:
; # (let Y X (loop (wipe Exe (++ Y)) (? (atom Y))))
; # (loop (wipe Exe (++ Y)) (? (atom Y)))
  br label %$12
$12:
  %17 = phi i64 [%13, %$10], [%24, %$13] ; # Y
; # (++ Y)
  %18 = inttoptr i64 %17 to i64*
  %19 = load i64, i64* %18
  %20 = getelementptr i64, i64* %18, i32 1
  %21 = load i64, i64* %20
; # (wipe Exe (++ Y))
  call void @wipe(i64 %0, i64 %19)
; # (? (atom Y))
; # (atom Y)
  %22 = and i64 %21, 15
  %23 = icmp ne i64 %22, 0
  br i1 %23, label %$14, label %$13
$13:
  %24 = phi i64 [%21, %$12] ; # Y
  br label %$12
$14:
  %25 = phi i64 [%21, %$12] ; # Y
  %26 = phi i64 [0, %$12] ; # ->
  br label %$11
$11:
  br label %$8
$8:
  ret i64 %13
}

define i64 @meta(i64, i64) align 8 {
$1:
; # (loop (? (atom X) $Nil) (let Y (car X) (when (symb? Y) (? (not (n...
  br label %$2
$2:
  %2 = phi i64 [%0, %$1], [%38, %$7] ; # X
; # (? (atom X) $Nil)
; # (atom X)
  %3 = and i64 %2, 15
  %4 = icmp ne i64 %3, 0
  br i1 %4, label %$5, label %$3
$5:
  %5 = phi i64 [%2, %$2] ; # X
  br label %$4
$3:
  %6 = phi i64 [%2, %$2] ; # X
; # (let Y (car X) (when (symb? Y) (? (not (nil? (if (== Key ZERO) (v...
; # (car X)
  %7 = inttoptr i64 %6 to i64*
  %8 = load i64, i64* %7
; # (when (symb? Y) (? (not (nil? (if (== Key ZERO) (val Y) (get Y Ke...
; # (symb? Y)
  %9 = xor i64 %8, 8
  %10 = and i64 %9, 14
  %11 = icmp eq i64 %10, 0
  br i1 %11, label %$6, label %$7
$6:
  %12 = phi i64 [%6, %$3] ; # X
; # (? (not (nil? (if (== Key ZERO) (val Y) (get Y Key)))) @)
; # (if (== Key ZERO) (val Y) (get Y Key))
; # (== Key ZERO)
  %13 = icmp eq i64 %1, 2
  br i1 %13, label %$8, label %$9
$8:
  %14 = phi i64 [%12, %$6] ; # X
; # (val Y)
  %15 = inttoptr i64 %8 to i64*
  %16 = load i64, i64* %15
  br label %$10
$9:
  %17 = phi i64 [%12, %$6] ; # X
; # (get Y Key)
  %18 = call i64 @get(i64 %8, i64 %1)
  br label %$10
$10:
  %19 = phi i64 [%14, %$8], [%17, %$9] ; # X
  %20 = phi i64 [%16, %$8], [%18, %$9] ; # ->
; # (nil? (if (== Key ZERO) (val Y) (get Y Key)))
  %21 = icmp eq i64 %20, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
; # (not (nil? (if (== Key ZERO) (val Y) (get Y Key))))
  %22 = icmp eq i1 %21, 0
  br i1 %22, label %$12, label %$11
$12:
  %23 = phi i64 [%19, %$10] ; # X
  br label %$4
$11:
  %24 = phi i64 [%19, %$10] ; # X
; # (stkChk 0)
  %25 = load i8*, i8** @$StkLimit
  %26 = call i8* @llvm.stacksave()
  %27 = icmp ugt i8* %25, %26
  br i1 %27, label %$13, label %$14
$13:
  call void @stkErr(i64 0)
  unreachable
$14:
; # (? (not (nil? (meta (car Y) Key))) @)
; # (car Y)
  %28 = inttoptr i64 %8 to i64*
  %29 = load i64, i64* %28
; # (meta (car Y) Key)
  %30 = call i64 @meta(i64 %29, i64 %1)
; # (nil? (meta (car Y) Key))
  %31 = icmp eq i64 %30, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
; # (not (nil? (meta (car Y) Key)))
  %32 = icmp eq i1 %31, 0
  br i1 %32, label %$16, label %$15
$16:
  %33 = phi i64 [%24, %$14] ; # X
  br label %$4
$15:
  %34 = phi i64 [%24, %$14] ; # X
  br label %$7
$7:
  %35 = phi i64 [%6, %$3], [%34, %$15] ; # X
; # (shift X)
  %36 = inttoptr i64 %35 to i64*
  %37 = getelementptr i64, i64* %36, i32 1
  %38 = load i64, i64* %37
  br label %$2
$4:
  %39 = phi i64 [%5, %$5], [%23, %$12], [%33, %$16] ; # X
  %40 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$5], [%20, %$12], [%30, %$16] ; # ->
  ret i64 %40
}

define i64 @_Meta(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (save (eval (++ X)))) (when (num? Y) (argErr ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (save (eval (++ X)))
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %17 = load i64, i64* %16
  %18 = alloca i64, i64 2, align 16
  %19 = ptrtoint i64* %18 to i64
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = add i64 %19, 8
  %22 = inttoptr i64 %21 to i64*
  store i64 %17, i64* %22
  %23 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %19, i64* %23
; # (when (num? Y) (argErr Exe Y))
; # (num? Y)
  %24 = and i64 %15, 6
  %25 = icmp ne i64 %24, 0
  br i1 %25, label %$7, label %$8
$7:
  %26 = phi i64 [%7, %$2] ; # X
  %27 = phi i64 [%15, %$2] ; # Y
; # (argErr Exe Y)
  call void @argErr(i64 %0, i64 %27)
  unreachable
$8:
  %28 = phi i64 [%7, %$2] ; # X
  %29 = phi i64 [%15, %$2] ; # Y
; # (when (sym? Y) (when (sym? (val (tail Y))) (dbFetch Exe Y)) (setq...
; # (sym? Y)
  %30 = and i64 %29, 8
  %31 = icmp ne i64 %30, 0
  br i1 %31, label %$9, label %$10
$9:
  %32 = phi i64 [%28, %$8] ; # X
  %33 = phi i64 [%29, %$8] ; # Y
; # (when (sym? (val (tail Y))) (dbFetch Exe Y))
; # (tail Y)
  %34 = add i64 %33, -8
; # (val (tail Y))
  %35 = inttoptr i64 %34 to i64*
  %36 = load i64, i64* %35
; # (sym? (val (tail Y)))
  %37 = and i64 %36, 8
  %38 = icmp ne i64 %37, 0
  br i1 %38, label %$11, label %$12
$11:
  %39 = phi i64 [%32, %$9] ; # X
  %40 = phi i64 [%33, %$9] ; # Y
; # (dbFetch Exe Y)
  call void @dbFetch(i64 %0, i64 %40)
  br label %$12
$12:
  %41 = phi i64 [%32, %$9], [%39, %$11] ; # X
  %42 = phi i64 [%33, %$9], [%40, %$11] ; # Y
; # (val Y)
  %43 = inttoptr i64 %42 to i64*
  %44 = load i64, i64* %43
  br label %$10
$10:
  %45 = phi i64 [%28, %$8], [%41, %$12] ; # X
  %46 = phi i64 [%29, %$8], [%44, %$12] ; # Y
; # (car X)
  %47 = inttoptr i64 %45 to i64*
  %48 = load i64, i64* %47
; # (eval (car X))
  %49 = and i64 %48, 6
  %50 = icmp ne i64 %49, 0
  br i1 %50, label %$15, label %$14
$15:
  br label %$13
$14:
  %51 = and i64 %48, 8
  %52 = icmp ne i64 %51, 0
  br i1 %52, label %$17, label %$16
$17:
  %53 = inttoptr i64 %48 to i64*
  %54 = load i64, i64* %53
  br label %$13
$16:
  %55 = call i64 @evList(i64 %48)
  br label %$13
$13:
  %56 = phi i64 [%48, %$15], [%54, %$17], [%55, %$16] ; # ->
; # (meta Y (eval (car X)))
  %57 = call i64 @meta(i64 %46, i64 %56)
; # (while (pair (shift X)) (safe Y) (setq Y (getn Exe Y (eval (car X...
  br label %$18
$18:
  %58 = phi i64 [%45, %$13], [%65, %$21] ; # X
  %59 = phi i64 [%57, %$13], [%78, %$21] ; # Y
; # (shift X)
  %60 = inttoptr i64 %58 to i64*
  %61 = getelementptr i64, i64* %60, i32 1
  %62 = load i64, i64* %61
; # (pair (shift X))
  %63 = and i64 %62, 15
  %64 = icmp eq i64 %63, 0
  br i1 %64, label %$19, label %$20
$19:
  %65 = phi i64 [%62, %$18] ; # X
  %66 = phi i64 [%59, %$18] ; # Y
; # (safe Y)
  %67 = inttoptr i64 %19 to i64*
  store i64 %66, i64* %67
; # (car X)
  %68 = inttoptr i64 %65 to i64*
  %69 = load i64, i64* %68
; # (eval (car X))
  %70 = and i64 %69, 6
  %71 = icmp ne i64 %70, 0
  br i1 %71, label %$23, label %$22
$23:
  br label %$21
$22:
  %72 = and i64 %69, 8
  %73 = icmp ne i64 %72, 0
  br i1 %73, label %$25, label %$24
$25:
  %74 = inttoptr i64 %69 to i64*
  %75 = load i64, i64* %74
  br label %$21
$24:
  %76 = call i64 @evList(i64 %69)
  br label %$21
$21:
  %77 = phi i64 [%69, %$23], [%75, %$25], [%76, %$24] ; # ->
; # (getn Exe Y (eval (car X)))
  %78 = call i64 @getn(i64 %0, i64 %66, i64 %77)
  br label %$18
$20:
  %79 = phi i64 [%62, %$18] ; # X
  %80 = phi i64 [%59, %$18] ; # Y
; # (drop *Safe)
  %81 = inttoptr i64 %19 to i64*
  %82 = getelementptr i64, i64* %81, i32 1
  %83 = load i64, i64* %82
  %84 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %83, i64* %84
  ret i64 %80
}

define i64 @_LowQ(i64) align 8 {
$1:
; # (let X (eval (cadr Exe)) (if (and (symb? X) (isLowc (firstChar X)...
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (if (and (symb? X) (isLowc (firstChar X))) X $Nil)
; # (and (symb? X) (isLowc (firstChar X)))
; # (symb? X)
  %14 = xor i64 %13, 8
  %15 = and i64 %14, 14
  %16 = icmp eq i64 %15, 0
  br i1 %16, label %$8, label %$7
$8:
; # (firstChar X)
  %17 = call i32 @firstChar(i64 %13)
; # (isLowc (firstChar X))
  %18 = call i1 @isLowc(i32 %17)
  br label %$7
$7:
  %19 = phi i1 [0, %$2], [%18, %$8] ; # ->
  br i1 %19, label %$9, label %$10
$9:
  br label %$11
$10:
  br label %$11
$11:
  %20 = phi i64 [%13, %$9], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$10] ; # ->
  ret i64 %20
}

define i64 @_UppQ(i64) align 8 {
$1:
; # (let X (eval (cadr Exe)) (if (and (symb? X) (isUppc (firstChar X)...
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (if (and (symb? X) (isUppc (firstChar X))) X $Nil)
; # (and (symb? X) (isUppc (firstChar X)))
; # (symb? X)
  %14 = xor i64 %13, 8
  %15 = and i64 %14, 14
  %16 = icmp eq i64 %15, 0
  br i1 %16, label %$8, label %$7
$8:
; # (firstChar X)
  %17 = call i32 @firstChar(i64 %13)
; # (isUppc (firstChar X))
  %18 = call i1 @isUppc(i32 %17)
  br label %$7
$7:
  %19 = phi i1 [0, %$2], [%18, %$8] ; # ->
  br i1 %19, label %$9, label %$10
$9:
  br label %$11
$10:
  br label %$11
$11:
  %20 = phi i64 [%13, %$9], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$10] ; # ->
  ret i64 %20
}

define i64 @_Lowc(i64) align 8 {
$1:
; # (let X (eval (cadr Exe)) (if (or (not (symb? X)) (nil? X)) X (let...
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (if (or (not (symb? X)) (nil? X)) X (let (P (push 0 (xName X) NIL...
; # (or (not (symb? X)) (nil? X))
; # (symb? X)
  %14 = xor i64 %13, 8
  %15 = and i64 %14, 14
  %16 = icmp eq i64 %15, 0
; # (not (symb? X))
  %17 = icmp eq i1 %16, 0
  br i1 %17, label %$7, label %$8
$8:
; # (nil? X)
  %18 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$7
$7:
  %19 = phi i1 [1, %$2], [%18, %$8] ; # ->
  br i1 %19, label %$9, label %$10
$9:
  br label %$11
$10:
; # (let (P (push 0 (xName X) NIL) Q (link (ofs P 1) T) R (push 4 NIL...
; # (xName X)
  %20 = call i64 @xName(i64 %13)
; # (push 0 (xName X) NIL)
  %21 = alloca i64, i64 3, align 16
  store i64 0, i64* %21
  %22 = getelementptr i64, i64* %21, i32 1
  store i64 %20, i64* %22
; # (ofs P 1)
  %23 = getelementptr i64, i64* %21, i32 1
; # (link (ofs P 1) T)
  %24 = ptrtoint i64* %23 to i64
  %25 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %26 = load i64, i64* %25
  %27 = inttoptr i64 %24 to i64*
  %28 = getelementptr i64, i64* %27, i32 1
  store i64 %26, i64* %28
  %29 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %24, i64* %29
; # (push 4 NIL ZERO NIL)
  %30 = alloca i64, i64 4, align 16
  store i64 4, i64* %30
  %31 = getelementptr i64, i64* %30, i32 2
  store i64 2, i64* %31
; # (ofs R 2)
  %32 = getelementptr i64, i64* %30, i32 2
; # (link (ofs R 2))
  %33 = ptrtoint i64* %32 to i64
  %34 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %35 = load i64, i64* %34
  %36 = inttoptr i64 %33 to i64*
  %37 = getelementptr i64, i64* %36, i32 1
  store i64 %35, i64* %37
  %38 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %33, i64* %38
; # (while (setq C (symChar P)) (charSym (toLowerCase C) R))
  br label %$12
$12:
; # (symChar P)
  %39 = call i32 @symChar(i64* %21)
  %40 = icmp ne i32 %39, 0
  br i1 %40, label %$13, label %$14
$13:
  %41 = phi i32 [%39, %$12] ; # C
; # (toLowerCase C)
  %42 = call i32 @toLowerCase(i32 %41)
; # (charSym (toLowerCase C) R)
  call void @charSym(i32 %42, i64* %30)
  br label %$12
$14:
  %43 = phi i32 [%39, %$12] ; # C
; # (val 3 R)
  %44 = getelementptr i64, i64* %30, i32 2
  %45 = load i64, i64* %44
; # (consStr (val 3 R))
  %46 = call i64 @consStr(i64 %45)
; # (drop *Safe)
  %47 = inttoptr i64 %24 to i64*
  %48 = getelementptr i64, i64* %47, i32 1
  %49 = load i64, i64* %48
  %50 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %49, i64* %50
  br label %$11
$11:
  %51 = phi i64 [%13, %$9], [%46, %$14] ; # ->
  ret i64 %51
}

define i64 @_Uppc(i64) align 8 {
$1:
; # (let X (eval (cadr Exe)) (if (or (not (symb? X)) (nil? X)) X (let...
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (if (or (not (symb? X)) (nil? X)) X (let (P (push 0 (xName X) NIL...
; # (or (not (symb? X)) (nil? X))
; # (symb? X)
  %14 = xor i64 %13, 8
  %15 = and i64 %14, 14
  %16 = icmp eq i64 %15, 0
; # (not (symb? X))
  %17 = icmp eq i1 %16, 0
  br i1 %17, label %$7, label %$8
$8:
; # (nil? X)
  %18 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$7
$7:
  %19 = phi i1 [1, %$2], [%18, %$8] ; # ->
  br i1 %19, label %$9, label %$10
$9:
  br label %$11
$10:
; # (let (P (push 0 (xName X) NIL) Q (link (ofs P 1) T) R (push 4 NIL...
; # (xName X)
  %20 = call i64 @xName(i64 %13)
; # (push 0 (xName X) NIL)
  %21 = alloca i64, i64 3, align 16
  store i64 0, i64* %21
  %22 = getelementptr i64, i64* %21, i32 1
  store i64 %20, i64* %22
; # (ofs P 1)
  %23 = getelementptr i64, i64* %21, i32 1
; # (link (ofs P 1) T)
  %24 = ptrtoint i64* %23 to i64
  %25 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %26 = load i64, i64* %25
  %27 = inttoptr i64 %24 to i64*
  %28 = getelementptr i64, i64* %27, i32 1
  store i64 %26, i64* %28
  %29 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %24, i64* %29
; # (push 4 NIL ZERO NIL)
  %30 = alloca i64, i64 4, align 16
  store i64 4, i64* %30
  %31 = getelementptr i64, i64* %30, i32 2
  store i64 2, i64* %31
; # (ofs R 2)
  %32 = getelementptr i64, i64* %30, i32 2
; # (link (ofs R 2))
  %33 = ptrtoint i64* %32 to i64
  %34 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %35 = load i64, i64* %34
  %36 = inttoptr i64 %33 to i64*
  %37 = getelementptr i64, i64* %36, i32 1
  store i64 %35, i64* %37
  %38 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %33, i64* %38
; # (while (setq C (symChar P)) (ifn (== C (char "ß")) (charSym (toUp...
  br label %$12
$12:
; # (symChar P)
  %39 = call i32 @symChar(i64* %21)
  %40 = icmp ne i32 %39, 0
  br i1 %40, label %$13, label %$14
$13:
  %41 = phi i32 [%39, %$12] ; # C
; # (ifn (== C (char "ß")) (charSym (toUpperCase C) R) (charSym (char...
; # (== C (char "ß"))
  %42 = icmp eq i32 %41, 223
  br i1 %42, label %$16, label %$15
$15:
  %43 = phi i32 [%41, %$13] ; # C
; # (toUpperCase C)
  %44 = call i32 @toUpperCase(i32 %43)
; # (charSym (toUpperCase C) R)
  call void @charSym(i32 %44, i64* %30)
  br label %$17
$16:
  %45 = phi i32 [%41, %$13] ; # C
; # (charSym (char "S") R)
  call void @charSym(i32 83, i64* %30)
; # (charSym (char "S") R)
  call void @charSym(i32 83, i64* %30)
  br label %$17
$17:
  %46 = phi i32 [%43, %$15], [%45, %$16] ; # C
  br label %$12
$14:
  %47 = phi i32 [%39, %$12] ; # C
; # (val 3 R)
  %48 = getelementptr i64, i64* %30, i32 2
  %49 = load i64, i64* %48
; # (consStr (val 3 R))
  %50 = call i64 @consStr(i64 %49)
; # (drop *Safe)
  %51 = inttoptr i64 %24 to i64*
  %52 = getelementptr i64, i64* %51, i32 1
  %53 = load i64, i64* %52
  %54 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %53, i64* %54
  br label %$11
$11:
  %55 = phi i64 [%13, %$9], [%50, %$14] ; # ->
  ret i64 %55
}

define i64 @_Fold(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (eval (++ X))) (if (or (not (symb? Y)) (nil? ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (if (or (not (symb? Y)) (nil? Y)) Y (let (N (if (atom X) 0 (evCnt...
; # (or (not (symb? Y)) (nil? Y))
; # (symb? Y)
  %16 = xor i64 %15, 8
  %17 = and i64 %16, 14
  %18 = icmp eq i64 %17, 0
; # (not (symb? Y))
  %19 = icmp eq i1 %18, 0
  br i1 %19, label %$7, label %$8
$8:
; # (nil? Y)
  %20 = icmp eq i64 %15, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$7
$7:
  %21 = phi i1 [1, %$2], [%20, %$8] ; # ->
  br i1 %21, label %$9, label %$10
$9:
  br label %$11
$10:
; # (let (N (if (atom X) 0 (evCnt Exe X)) P (push 0 (xName Y) NIL) Q ...
; # (if (atom X) 0 (evCnt Exe X))
; # (atom X)
  %22 = and i64 %7, 15
  %23 = icmp ne i64 %22, 0
  br i1 %23, label %$12, label %$13
$12:
  br label %$14
$13:
; # (evCnt Exe X)
  %24 = call i64 @evCnt(i64 %0, i64 %7)
  br label %$14
$14:
  %25 = phi i64 [0, %$12], [%24, %$13] ; # ->
; # (xName Y)
  %26 = call i64 @xName(i64 %15)
; # (push 0 (xName Y) NIL)
  %27 = alloca i64, i64 3, align 16
  store i64 0, i64* %27
  %28 = getelementptr i64, i64* %27, i32 1
  store i64 %26, i64* %28
; # (ofs P 1)
  %29 = getelementptr i64, i64* %27, i32 1
; # (link (ofs P 1) T)
  %30 = ptrtoint i64* %29 to i64
  %31 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %32 = load i64, i64* %31
  %33 = inttoptr i64 %30 to i64*
  %34 = getelementptr i64, i64* %33, i32 1
  store i64 %32, i64* %34
  %35 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %30, i64* %35
; # (push 4 NIL ZERO NIL)
  %36 = alloca i64, i64 4, align 16
  store i64 4, i64* %36
  %37 = getelementptr i64, i64* %36, i32 2
  store i64 2, i64* %37
; # (ofs R 2)
  %38 = getelementptr i64, i64* %36, i32 2
; # (link (ofs R 2))
  %39 = ptrtoint i64* %38 to i64
  %40 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %41 = load i64, i64* %40
  %42 = inttoptr i64 %39 to i64*
  %43 = getelementptr i64, i64* %42, i32 1
  store i64 %41, i64* %43
  %44 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %39, i64* %44
; # (while (setq C (symChar P)) (when (isLetterOrDigit C) (charSym (t...
  br label %$15
$15:
  %45 = phi i64 [%25, %$14], [%58, %$19] ; # N
; # (symChar P)
  %46 = call i32 @symChar(i64* %27)
  %47 = icmp ne i32 %46, 0
  br i1 %47, label %$16, label %$17
$16:
  %48 = phi i64 [%45, %$15] ; # N
  %49 = phi i32 [%46, %$15] ; # C
; # (when (isLetterOrDigit C) (charSym (toLowerCase C) R) (? (=0 (dec...
; # (isLetterOrDigit C)
  %50 = call i1 @isLetterOrDigit(i32 %49)
  br i1 %50, label %$18, label %$19
$18:
  %51 = phi i64 [%48, %$16] ; # N
  %52 = phi i32 [%49, %$16] ; # C
; # (toLowerCase C)
  %53 = call i32 @toLowerCase(i32 %52)
; # (charSym (toLowerCase C) R)
  call void @charSym(i32 %53, i64* %36)
; # (? (=0 (dec 'N)))
; # (dec 'N)
  %54 = sub i64 %51, 1
; # (=0 (dec 'N))
  %55 = icmp eq i64 %54, 0
  br i1 %55, label %$17, label %$20
$20:
  %56 = phi i64 [%54, %$18] ; # N
  %57 = phi i32 [%52, %$18] ; # C
  br label %$19
$19:
  %58 = phi i64 [%48, %$16], [%56, %$20] ; # N
  %59 = phi i32 [%49, %$16], [%57, %$20] ; # C
  br label %$15
$17:
  %60 = phi i64 [%45, %$15], [%54, %$18] ; # N
  %61 = phi i32 [%46, %$15], [%52, %$18] ; # C
; # (val 3 R)
  %62 = getelementptr i64, i64* %36, i32 2
  %63 = load i64, i64* %62
; # (consStr (val 3 R))
  %64 = call i64 @consStr(i64 %63)
; # (drop *Safe)
  %65 = inttoptr i64 %30 to i64*
  %66 = getelementptr i64, i64* %65, i32 1
  %67 = load i64, i64* %66
  %68 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %67, i64* %68
  br label %$11
$11:
  %69 = phi i64 [%15, %$9], [%64, %$17] ; # ->
  ret i64 %69
}

define i8* @dirString(i64, i8*) align 8 {
$1:
; # (let S (pathString Nm P) (if (val P) P ($ ".")))
; # (pathString Nm P)
  %2 = call i8* @pathString(i64 %0, i8* %1)
; # (if (val P) P ($ "."))
; # (val P)
  %3 = load i8, i8* %1
  %4 = icmp ne i8 %3, 0
  br i1 %4, label %$2, label %$3
$2:
  br label %$4
$3:
  br label %$4
$4:
  %5 = phi i8* [%1, %$2], [bitcast ([2 x i8]* @$28 to i8*), %$3] ; # ->
  ret i8* %5
}

define i1 @equal(i64, i64) align 8 {
$1:
; # (cond ((== X Y) YES) ((cnt? X) NO) ((big? X) (if (cnt? Y) NO (whe...
; # (== X Y)
  %2 = icmp eq i64 %0, %1
  br i1 %2, label %$4, label %$3
$4:
  %3 = phi i64 [%0, %$1] ; # X
  %4 = phi i64 [%1, %$1] ; # Y
  br label %$2
$3:
  %5 = phi i64 [%0, %$1] ; # X
  %6 = phi i64 [%1, %$1] ; # Y
; # (cnt? X)
  %7 = and i64 %5, 2
  %8 = icmp ne i64 %7, 0
  br i1 %8, label %$6, label %$5
$6:
  %9 = phi i64 [%5, %$3] ; # X
  %10 = phi i64 [%6, %$3] ; # Y
  br label %$2
$5:
  %11 = phi i64 [%5, %$3] ; # X
  %12 = phi i64 [%6, %$3] ; # Y
; # (big? X)
  %13 = and i64 %11, 4
  %14 = icmp ne i64 %13, 0
  br i1 %14, label %$8, label %$7
$8:
  %15 = phi i64 [%11, %$5] ; # X
  %16 = phi i64 [%12, %$5] ; # Y
; # (if (cnt? Y) NO (when (sign? X) (unless (sign? Y) (ret NO)) (setq...
; # (cnt? Y)
  %17 = and i64 %16, 2
  %18 = icmp ne i64 %17, 0
  br i1 %18, label %$9, label %$10
$9:
  %19 = phi i64 [%15, %$8] ; # X
  %20 = phi i64 [%16, %$8] ; # Y
  br label %$11
$10:
  %21 = phi i64 [%15, %$8] ; # X
  %22 = phi i64 [%16, %$8] ; # Y
; # (when (sign? X) (unless (sign? Y) (ret NO)) (setq X (pos X) Y (po...
; # (sign? X)
  %23 = and i64 %21, 8
  %24 = icmp ne i64 %23, 0
  br i1 %24, label %$12, label %$13
$12:
  %25 = phi i64 [%21, %$10] ; # X
  %26 = phi i64 [%22, %$10] ; # Y
; # (unless (sign? Y) (ret NO))
; # (sign? Y)
  %27 = and i64 %26, 8
  %28 = icmp ne i64 %27, 0
  br i1 %28, label %$15, label %$14
$14:
  %29 = phi i64 [%25, %$12] ; # X
  %30 = phi i64 [%26, %$12] ; # Y
; # (ret NO)
  ret i1 0
$15:
  %31 = phi i64 [%25, %$12] ; # X
  %32 = phi i64 [%26, %$12] ; # Y
; # (pos X)
  %33 = and i64 %31, -9
; # (pos Y)
  %34 = and i64 %32, -9
  br label %$13
$13:
  %35 = phi i64 [%21, %$10], [%33, %$15] ; # X
  %36 = phi i64 [%22, %$10], [%34, %$15] ; # Y
; # (equalBig X Y)
  br label %$16
$16:
  %37 = phi i64 [%35, %$13], [%71, %$24] ; # X
  %38 = phi i64 [%36, %$13], [%72, %$24] ; # Y
  %39 = add i64 %37, -4
  %40 = inttoptr i64 %39 to i64*
  %41 = load i64, i64* %40
  %42 = add i64 %38, -4
  %43 = inttoptr i64 %42 to i64*
  %44 = load i64, i64* %43
  %45 = icmp ne i64 %41, %44
  br i1 %45, label %$19, label %$17
$19:
  %46 = phi i64 [%37, %$16] ; # X
  %47 = phi i64 [%38, %$16] ; # Y
  br label %$18
$17:
  %48 = phi i64 [%37, %$16] ; # X
  %49 = phi i64 [%38, %$16] ; # Y
  %50 = add i64 %48, 4
  %51 = inttoptr i64 %50 to i64*
  %52 = load i64, i64* %51
  %53 = add i64 %49, 4
  %54 = inttoptr i64 %53 to i64*
  %55 = load i64, i64* %54
  %56 = icmp eq i64 %52, %55
  br i1 %56, label %$21, label %$20
$21:
  %57 = phi i64 [%52, %$17] ; # X
  %58 = phi i64 [%55, %$17] ; # Y
  br label %$18
$20:
  %59 = phi i64 [%52, %$17] ; # X
  %60 = phi i64 [%55, %$17] ; # Y
  %61 = and i64 %59, 2
  %62 = icmp ne i64 %61, 0
  br i1 %62, label %$23, label %$22
$23:
  %63 = phi i64 [%59, %$20] ; # X
  %64 = phi i64 [%60, %$20] ; # Y
  br label %$18
$22:
  %65 = phi i64 [%59, %$20] ; # X
  %66 = phi i64 [%60, %$20] ; # Y
  %67 = and i64 %66, 2
  %68 = icmp ne i64 %67, 0
  br i1 %68, label %$25, label %$24
$25:
  %69 = phi i64 [%65, %$22] ; # X
  %70 = phi i64 [%66, %$22] ; # Y
  br label %$18
$24:
  %71 = phi i64 [%65, %$22] ; # X
  %72 = phi i64 [%66, %$22] ; # Y
  br label %$16
$18:
  %73 = phi i64 [%46, %$19], [%57, %$21], [%63, %$23], [%69, %$25] ; # X
  %74 = phi i64 [%47, %$19], [%58, %$21], [%64, %$23], [%70, %$25] ; # Y
  %75 = phi i1 [0, %$19], [1, %$21], [0, %$23], [0, %$25] ; # ->
  br label %$11
$11:
  %76 = phi i64 [%19, %$9], [%35, %$18] ; # X
  %77 = phi i64 [%20, %$9], [%36, %$18] ; # Y
  %78 = phi i1 [0, %$9], [%75, %$18] ; # ->
  br label %$2
$7:
  %79 = phi i64 [%11, %$5] ; # X
  %80 = phi i64 [%12, %$5] ; # Y
; # (sym? X)
  %81 = and i64 %79, 8
  %82 = icmp ne i64 %81, 0
  br i1 %82, label %$27, label %$26
$27:
  %83 = phi i64 [%79, %$7] ; # X
  %84 = phi i64 [%80, %$7] ; # Y
; # (cond ((num? Y) NO) ((pair Y) NO) ((sym? (val (tail X))) NO) ((==...
; # (num? Y)
  %85 = and i64 %84, 6
  %86 = icmp ne i64 %85, 0
  br i1 %86, label %$30, label %$29
$30:
  %87 = phi i64 [%83, %$27] ; # X
  %88 = phi i64 [%84, %$27] ; # Y
  br label %$28
$29:
  %89 = phi i64 [%83, %$27] ; # X
  %90 = phi i64 [%84, %$27] ; # Y
; # (pair Y)
  %91 = and i64 %90, 15
  %92 = icmp eq i64 %91, 0
  br i1 %92, label %$32, label %$31
$32:
  %93 = phi i64 [%89, %$29] ; # X
  %94 = phi i64 [%90, %$29] ; # Y
  br label %$28
$31:
  %95 = phi i64 [%89, %$29] ; # X
  %96 = phi i64 [%90, %$29] ; # Y
; # (tail X)
  %97 = add i64 %95, -8
; # (val (tail X))
  %98 = inttoptr i64 %97 to i64*
  %99 = load i64, i64* %98
; # (sym? (val (tail X)))
  %100 = and i64 %99, 8
  %101 = icmp ne i64 %100, 0
  br i1 %101, label %$34, label %$33
$34:
  %102 = phi i64 [%95, %$31] ; # X
  %103 = phi i64 [%96, %$31] ; # Y
  br label %$28
$33:
  %104 = phi i64 [%95, %$31] ; # X
  %105 = phi i64 [%96, %$31] ; # Y
; # (name @)
  br label %$35
$35:
  %106 = phi i64 [%99, %$33], [%112, %$36] ; # Tail
  %107 = and i64 %106, 6
  %108 = icmp ne i64 %107, 0
  br i1 %108, label %$37, label %$36
$36:
  %109 = phi i64 [%106, %$35] ; # Tail
  %110 = inttoptr i64 %109 to i64*
  %111 = getelementptr i64, i64* %110, i32 1
  %112 = load i64, i64* %111
  br label %$35
$37:
  %113 = phi i64 [%106, %$35] ; # Tail
; # (== ZERO (setq X (name @)))
  %114 = icmp eq i64 2, %113
  br i1 %114, label %$39, label %$38
$39:
  %115 = phi i64 [%113, %$37] ; # X
  %116 = phi i64 [%105, %$37] ; # Y
  br label %$28
$38:
  %117 = phi i64 [%113, %$37] ; # X
  %118 = phi i64 [%105, %$37] ; # Y
; # (tail Y)
  %119 = add i64 %118, -8
; # (val (tail Y))
  %120 = inttoptr i64 %119 to i64*
  %121 = load i64, i64* %120
; # (sym? (val (tail Y)))
  %122 = and i64 %121, 8
  %123 = icmp ne i64 %122, 0
  br i1 %123, label %$41, label %$40
$41:
  %124 = phi i64 [%117, %$38] ; # X
  %125 = phi i64 [%118, %$38] ; # Y
  br label %$28
$40:
  %126 = phi i64 [%117, %$38] ; # X
  %127 = phi i64 [%118, %$38] ; # Y
; # (name @)
  br label %$42
$42:
  %128 = phi i64 [%121, %$40], [%134, %$43] ; # Tail
  %129 = and i64 %128, 6
  %130 = icmp ne i64 %129, 0
  br i1 %130, label %$44, label %$43
$43:
  %131 = phi i64 [%128, %$42] ; # Tail
  %132 = inttoptr i64 %131 to i64*
  %133 = getelementptr i64, i64* %132, i32 1
  %134 = load i64, i64* %133
  br label %$42
$44:
  %135 = phi i64 [%128, %$42] ; # Tail
; # (== ZERO (setq Y (name @)))
  %136 = icmp eq i64 2, %135
  br i1 %136, label %$46, label %$45
$46:
  %137 = phi i64 [%126, %$44] ; # X
  %138 = phi i64 [%135, %$44] ; # Y
  br label %$28
$45:
  %139 = phi i64 [%126, %$44] ; # X
  %140 = phi i64 [%135, %$44] ; # Y
; # (== X Y)
  %141 = icmp eq i64 %139, %140
  br i1 %141, label %$48, label %$47
$48:
  %142 = phi i64 [%139, %$45] ; # X
  %143 = phi i64 [%140, %$45] ; # Y
  br label %$28
$47:
  %144 = phi i64 [%139, %$45] ; # X
  %145 = phi i64 [%140, %$45] ; # Y
; # (cnt? X)
  %146 = and i64 %144, 2
  %147 = icmp ne i64 %146, 0
  br i1 %147, label %$50, label %$49
$50:
  %148 = phi i64 [%144, %$47] ; # X
  %149 = phi i64 [%145, %$47] ; # Y
  br label %$28
$49:
  %150 = phi i64 [%144, %$47] ; # X
  %151 = phi i64 [%145, %$47] ; # Y
; # (cnt? Y)
  %152 = and i64 %151, 2
  %153 = icmp ne i64 %152, 0
  br i1 %153, label %$52, label %$51
$52:
  %154 = phi i64 [%150, %$49] ; # X
  %155 = phi i64 [%151, %$49] ; # Y
  br label %$28
$51:
  %156 = phi i64 [%150, %$49] ; # X
  %157 = phi i64 [%151, %$49] ; # Y
; # (equalBig X Y)
  br label %$53
$53:
  %158 = phi i64 [%156, %$51], [%192, %$61] ; # X
  %159 = phi i64 [%157, %$51], [%193, %$61] ; # Y
  %160 = add i64 %158, -4
  %161 = inttoptr i64 %160 to i64*
  %162 = load i64, i64* %161
  %163 = add i64 %159, -4
  %164 = inttoptr i64 %163 to i64*
  %165 = load i64, i64* %164
  %166 = icmp ne i64 %162, %165
  br i1 %166, label %$56, label %$54
$56:
  %167 = phi i64 [%158, %$53] ; # X
  %168 = phi i64 [%159, %$53] ; # Y
  br label %$55
$54:
  %169 = phi i64 [%158, %$53] ; # X
  %170 = phi i64 [%159, %$53] ; # Y
  %171 = add i64 %169, 4
  %172 = inttoptr i64 %171 to i64*
  %173 = load i64, i64* %172
  %174 = add i64 %170, 4
  %175 = inttoptr i64 %174 to i64*
  %176 = load i64, i64* %175
  %177 = icmp eq i64 %173, %176
  br i1 %177, label %$58, label %$57
$58:
  %178 = phi i64 [%173, %$54] ; # X
  %179 = phi i64 [%176, %$54] ; # Y
  br label %$55
$57:
  %180 = phi i64 [%173, %$54] ; # X
  %181 = phi i64 [%176, %$54] ; # Y
  %182 = and i64 %180, 2
  %183 = icmp ne i64 %182, 0
  br i1 %183, label %$60, label %$59
$60:
  %184 = phi i64 [%180, %$57] ; # X
  %185 = phi i64 [%181, %$57] ; # Y
  br label %$55
$59:
  %186 = phi i64 [%180, %$57] ; # X
  %187 = phi i64 [%181, %$57] ; # Y
  %188 = and i64 %187, 2
  %189 = icmp ne i64 %188, 0
  br i1 %189, label %$62, label %$61
$62:
  %190 = phi i64 [%186, %$59] ; # X
  %191 = phi i64 [%187, %$59] ; # Y
  br label %$55
$61:
  %192 = phi i64 [%186, %$59] ; # X
  %193 = phi i64 [%187, %$59] ; # Y
  br label %$53
$55:
  %194 = phi i64 [%167, %$56], [%178, %$58], [%184, %$60], [%190, %$62] ; # X
  %195 = phi i64 [%168, %$56], [%179, %$58], [%185, %$60], [%191, %$62] ; # Y
  %196 = phi i1 [0, %$56], [1, %$58], [0, %$60], [0, %$62] ; # ->
  br label %$28
$28:
  %197 = phi i64 [%87, %$30], [%93, %$32], [%102, %$34], [%115, %$39], [%124, %$41], [%137, %$46], [%142, %$48], [%148, %$50], [%154, %$52], [%156, %$55] ; # X
  %198 = phi i64 [%88, %$30], [%94, %$32], [%103, %$34], [%116, %$39], [%125, %$41], [%138, %$46], [%143, %$48], [%149, %$50], [%155, %$52], [%157, %$55] ; # Y
  %199 = phi i1 [0, %$30], [0, %$32], [0, %$34], [0, %$39], [0, %$41], [0, %$46], [1, %$48], [0, %$50], [0, %$52], [%196, %$55] ; # ->
  br label %$2
$26:
  %200 = phi i64 [%79, %$7] ; # X
  %201 = phi i64 [%80, %$7] ; # Y
; # (atom Y)
  %202 = and i64 %201, 15
  %203 = icmp ne i64 %202, 0
  br i1 %203, label %$64, label %$63
$64:
  %204 = phi i64 [%200, %$26] ; # X
  %205 = phi i64 [%201, %$26] ; # Y
  br label %$2
$63:
  %206 = phi i64 [%200, %$26] ; # X
  %207 = phi i64 [%201, %$26] ; # Y
; # (stkChk 0)
  %208 = load i8*, i8** @$StkLimit
  %209 = call i8* @llvm.stacksave()
  %210 = icmp ugt i8* %208, %209
  br i1 %210, label %$65, label %$66
$65:
  call void @stkErr(i64 0)
  unreachable
$66:
; # (let (A X B Y) (prog1 (loop (? (not (equal (car X) (& (car Y) -2)...
; # (prog1 (loop (? (not (equal (car X) (& (car Y) -2))) NO) (? (atom...
; # (loop (? (not (equal (car X) (& (car Y) -2))) NO) (? (atom (cdr X...
  br label %$67
$67:
  %211 = phi i64 [%206, %$66], [%373, %$75] ; # X
  %212 = phi i64 [%207, %$66], [%374, %$75] ; # Y
  %213 = phi i64 [%206, %$66], [%375, %$75] ; # A
  %214 = phi i64 [%207, %$66], [%376, %$75] ; # B
; # (? (not (equal (car X) (& (car Y) -2))) NO)
; # (car X)
  %215 = inttoptr i64 %211 to i64*
  %216 = load i64, i64* %215
; # (car Y)
  %217 = inttoptr i64 %212 to i64*
  %218 = load i64, i64* %217
; # (& (car Y) -2)
  %219 = and i64 %218, -2
; # (equal (car X) (& (car Y) -2))
  %220 = call i1 @equal(i64 %216, i64 %219)
; # (not (equal (car X) (& (car Y) -2)))
  %221 = icmp eq i1 %220, 0
  br i1 %221, label %$70, label %$68
$70:
  %222 = phi i64 [%211, %$67] ; # X
  %223 = phi i64 [%212, %$67] ; # Y
  %224 = phi i64 [%213, %$67] ; # A
  %225 = phi i64 [%214, %$67] ; # B
  br label %$69
$68:
  %226 = phi i64 [%211, %$67] ; # X
  %227 = phi i64 [%212, %$67] ; # Y
  %228 = phi i64 [%213, %$67] ; # A
  %229 = phi i64 [%214, %$67] ; # B
; # (? (atom (cdr X)) (equal (cdr X) (cdr Y)))
; # (cdr X)
  %230 = inttoptr i64 %226 to i64*
  %231 = getelementptr i64, i64* %230, i32 1
  %232 = load i64, i64* %231
; # (atom (cdr X))
  %233 = and i64 %232, 15
  %234 = icmp ne i64 %233, 0
  br i1 %234, label %$72, label %$71
$72:
  %235 = phi i64 [%226, %$68] ; # X
  %236 = phi i64 [%227, %$68] ; # Y
  %237 = phi i64 [%228, %$68] ; # A
  %238 = phi i64 [%229, %$68] ; # B
; # (cdr X)
  %239 = inttoptr i64 %235 to i64*
  %240 = getelementptr i64, i64* %239, i32 1
  %241 = load i64, i64* %240
; # (cdr Y)
  %242 = inttoptr i64 %236 to i64*
  %243 = getelementptr i64, i64* %242, i32 1
  %244 = load i64, i64* %243
; # (equal (cdr X) (cdr Y))
  %245 = call i1 @equal(i64 %241, i64 %244)
  br label %$69
$71:
  %246 = phi i64 [%226, %$68] ; # X
  %247 = phi i64 [%227, %$68] ; # Y
  %248 = phi i64 [%228, %$68] ; # A
  %249 = phi i64 [%229, %$68] ; # B
; # (? (atom (cdr Y)) NO)
; # (cdr Y)
  %250 = inttoptr i64 %247 to i64*
  %251 = getelementptr i64, i64* %250, i32 1
  %252 = load i64, i64* %251
; # (atom (cdr Y))
  %253 = and i64 %252, 15
  %254 = icmp ne i64 %253, 0
  br i1 %254, label %$74, label %$73
$74:
  %255 = phi i64 [%246, %$71] ; # X
  %256 = phi i64 [%247, %$71] ; # Y
  %257 = phi i64 [%248, %$71] ; # A
  %258 = phi i64 [%249, %$71] ; # B
  br label %$69
$73:
  %259 = phi i64 [%246, %$71] ; # X
  %260 = phi i64 [%247, %$71] ; # Y
  %261 = phi i64 [%248, %$71] ; # A
  %262 = phi i64 [%249, %$71] ; # B
; # (set X (| (val X) 1))
; # (val X)
  %263 = inttoptr i64 %259 to i64*
  %264 = load i64, i64* %263
; # (| (val X) 1)
  %265 = or i64 %264, 1
  %266 = inttoptr i64 %259 to i64*
  store i64 %265, i64* %266
; # (shift X)
  %267 = inttoptr i64 %259 to i64*
  %268 = getelementptr i64, i64* %267, i32 1
  %269 = load i64, i64* %268
; # (shift Y)
  %270 = inttoptr i64 %260 to i64*
  %271 = getelementptr i64, i64* %270, i32 1
  %272 = load i64, i64* %271
; # (? (& (val X) 1) (prog1 (loop (? (== A X) (if (== B Y) (loop (shi...
; # (val X)
  %273 = inttoptr i64 %269 to i64*
  %274 = load i64, i64* %273
; # (& (val X) 1)
  %275 = and i64 %274, 1
  %276 = icmp ne i64 %275, 0
  br i1 %276, label %$76, label %$75
$76:
  %277 = phi i64 [%269, %$73] ; # X
  %278 = phi i64 [%272, %$73] ; # Y
  %279 = phi i64 [%261, %$73] ; # A
  %280 = phi i64 [%262, %$73] ; # B
; # (prog1 (loop (? (== A X) (if (== B Y) (loop (shift A) (? (== (shi...
; # (loop (? (== A X) (if (== B Y) (loop (shift A) (? (== (shift B) Y...
  br label %$77
$77:
  %281 = phi i64 [%277, %$76], [%347, %$90] ; # X
  %282 = phi i64 [%278, %$76], [%348, %$90] ; # Y
  %283 = phi i64 [%279, %$76], [%357, %$90] ; # A
  %284 = phi i64 [%280, %$76], [%360, %$90] ; # B
; # (? (== A X) (if (== B Y) (loop (shift A) (? (== (shift B) Y) (== ...
; # (== A X)
  %285 = icmp eq i64 %283, %281
  br i1 %285, label %$80, label %$78
$80:
  %286 = phi i64 [%281, %$77] ; # X
  %287 = phi i64 [%282, %$77] ; # Y
  %288 = phi i64 [%283, %$77] ; # A
  %289 = phi i64 [%284, %$77] ; # B
; # (if (== B Y) (loop (shift A) (? (== (shift B) Y) (== A X)) (? (==...
; # (== B Y)
  %290 = icmp eq i64 %289, %287
  br i1 %290, label %$81, label %$82
$81:
  %291 = phi i64 [%286, %$80] ; # X
  %292 = phi i64 [%287, %$80] ; # Y
  %293 = phi i64 [%288, %$80] ; # A
  %294 = phi i64 [%289, %$80] ; # B
; # (loop (shift A) (? (== (shift B) Y) (== A X)) (? (== A X) YES))
  br label %$84
$84:
  %295 = phi i64 [%291, %$81], [%320, %$88] ; # X
  %296 = phi i64 [%292, %$81], [%321, %$88] ; # Y
  %297 = phi i64 [%293, %$81], [%322, %$88] ; # A
  %298 = phi i64 [%294, %$81], [%323, %$88] ; # B
; # (shift A)
  %299 = inttoptr i64 %297 to i64*
  %300 = getelementptr i64, i64* %299, i32 1
  %301 = load i64, i64* %300
; # (? (== (shift B) Y) (== A X))
; # (shift B)
  %302 = inttoptr i64 %298 to i64*
  %303 = getelementptr i64, i64* %302, i32 1
  %304 = load i64, i64* %303
; # (== (shift B) Y)
  %305 = icmp eq i64 %304, %296
  br i1 %305, label %$87, label %$85
$87:
  %306 = phi i64 [%295, %$84] ; # X
  %307 = phi i64 [%296, %$84] ; # Y
  %308 = phi i64 [%301, %$84] ; # A
  %309 = phi i64 [%304, %$84] ; # B
; # (== A X)
  %310 = icmp eq i64 %308, %306
  br label %$86
$85:
  %311 = phi i64 [%295, %$84] ; # X
  %312 = phi i64 [%296, %$84] ; # Y
  %313 = phi i64 [%301, %$84] ; # A
  %314 = phi i64 [%304, %$84] ; # B
; # (? (== A X) YES)
; # (== A X)
  %315 = icmp eq i64 %313, %311
  br i1 %315, label %$89, label %$88
$89:
  %316 = phi i64 [%311, %$85] ; # X
  %317 = phi i64 [%312, %$85] ; # Y
  %318 = phi i64 [%313, %$85] ; # A
  %319 = phi i64 [%314, %$85] ; # B
  br label %$86
$88:
  %320 = phi i64 [%311, %$85] ; # X
  %321 = phi i64 [%312, %$85] ; # Y
  %322 = phi i64 [%313, %$85] ; # A
  %323 = phi i64 [%314, %$85] ; # B
  br label %$84
$86:
  %324 = phi i64 [%306, %$87], [%316, %$89] ; # X
  %325 = phi i64 [%307, %$87], [%317, %$89] ; # Y
  %326 = phi i64 [%308, %$87], [%318, %$89] ; # A
  %327 = phi i64 [%309, %$87], [%319, %$89] ; # B
  %328 = phi i1 [%310, %$87], [1, %$89] ; # ->
  br label %$83
$82:
  %329 = phi i64 [%286, %$80] ; # X
  %330 = phi i64 [%287, %$80] ; # Y
  %331 = phi i64 [%288, %$80] ; # A
  %332 = phi i64 [%289, %$80] ; # B
  br label %$83
$83:
  %333 = phi i64 [%324, %$86], [%329, %$82] ; # X
  %334 = phi i64 [%325, %$86], [%330, %$82] ; # Y
  %335 = phi i64 [%326, %$86], [%331, %$82] ; # A
  %336 = phi i64 [%327, %$86], [%332, %$82] ; # B
  %337 = phi i1 [%328, %$86], [0, %$82] ; # ->
  br label %$79
$78:
  %338 = phi i64 [%281, %$77] ; # X
  %339 = phi i64 [%282, %$77] ; # Y
  %340 = phi i64 [%283, %$77] ; # A
  %341 = phi i64 [%284, %$77] ; # B
; # (? (== B Y) NO)
; # (== B Y)
  %342 = icmp eq i64 %341, %339
  br i1 %342, label %$91, label %$90
$91:
  %343 = phi i64 [%338, %$78] ; # X
  %344 = phi i64 [%339, %$78] ; # Y
  %345 = phi i64 [%340, %$78] ; # A
  %346 = phi i64 [%341, %$78] ; # B
  br label %$79
$90:
  %347 = phi i64 [%338, %$78] ; # X
  %348 = phi i64 [%339, %$78] ; # Y
  %349 = phi i64 [%340, %$78] ; # A
  %350 = phi i64 [%341, %$78] ; # B
; # (set A (& (val A) -2))
; # (val A)
  %351 = inttoptr i64 %349 to i64*
  %352 = load i64, i64* %351
; # (& (val A) -2)
  %353 = and i64 %352, -2
  %354 = inttoptr i64 %349 to i64*
  store i64 %353, i64* %354
; # (shift A)
  %355 = inttoptr i64 %349 to i64*
  %356 = getelementptr i64, i64* %355, i32 1
  %357 = load i64, i64* %356
; # (shift B)
  %358 = inttoptr i64 %350 to i64*
  %359 = getelementptr i64, i64* %358, i32 1
  %360 = load i64, i64* %359
  br label %$77
$79:
  %361 = phi i64 [%333, %$83], [%343, %$91] ; # X
  %362 = phi i64 [%334, %$83], [%344, %$91] ; # Y
  %363 = phi i64 [%335, %$83], [%345, %$91] ; # A
  %364 = phi i64 [%336, %$83], [%346, %$91] ; # B
  %365 = phi i1 [%337, %$83], [0, %$91] ; # ->
; # (set A (& (val A) -2))
; # (val A)
  %366 = inttoptr i64 %363 to i64*
  %367 = load i64, i64* %366
; # (& (val A) -2)
  %368 = and i64 %367, -2
  %369 = inttoptr i64 %363 to i64*
  store i64 %368, i64* %369
; # (shift A)
  %370 = inttoptr i64 %363 to i64*
  %371 = getelementptr i64, i64* %370, i32 1
  %372 = load i64, i64* %371
  br label %$69
$75:
  %373 = phi i64 [%269, %$73] ; # X
  %374 = phi i64 [%272, %$73] ; # Y
  %375 = phi i64 [%261, %$73] ; # A
  %376 = phi i64 [%262, %$73] ; # B
  br label %$67
$69:
  %377 = phi i64 [%222, %$70], [%235, %$72], [%255, %$74], [%361, %$79] ; # X
  %378 = phi i64 [%223, %$70], [%236, %$72], [%256, %$74], [%362, %$79] ; # Y
  %379 = phi i64 [%224, %$70], [%237, %$72], [%257, %$74], [%372, %$79] ; # A
  %380 = phi i64 [%225, %$70], [%238, %$72], [%258, %$74], [%364, %$79] ; # B
  %381 = phi i1 [0, %$70], [%245, %$72], [0, %$74], [%365, %$79] ; # ->
; # (until (== A X) (set A (& (val A) -2)) (shift A))
  br label %$92
$92:
  %382 = phi i64 [%377, %$69], [%387, %$93] ; # X
  %383 = phi i64 [%378, %$69], [%388, %$93] ; # Y
  %384 = phi i64 [%379, %$69], [%397, %$93] ; # A
  %385 = phi i64 [%380, %$69], [%390, %$93] ; # B
; # (== A X)
  %386 = icmp eq i64 %384, %382
  br i1 %386, label %$94, label %$93
$93:
  %387 = phi i64 [%382, %$92] ; # X
  %388 = phi i64 [%383, %$92] ; # Y
  %389 = phi i64 [%384, %$92] ; # A
  %390 = phi i64 [%385, %$92] ; # B
; # (set A (& (val A) -2))
; # (val A)
  %391 = inttoptr i64 %389 to i64*
  %392 = load i64, i64* %391
; # (& (val A) -2)
  %393 = and i64 %392, -2
  %394 = inttoptr i64 %389 to i64*
  store i64 %393, i64* %394
; # (shift A)
  %395 = inttoptr i64 %389 to i64*
  %396 = getelementptr i64, i64* %395, i32 1
  %397 = load i64, i64* %396
  br label %$92
$94:
  %398 = phi i64 [%382, %$92] ; # X
  %399 = phi i64 [%383, %$92] ; # Y
  %400 = phi i64 [%384, %$92] ; # A
  %401 = phi i64 [%385, %$92] ; # B
  br label %$2
$2:
  %402 = phi i64 [%3, %$4], [%9, %$6], [%76, %$11], [%197, %$28], [%204, %$64], [%398, %$94] ; # X
  %403 = phi i64 [%4, %$4], [%10, %$6], [%77, %$11], [%198, %$28], [%205, %$64], [%399, %$94] ; # Y
  %404 = phi i1 [1, %$4], [0, %$6], [%78, %$11], [%199, %$28], [0, %$64], [%381, %$94] ; # ->
  ret i1 %404
}

define i64 @compare(i64, i64) align 8 {
$1:
; # (cond ((== X Y) 0) ((nil? X) -1) ((t? X) 1) ((num? X) (cond ((num...
; # (== X Y)
  %2 = icmp eq i64 %0, %1
  br i1 %2, label %$4, label %$3
$4:
  %3 = phi i64 [%0, %$1] ; # X
  %4 = phi i64 [%1, %$1] ; # Y
  br label %$2
$3:
  %5 = phi i64 [%0, %$1] ; # X
  %6 = phi i64 [%1, %$1] ; # Y
; # (nil? X)
  %7 = icmp eq i64 %5, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %7, label %$6, label %$5
$6:
  %8 = phi i64 [%5, %$3] ; # X
  %9 = phi i64 [%6, %$3] ; # Y
  br label %$2
$5:
  %10 = phi i64 [%5, %$3] ; # X
  %11 = phi i64 [%6, %$3] ; # Y
; # (t? X)
  %12 = icmp eq i64 %10, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %12, label %$8, label %$7
$8:
  %13 = phi i64 [%10, %$5] ; # X
  %14 = phi i64 [%11, %$5] ; # Y
  br label %$2
$7:
  %15 = phi i64 [%10, %$5] ; # X
  %16 = phi i64 [%11, %$5] ; # Y
; # (num? X)
  %17 = and i64 %15, 6
  %18 = icmp ne i64 %17, 0
  br i1 %18, label %$10, label %$9
$10:
  %19 = phi i64 [%15, %$7] ; # X
  %20 = phi i64 [%16, %$7] ; # Y
; # (cond ((num? Y) (cmpNum X Y)) ((nil? Y) 1) (T -1))
; # (num? Y)
  %21 = and i64 %20, 6
  %22 = icmp ne i64 %21, 0
  br i1 %22, label %$13, label %$12
$13:
  %23 = phi i64 [%19, %$10] ; # X
  %24 = phi i64 [%20, %$10] ; # Y
; # (cmpNum X Y)
  %25 = call i64 @cmpNum(i64 %23, i64 %24)
  br label %$11
$12:
  %26 = phi i64 [%19, %$10] ; # X
  %27 = phi i64 [%20, %$10] ; # Y
; # (nil? Y)
  %28 = icmp eq i64 %27, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %28, label %$15, label %$14
$15:
  %29 = phi i64 [%26, %$12] ; # X
  %30 = phi i64 [%27, %$12] ; # Y
  br label %$11
$14:
  %31 = phi i64 [%26, %$12] ; # X
  %32 = phi i64 [%27, %$12] ; # Y
  br label %$11
$11:
  %33 = phi i64 [%23, %$13], [%29, %$15], [%31, %$14] ; # X
  %34 = phi i64 [%24, %$13], [%30, %$15], [%32, %$14] ; # Y
  %35 = phi i64 [%25, %$13], [1, %$15], [-1, %$14] ; # ->
  br label %$2
$9:
  %36 = phi i64 [%15, %$7] ; # X
  %37 = phi i64 [%16, %$7] ; # Y
; # (sym? X)
  %38 = and i64 %36, 8
  %39 = icmp ne i64 %38, 0
  br i1 %39, label %$17, label %$16
$17:
  %40 = phi i64 [%36, %$9] ; # X
  %41 = phi i64 [%37, %$9] ; # Y
; # (cond ((or (num? Y) (nil? Y)) 1) ((or (pair Y) (t? Y)) -1) (T (le...
; # (or (num? Y) (nil? Y))
; # (num? Y)
  %42 = and i64 %41, 6
  %43 = icmp ne i64 %42, 0
  br i1 %43, label %$19, label %$20
$20:
  %44 = phi i64 [%40, %$17] ; # X
  %45 = phi i64 [%41, %$17] ; # Y
; # (nil? Y)
  %46 = icmp eq i64 %45, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$19
$19:
  %47 = phi i64 [%40, %$17], [%44, %$20] ; # X
  %48 = phi i64 [%41, %$17], [%45, %$20] ; # Y
  %49 = phi i1 [1, %$17], [%46, %$20] ; # ->
  br i1 %49, label %$22, label %$21
$22:
  %50 = phi i64 [%47, %$19] ; # X
  %51 = phi i64 [%48, %$19] ; # Y
  br label %$18
$21:
  %52 = phi i64 [%47, %$19] ; # X
  %53 = phi i64 [%48, %$19] ; # Y
; # (or (pair Y) (t? Y))
; # (pair Y)
  %54 = and i64 %53, 15
  %55 = icmp eq i64 %54, 0
  br i1 %55, label %$23, label %$24
$24:
  %56 = phi i64 [%52, %$21] ; # X
  %57 = phi i64 [%53, %$21] ; # Y
; # (t? Y)
  %58 = icmp eq i64 %57, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br label %$23
$23:
  %59 = phi i64 [%52, %$21], [%56, %$24] ; # X
  %60 = phi i64 [%53, %$21], [%57, %$24] ; # Y
  %61 = phi i1 [1, %$21], [%58, %$24] ; # ->
  br i1 %61, label %$26, label %$25
$26:
  %62 = phi i64 [%59, %$23] ; # X
  %63 = phi i64 [%60, %$23] ; # Y
  br label %$18
$25:
  %64 = phi i64 [%59, %$23] ; # X
  %65 = phi i64 [%60, %$23] ; # Y
; # (let (NmX (name (& (val (tail X)) -9)) NmY (name (& (val (tail Y)...
; # (tail X)
  %66 = add i64 %64, -8
; # (val (tail X))
  %67 = inttoptr i64 %66 to i64*
  %68 = load i64, i64* %67
; # (& (val (tail X)) -9)
  %69 = and i64 %68, -9
; # (name (& (val (tail X)) -9))
  br label %$27
$27:
  %70 = phi i64 [%69, %$25], [%76, %$28] ; # Tail
  %71 = and i64 %70, 6
  %72 = icmp ne i64 %71, 0
  br i1 %72, label %$29, label %$28
$28:
  %73 = phi i64 [%70, %$27] ; # Tail
  %74 = inttoptr i64 %73 to i64*
  %75 = getelementptr i64, i64* %74, i32 1
  %76 = load i64, i64* %75
  br label %$27
$29:
  %77 = phi i64 [%70, %$27] ; # Tail
; # (tail Y)
  %78 = add i64 %65, -8
; # (val (tail Y))
  %79 = inttoptr i64 %78 to i64*
  %80 = load i64, i64* %79
; # (& (val (tail Y)) -9)
  %81 = and i64 %80, -9
; # (name (& (val (tail Y)) -9))
  br label %$30
$30:
  %82 = phi i64 [%81, %$29], [%88, %$31] ; # Tail
  %83 = and i64 %82, 6
  %84 = icmp ne i64 %83, 0
  br i1 %84, label %$32, label %$31
$31:
  %85 = phi i64 [%82, %$30] ; # Tail
  %86 = inttoptr i64 %85 to i64*
  %87 = getelementptr i64, i64* %86, i32 1
  %88 = load i64, i64* %87
  br label %$30
$32:
  %89 = phi i64 [%82, %$30] ; # Tail
; # (cond ((== ZERO NmX) (nond ((== ZERO NmY) -1) ((> X Y) -1) (NIL 1...
; # (== ZERO NmX)
  %90 = icmp eq i64 2, %77
  br i1 %90, label %$35, label %$34
$35:
  %91 = phi i64 [%64, %$32] ; # X
  %92 = phi i64 [%65, %$32] ; # Y
  %93 = phi i64 [%77, %$32] ; # NmX
  %94 = phi i64 [%89, %$32] ; # NmY
; # (nond ((== ZERO NmY) -1) ((> X Y) -1) (NIL 1))
; # (== ZERO NmY)
  %95 = icmp eq i64 2, %94
  br i1 %95, label %$37, label %$38
$38:
  %96 = phi i64 [%91, %$35] ; # X
  %97 = phi i64 [%92, %$35] ; # Y
  %98 = phi i64 [%93, %$35] ; # NmX
  %99 = phi i64 [%94, %$35] ; # NmY
  br label %$36
$37:
  %100 = phi i64 [%91, %$35] ; # X
  %101 = phi i64 [%92, %$35] ; # Y
  %102 = phi i64 [%93, %$35] ; # NmX
  %103 = phi i64 [%94, %$35] ; # NmY
; # (> X Y)
  %104 = icmp ugt i64 %100, %101
  br i1 %104, label %$39, label %$40
$40:
  %105 = phi i64 [%100, %$37] ; # X
  %106 = phi i64 [%101, %$37] ; # Y
  %107 = phi i64 [%102, %$37] ; # NmX
  %108 = phi i64 [%103, %$37] ; # NmY
  br label %$36
$39:
  %109 = phi i64 [%100, %$37] ; # X
  %110 = phi i64 [%101, %$37] ; # Y
  %111 = phi i64 [%102, %$37] ; # NmX
  %112 = phi i64 [%103, %$37] ; # NmY
  br label %$36
$36:
  %113 = phi i64 [%96, %$38], [%105, %$40], [%109, %$39] ; # X
  %114 = phi i64 [%97, %$38], [%106, %$40], [%110, %$39] ; # Y
  %115 = phi i64 [%98, %$38], [%107, %$40], [%111, %$39] ; # NmX
  %116 = phi i64 [%99, %$38], [%108, %$40], [%112, %$39] ; # NmY
  %117 = phi i64 [-1, %$38], [-1, %$40], [1, %$39] ; # ->
  br label %$33
$34:
  %118 = phi i64 [%64, %$32] ; # X
  %119 = phi i64 [%65, %$32] ; # Y
  %120 = phi i64 [%77, %$32] ; # NmX
  %121 = phi i64 [%89, %$32] ; # NmY
; # (== ZERO NmY)
  %122 = icmp eq i64 2, %121
  br i1 %122, label %$42, label %$41
$42:
  %123 = phi i64 [%118, %$34] ; # X
  %124 = phi i64 [%119, %$34] ; # Y
  %125 = phi i64 [%120, %$34] ; # NmX
  %126 = phi i64 [%121, %$34] ; # NmY
  br label %$33
$41:
  %127 = phi i64 [%118, %$34] ; # X
  %128 = phi i64 [%119, %$34] ; # Y
  %129 = phi i64 [%120, %$34] ; # NmX
  %130 = phi i64 [%121, %$34] ; # NmY
; # (loop (let (A (if (cnt? NmX) (prog1 (shr (shl (name NmX) 2) 6) (s...
  br label %$43
$43:
  %131 = phi i64 [%127, %$41], [%330, %$63] ; # X
  %132 = phi i64 [%128, %$41], [%331, %$63] ; # Y
  %133 = phi i64 [%129, %$41], [%332, %$63] ; # NmX
  %134 = phi i64 [%130, %$41], [%333, %$63] ; # NmY
; # (let (A (if (cnt? NmX) (prog1 (shr (shl (name NmX) 2) 6) (setq Nm...
; # (if (cnt? NmX) (prog1 (shr (shl (name NmX) 2) 6) (setq NmX 0)) (p...
; # (cnt? NmX)
  %135 = and i64 %133, 2
  %136 = icmp ne i64 %135, 0
  br i1 %136, label %$44, label %$45
$44:
  %137 = phi i64 [%131, %$43] ; # X
  %138 = phi i64 [%132, %$43] ; # Y
  %139 = phi i64 [%133, %$43] ; # NmX
  %140 = phi i64 [%134, %$43] ; # NmY
; # (prog1 (shr (shl (name NmX) 2) 6) (setq NmX 0))
; # (name NmX)
  br label %$47
$47:
  %141 = phi i64 [%139, %$44], [%147, %$48] ; # Tail
  %142 = and i64 %141, 6
  %143 = icmp ne i64 %142, 0
  br i1 %143, label %$49, label %$48
$48:
  %144 = phi i64 [%141, %$47] ; # Tail
  %145 = inttoptr i64 %144 to i64*
  %146 = getelementptr i64, i64* %145, i32 1
  %147 = load i64, i64* %146
  br label %$47
$49:
  %148 = phi i64 [%141, %$47] ; # Tail
; # (shl (name NmX) 2)
  %149 = shl i64 %148, 2
; # (shr (shl (name NmX) 2) 6)
  %150 = lshr i64 %149, 6
  br label %$46
$45:
  %151 = phi i64 [%131, %$43] ; # X
  %152 = phi i64 [%132, %$43] ; # Y
  %153 = phi i64 [%133, %$43] ; # NmX
  %154 = phi i64 [%134, %$43] ; # NmY
; # (prog1 (val (dig NmX)) (setq NmX (val (big NmX))))
; # (dig NmX)
  %155 = add i64 %153, -4
; # (val (dig NmX))
  %156 = inttoptr i64 %155 to i64*
  %157 = load i64, i64* %156
; # (big NmX)
  %158 = add i64 %153, 4
; # (val (big NmX))
  %159 = inttoptr i64 %158 to i64*
  %160 = load i64, i64* %159
  br label %$46
$46:
  %161 = phi i64 [%137, %$49], [%151, %$45] ; # X
  %162 = phi i64 [%138, %$49], [%152, %$45] ; # Y
  %163 = phi i64 [0, %$49], [%160, %$45] ; # NmX
  %164 = phi i64 [%140, %$49], [%154, %$45] ; # NmY
  %165 = phi i64 [%150, %$49], [%157, %$45] ; # ->
; # (if (cnt? NmY) (prog1 (shr (shl (name NmY) 2) 6) (setq NmY 0)) (p...
; # (cnt? NmY)
  %166 = and i64 %164, 2
  %167 = icmp ne i64 %166, 0
  br i1 %167, label %$50, label %$51
$50:
  %168 = phi i64 [%161, %$46] ; # X
  %169 = phi i64 [%162, %$46] ; # Y
  %170 = phi i64 [%163, %$46] ; # NmX
  %171 = phi i64 [%164, %$46] ; # NmY
  %172 = phi i64 [%165, %$46] ; # A
; # (prog1 (shr (shl (name NmY) 2) 6) (setq NmY 0))
; # (name NmY)
  br label %$53
$53:
  %173 = phi i64 [%171, %$50], [%179, %$54] ; # Tail
  %174 = and i64 %173, 6
  %175 = icmp ne i64 %174, 0
  br i1 %175, label %$55, label %$54
$54:
  %176 = phi i64 [%173, %$53] ; # Tail
  %177 = inttoptr i64 %176 to i64*
  %178 = getelementptr i64, i64* %177, i32 1
  %179 = load i64, i64* %178
  br label %$53
$55:
  %180 = phi i64 [%173, %$53] ; # Tail
; # (shl (name NmY) 2)
  %181 = shl i64 %180, 2
; # (shr (shl (name NmY) 2) 6)
  %182 = lshr i64 %181, 6
  br label %$52
$51:
  %183 = phi i64 [%161, %$46] ; # X
  %184 = phi i64 [%162, %$46] ; # Y
  %185 = phi i64 [%163, %$46] ; # NmX
  %186 = phi i64 [%164, %$46] ; # NmY
  %187 = phi i64 [%165, %$46] ; # A
; # (prog1 (val (dig NmY)) (setq NmY (val (big NmY))))
; # (dig NmY)
  %188 = add i64 %186, -4
; # (val (dig NmY))
  %189 = inttoptr i64 %188 to i64*
  %190 = load i64, i64* %189
; # (big NmY)
  %191 = add i64 %186, 4
; # (val (big NmY))
  %192 = inttoptr i64 %191 to i64*
  %193 = load i64, i64* %192
  br label %$52
$52:
  %194 = phi i64 [%168, %$55], [%183, %$51] ; # X
  %195 = phi i64 [%169, %$55], [%184, %$51] ; # Y
  %196 = phi i64 [%170, %$55], [%185, %$51] ; # NmX
  %197 = phi i64 [0, %$55], [%193, %$51] ; # NmY
  %198 = phi i64 [%172, %$55], [%187, %$51] ; # A
  %199 = phi i64 [%182, %$55], [%190, %$51] ; # ->
; # (loop (when (- (& A 255) (& B 255)) (ret (if (gt0 @) 1 -1))) (? (...
  br label %$56
$56:
  %200 = phi i64 [%194, %$52], [%324, %$75] ; # X
  %201 = phi i64 [%195, %$52], [%325, %$75] ; # Y
  %202 = phi i64 [%196, %$52], [%326, %$75] ; # NmX
  %203 = phi i64 [%197, %$52], [%327, %$75] ; # NmY
  %204 = phi i64 [%198, %$52], [%328, %$75] ; # A
  %205 = phi i64 [%199, %$52], [%329, %$75] ; # B
; # (when (- (& A 255) (& B 255)) (ret (if (gt0 @) 1 -1)))
; # (& A 255)
  %206 = and i64 %204, 255
; # (& B 255)
  %207 = and i64 %205, 255
; # (- (& A 255) (& B 255))
  %208 = sub i64 %206, %207
  %209 = icmp ne i64 %208, 0
  br i1 %209, label %$57, label %$58
$57:
  %210 = phi i64 [%200, %$56] ; # X
  %211 = phi i64 [%201, %$56] ; # Y
  %212 = phi i64 [%202, %$56] ; # NmX
  %213 = phi i64 [%203, %$56] ; # NmY
  %214 = phi i64 [%204, %$56] ; # A
  %215 = phi i64 [%205, %$56] ; # B
; # (if (gt0 @) 1 -1)
; # (gt0 @)
  %216 = icmp sgt i64 %208, 0
  br i1 %216, label %$59, label %$60
$59:
  %217 = phi i64 [%210, %$57] ; # X
  %218 = phi i64 [%211, %$57] ; # Y
  %219 = phi i64 [%212, %$57] ; # NmX
  %220 = phi i64 [%213, %$57] ; # NmY
  %221 = phi i64 [%214, %$57] ; # A
  %222 = phi i64 [%215, %$57] ; # B
  br label %$61
$60:
  %223 = phi i64 [%210, %$57] ; # X
  %224 = phi i64 [%211, %$57] ; # Y
  %225 = phi i64 [%212, %$57] ; # NmX
  %226 = phi i64 [%213, %$57] ; # NmY
  %227 = phi i64 [%214, %$57] ; # A
  %228 = phi i64 [%215, %$57] ; # B
  br label %$61
$61:
  %229 = phi i64 [%217, %$59], [%223, %$60] ; # X
  %230 = phi i64 [%218, %$59], [%224, %$60] ; # Y
  %231 = phi i64 [%219, %$59], [%225, %$60] ; # NmX
  %232 = phi i64 [%220, %$59], [%226, %$60] ; # NmY
  %233 = phi i64 [%221, %$59], [%227, %$60] ; # A
  %234 = phi i64 [%222, %$59], [%228, %$60] ; # B
  %235 = phi i64 [1, %$59], [-1, %$60] ; # ->
; # (ret (if (gt0 @) 1 -1))
  ret i64 %235
$58:
  %236 = phi i64 [%200, %$56] ; # X
  %237 = phi i64 [%201, %$56] ; # Y
  %238 = phi i64 [%202, %$56] ; # NmX
  %239 = phi i64 [%203, %$56] ; # NmY
  %240 = phi i64 [%204, %$56] ; # A
  %241 = phi i64 [%205, %$56] ; # B
; # (? (=0 (setq A (shr A 8))) (when (setq B (shr B 8)) (ret -1)) (un...
; # (shr A 8)
  %242 = lshr i64 %240, 8
; # (=0 (setq A (shr A 8)))
  %243 = icmp eq i64 %242, 0
  br i1 %243, label %$64, label %$62
$64:
  %244 = phi i64 [%236, %$58] ; # X
  %245 = phi i64 [%237, %$58] ; # Y
  %246 = phi i64 [%238, %$58] ; # NmX
  %247 = phi i64 [%239, %$58] ; # NmY
  %248 = phi i64 [%242, %$58] ; # A
  %249 = phi i64 [%241, %$58] ; # B
; # (when (setq B (shr B 8)) (ret -1))
; # (shr B 8)
  %250 = lshr i64 %249, 8
  %251 = icmp ne i64 %250, 0
  br i1 %251, label %$65, label %$66
$65:
  %252 = phi i64 [%244, %$64] ; # X
  %253 = phi i64 [%245, %$64] ; # Y
  %254 = phi i64 [%246, %$64] ; # NmX
  %255 = phi i64 [%247, %$64] ; # NmY
  %256 = phi i64 [%248, %$64] ; # A
  %257 = phi i64 [%250, %$64] ; # B
; # (ret -1)
  ret i64 -1
$66:
  %258 = phi i64 [%244, %$64] ; # X
  %259 = phi i64 [%245, %$64] ; # Y
  %260 = phi i64 [%246, %$64] ; # NmX
  %261 = phi i64 [%247, %$64] ; # NmY
  %262 = phi i64 [%248, %$64] ; # A
  %263 = phi i64 [%250, %$64] ; # B
; # (unless NmX (ret (if NmY -1 0)))
  %264 = icmp ne i64 %260, 0
  br i1 %264, label %$68, label %$67
$67:
  %265 = phi i64 [%258, %$66] ; # X
  %266 = phi i64 [%259, %$66] ; # Y
  %267 = phi i64 [%260, %$66] ; # NmX
  %268 = phi i64 [%261, %$66] ; # NmY
  %269 = phi i64 [%262, %$66] ; # A
  %270 = phi i64 [%263, %$66] ; # B
; # (if NmY -1 0)
  %271 = icmp ne i64 %268, 0
  br i1 %271, label %$69, label %$70
$69:
  %272 = phi i64 [%265, %$67] ; # X
  %273 = phi i64 [%266, %$67] ; # Y
  %274 = phi i64 [%267, %$67] ; # NmX
  %275 = phi i64 [%268, %$67] ; # NmY
  %276 = phi i64 [%269, %$67] ; # A
  %277 = phi i64 [%270, %$67] ; # B
  br label %$71
$70:
  %278 = phi i64 [%265, %$67] ; # X
  %279 = phi i64 [%266, %$67] ; # Y
  %280 = phi i64 [%267, %$67] ; # NmX
  %281 = phi i64 [%268, %$67] ; # NmY
  %282 = phi i64 [%269, %$67] ; # A
  %283 = phi i64 [%270, %$67] ; # B
  br label %$71
$71:
  %284 = phi i64 [%272, %$69], [%278, %$70] ; # X
  %285 = phi i64 [%273, %$69], [%279, %$70] ; # Y
  %286 = phi i64 [%274, %$69], [%280, %$70] ; # NmX
  %287 = phi i64 [%275, %$69], [%281, %$70] ; # NmY
  %288 = phi i64 [%276, %$69], [%282, %$70] ; # A
  %289 = phi i64 [%277, %$69], [%283, %$70] ; # B
  %290 = phi i64 [-1, %$69], [0, %$70] ; # ->
; # (ret (if NmY -1 0))
  ret i64 %290
$68:
  %291 = phi i64 [%258, %$66] ; # X
  %292 = phi i64 [%259, %$66] ; # Y
  %293 = phi i64 [%260, %$66] ; # NmX
  %294 = phi i64 [%261, %$66] ; # NmY
  %295 = phi i64 [%262, %$66] ; # A
  %296 = phi i64 [%263, %$66] ; # B
; # (unless NmY (ret 1))
  %297 = icmp ne i64 %294, 0
  br i1 %297, label %$73, label %$72
$72:
  %298 = phi i64 [%291, %$68] ; # X
  %299 = phi i64 [%292, %$68] ; # Y
  %300 = phi i64 [%293, %$68] ; # NmX
  %301 = phi i64 [%294, %$68] ; # NmY
  %302 = phi i64 [%295, %$68] ; # A
  %303 = phi i64 [%296, %$68] ; # B
; # (ret 1)
  ret i64 1
$73:
  %304 = phi i64 [%291, %$68] ; # X
  %305 = phi i64 [%292, %$68] ; # Y
  %306 = phi i64 [%293, %$68] ; # NmX
  %307 = phi i64 [%294, %$68] ; # NmY
  %308 = phi i64 [%295, %$68] ; # A
  %309 = phi i64 [%296, %$68] ; # B
  br label %$63
$62:
  %310 = phi i64 [%236, %$58] ; # X
  %311 = phi i64 [%237, %$58] ; # Y
  %312 = phi i64 [%238, %$58] ; # NmX
  %313 = phi i64 [%239, %$58] ; # NmY
  %314 = phi i64 [%242, %$58] ; # A
  %315 = phi i64 [%241, %$58] ; # B
; # (unless (setq B (shr B 8)) (ret 1))
; # (shr B 8)
  %316 = lshr i64 %315, 8
  %317 = icmp ne i64 %316, 0
  br i1 %317, label %$75, label %$74
$74:
  %318 = phi i64 [%310, %$62] ; # X
  %319 = phi i64 [%311, %$62] ; # Y
  %320 = phi i64 [%312, %$62] ; # NmX
  %321 = phi i64 [%313, %$62] ; # NmY
  %322 = phi i64 [%314, %$62] ; # A
  %323 = phi i64 [%316, %$62] ; # B
; # (ret 1)
  ret i64 1
$75:
  %324 = phi i64 [%310, %$62] ; # X
  %325 = phi i64 [%311, %$62] ; # Y
  %326 = phi i64 [%312, %$62] ; # NmX
  %327 = phi i64 [%313, %$62] ; # NmY
  %328 = phi i64 [%314, %$62] ; # A
  %329 = phi i64 [%316, %$62] ; # B
  br label %$56
$63:
  %330 = phi i64 [%304, %$73] ; # X
  %331 = phi i64 [%305, %$73] ; # Y
  %332 = phi i64 [%306, %$73] ; # NmX
  %333 = phi i64 [%307, %$73] ; # NmY
  %334 = phi i64 [%308, %$73] ; # A
  %335 = phi i64 [%309, %$73] ; # B
  br label %$43
$33:
  %336 = phi i64 [%113, %$36], [%123, %$42] ; # X
  %337 = phi i64 [%114, %$36], [%124, %$42] ; # Y
  %338 = phi i64 [%115, %$36], [%125, %$42] ; # NmX
  %339 = phi i64 [%116, %$36], [%126, %$42] ; # NmY
  %340 = phi i64 [%117, %$36], [1, %$42] ; # ->
  br label %$18
$18:
  %341 = phi i64 [%50, %$22], [%62, %$26], [%336, %$33] ; # X
  %342 = phi i64 [%51, %$22], [%63, %$26], [%337, %$33] ; # Y
  %343 = phi i64 [1, %$22], [-1, %$26], [%340, %$33] ; # ->
  br label %$2
$16:
  %344 = phi i64 [%36, %$9] ; # X
  %345 = phi i64 [%37, %$9] ; # Y
; # (atom Y)
  %346 = and i64 %345, 15
  %347 = icmp ne i64 %346, 0
  br i1 %347, label %$77, label %$76
$77:
  %348 = phi i64 [%344, %$16] ; # X
  %349 = phi i64 [%345, %$16] ; # Y
; # (if (t? Y) -1 1)
; # (t? Y)
  %350 = icmp eq i64 %349, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %350, label %$78, label %$79
$78:
  %351 = phi i64 [%348, %$77] ; # X
  %352 = phi i64 [%349, %$77] ; # Y
  br label %$80
$79:
  %353 = phi i64 [%348, %$77] ; # X
  %354 = phi i64 [%349, %$77] ; # Y
  br label %$80
$80:
  %355 = phi i64 [%351, %$78], [%353, %$79] ; # X
  %356 = phi i64 [%352, %$78], [%354, %$79] ; # Y
  %357 = phi i64 [-1, %$78], [1, %$79] ; # ->
  br label %$2
$76:
  %358 = phi i64 [%344, %$16] ; # X
  %359 = phi i64 [%345, %$16] ; # Y
; # (stkChk 0)
  %360 = load i8*, i8** @$StkLimit
  %361 = call i8* @llvm.stacksave()
  %362 = icmp ugt i8* %360, %361
  br i1 %362, label %$81, label %$82
$81:
  call void @stkErr(i64 0)
  unreachable
$82:
; # (let (A X B Y) (loop (? (compare (car X) (car Y)) @) (? (atom (sh...
; # (loop (? (compare (car X) (car Y)) @) (? (atom (shift X)) (compar...
  br label %$83
$83:
  %363 = phi i64 [%358, %$82], [%421, %$102] ; # X
  %364 = phi i64 [%359, %$82], [%422, %$102] ; # Y
; # (? (compare (car X) (car Y)) @)
; # (car X)
  %365 = inttoptr i64 %363 to i64*
  %366 = load i64, i64* %365
; # (car Y)
  %367 = inttoptr i64 %364 to i64*
  %368 = load i64, i64* %367
; # (compare (car X) (car Y))
  %369 = call i64 @compare(i64 %366, i64 %368)
  %370 = icmp ne i64 %369, 0
  br i1 %370, label %$86, label %$84
$86:
  %371 = phi i64 [%363, %$83] ; # X
  %372 = phi i64 [%364, %$83] ; # Y
  br label %$85
$84:
  %373 = phi i64 [%363, %$83] ; # X
  %374 = phi i64 [%364, %$83] ; # Y
; # (? (atom (shift X)) (compare X (cdr Y)))
; # (shift X)
  %375 = inttoptr i64 %373 to i64*
  %376 = getelementptr i64, i64* %375, i32 1
  %377 = load i64, i64* %376
; # (atom (shift X))
  %378 = and i64 %377, 15
  %379 = icmp ne i64 %378, 0
  br i1 %379, label %$88, label %$87
$88:
  %380 = phi i64 [%377, %$84] ; # X
  %381 = phi i64 [%374, %$84] ; # Y
; # (cdr Y)
  %382 = inttoptr i64 %381 to i64*
  %383 = getelementptr i64, i64* %382, i32 1
  %384 = load i64, i64* %383
; # (compare X (cdr Y))
  %385 = call i64 @compare(i64 %380, i64 %384)
  br label %$85
$87:
  %386 = phi i64 [%377, %$84] ; # X
  %387 = phi i64 [%374, %$84] ; # Y
; # (? (atom (shift Y)) (if (t? Y) -1 1))
; # (shift Y)
  %388 = inttoptr i64 %387 to i64*
  %389 = getelementptr i64, i64* %388, i32 1
  %390 = load i64, i64* %389
; # (atom (shift Y))
  %391 = and i64 %390, 15
  %392 = icmp ne i64 %391, 0
  br i1 %392, label %$90, label %$89
$90:
  %393 = phi i64 [%386, %$87] ; # X
  %394 = phi i64 [%390, %$87] ; # Y
; # (if (t? Y) -1 1)
; # (t? Y)
  %395 = icmp eq i64 %394, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %395, label %$91, label %$92
$91:
  %396 = phi i64 [%393, %$90] ; # X
  %397 = phi i64 [%394, %$90] ; # Y
  br label %$93
$92:
  %398 = phi i64 [%393, %$90] ; # X
  %399 = phi i64 [%394, %$90] ; # Y
  br label %$93
$93:
  %400 = phi i64 [%396, %$91], [%398, %$92] ; # X
  %401 = phi i64 [%397, %$91], [%399, %$92] ; # Y
  %402 = phi i64 [-1, %$91], [1, %$92] ; # ->
  br label %$85
$89:
  %403 = phi i64 [%386, %$87] ; # X
  %404 = phi i64 [%390, %$87] ; # Y
; # (? (== X A) (if (== Y B) 0 -1))
; # (== X A)
  %405 = icmp eq i64 %403, %358
  br i1 %405, label %$95, label %$94
$95:
  %406 = phi i64 [%403, %$89] ; # X
  %407 = phi i64 [%404, %$89] ; # Y
; # (if (== Y B) 0 -1)
; # (== Y B)
  %408 = icmp eq i64 %407, %359
  br i1 %408, label %$96, label %$97
$96:
  %409 = phi i64 [%406, %$95] ; # X
  %410 = phi i64 [%407, %$95] ; # Y
  br label %$98
$97:
  %411 = phi i64 [%406, %$95] ; # X
  %412 = phi i64 [%407, %$95] ; # Y
  br label %$98
$98:
  %413 = phi i64 [%409, %$96], [%411, %$97] ; # X
  %414 = phi i64 [%410, %$96], [%412, %$97] ; # Y
  %415 = phi i64 [0, %$96], [-1, %$97] ; # ->
  br label %$85
$94:
  %416 = phi i64 [%403, %$89] ; # X
  %417 = phi i64 [%404, %$89] ; # Y
; # (? (== Y B) 1)
; # (== Y B)
  %418 = icmp eq i64 %417, %359
  br i1 %418, label %$100, label %$99
$100:
  %419 = phi i64 [%416, %$94] ; # X
  %420 = phi i64 [%417, %$94] ; # Y
  br label %$85
$99:
  %421 = phi i64 [%416, %$94] ; # X
  %422 = phi i64 [%417, %$94] ; # Y
; # (sigChk 0)
  %423 = load volatile i32, i32* bitcast ([16 x i32]* @$Signal to i32*)
  %424 = icmp ne i32 %423, 0
  br i1 %424, label %$101, label %$102
$101:
  call void @sighandler(i64 0)
  br label %$102
$102:
  br label %$83
$85:
  %425 = phi i64 [%371, %$86], [%380, %$88], [%400, %$93], [%413, %$98], [%419, %$100] ; # X
  %426 = phi i64 [%372, %$86], [%381, %$88], [%401, %$93], [%414, %$98], [%420, %$100] ; # Y
  %427 = phi i64 [%369, %$86], [%385, %$88], [%402, %$93], [%415, %$98], [1, %$100] ; # ->
  br label %$2
$2:
  %428 = phi i64 [%3, %$4], [%8, %$6], [%13, %$8], [%33, %$11], [%341, %$18], [%355, %$80], [%425, %$85] ; # X
  %429 = phi i64 [%4, %$4], [%9, %$6], [%14, %$8], [%34, %$11], [%342, %$18], [%356, %$80], [%426, %$85] ; # Y
  %430 = phi i64 [0, %$4], [-1, %$6], [1, %$8], [%35, %$11], [%343, %$18], [%357, %$80], [%427, %$85] ; # ->
  ret i64 %430
}

define void @undefined(i64, i64) align 8 {
$1:
; # (err Exe Fun ($ "Undefined") null)
  call void @err(i64 %1, i64 %0, i8* bitcast ([10 x i8]* @$29 to i8*), i8* null)
  unreachable
}

define i64 @evExpr(i64, i64) align 8 {
$1:
; # (stkChk Exe)
  %2 = load i8*, i8** @$StkLimit
  %3 = call i8* @llvm.stacksave()
  %4 = icmp ugt i8* %2, %3
  br i1 %4, label %$2, label %$3
$2:
  call void @stkErr(i64 %0)
  unreachable
$3:
; # (let (X (cdr Lst) Y (car Exe) P (set $Bind (push (val $At) $At (v...
; # (cdr Lst)
  %5 = inttoptr i64 %1 to i64*
  %6 = getelementptr i64, i64* %5, i32 1
  %7 = load i64, i64* %6
; # (car Exe)
  %8 = inttoptr i64 %0 to i64*
  %9 = load i64, i64* %8
; # (set $Bind (push (val $At) $At (val $Bind) Lst))
; # (val $At)
  %10 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  %11 = load i64, i64* %10
; # (val $Bind)
  %12 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  %13 = load i64, i64* %12
; # (push (val $At) $At (val $Bind) Lst)
  %14 = alloca i64, i64 4, align 16
  %15 = ptrtoint i64* %14 to i64
  %16 = inttoptr i64 %15 to i64*
  store i64 %11, i64* %16
  %17 = add i64 %15, 8
  %18 = inttoptr i64 %17 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64), i64* %18
  %19 = add i64 %15, 16
  %20 = inttoptr i64 %19 to i64*
  store i64 %13, i64* %20
  %21 = add i64 %15, 24
  %22 = inttoptr i64 %21 to i64*
  store i64 %1, i64* %22
  %23 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %15, i64* %23
; # (while (pair Y) (let (V (eval (++ X)) Z (++ Y)) (if (atom Z) (set...
  br label %$4
$4:
  %24 = phi i64 [%7, %$3], [%154, %$14] ; # X
  %25 = phi i64 [%9, %$3], [%155, %$14] ; # Y
  %26 = phi i64 [%15, %$3], [%156, %$14] ; # P
; # (pair Y)
  %27 = and i64 %25, 15
  %28 = icmp eq i64 %27, 0
  br i1 %28, label %$5, label %$6
$5:
  %29 = phi i64 [%24, %$4] ; # X
  %30 = phi i64 [%25, %$4] ; # Y
  %31 = phi i64 [%26, %$4] ; # P
; # (let (V (eval (++ X)) Z (++ Y)) (if (atom Z) (set $Bind (setq P (...
; # (++ X)
  %32 = inttoptr i64 %29 to i64*
  %33 = load i64, i64* %32
  %34 = getelementptr i64, i64* %32, i32 1
  %35 = load i64, i64* %34
; # (eval (++ X))
  %36 = and i64 %33, 6
  %37 = icmp ne i64 %36, 0
  br i1 %37, label %$9, label %$8
$9:
  br label %$7
$8:
  %38 = and i64 %33, 8
  %39 = icmp ne i64 %38, 0
  br i1 %39, label %$11, label %$10
$11:
  %40 = inttoptr i64 %33 to i64*
  %41 = load i64, i64* %40
  br label %$7
$10:
  %42 = call i64 @evList(i64 %33)
  br label %$7
$7:
  %43 = phi i64 [%33, %$9], [%41, %$11], [%42, %$10] ; # ->
; # (++ Y)
  %44 = inttoptr i64 %30 to i64*
  %45 = load i64, i64* %44
  %46 = getelementptr i64, i64* %44, i32 1
  %47 = load i64, i64* %46
; # (if (atom Z) (set $Bind (setq P (push V (needChkVar Exe Z) P))) (...
; # (atom Z)
  %48 = and i64 %45, 15
  %49 = icmp ne i64 %48, 0
  br i1 %49, label %$12, label %$13
$12:
  %50 = phi i64 [%35, %$7] ; # X
  %51 = phi i64 [%47, %$7] ; # Y
  %52 = phi i64 [%31, %$7] ; # P
  %53 = phi i64 [%43, %$7] ; # V
  %54 = phi i64 [%45, %$7] ; # Z
; # (set $Bind (setq P (push V (needChkVar Exe Z) P)))
; # (needChkVar Exe Z)
  %55 = and i64 %54, 6
  %56 = icmp ne i64 %55, 0
  br i1 %56, label %$15, label %$16
$15:
  call void @varErr(i64 %0, i64 %54)
  unreachable
$16:
  %57 = icmp uge i64 %54, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %57, label %$18, label %$17
$18:
  %58 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %54
  br label %$17
$17:
  %59 = phi i1 [0, %$16], [%58, %$18] ; # ->
  br i1 %59, label %$19, label %$20
$19:
  call void @protErr(i64 %0, i64 %54)
  unreachable
$20:
; # (push V (needChkVar Exe Z) P)
  %60 = alloca i64, i64 3, align 16
  %61 = ptrtoint i64* %60 to i64
  %62 = inttoptr i64 %61 to i64*
  store i64 %53, i64* %62
  %63 = add i64 %61, 8
  %64 = inttoptr i64 %63 to i64*
  store i64 %54, i64* %64
  %65 = add i64 %61, 16
  %66 = inttoptr i64 %65 to i64*
  store i64 %52, i64* %66
  %67 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %61, i64* %67
  br label %$14
$13:
  %68 = phi i64 [%35, %$7] ; # X
  %69 = phi i64 [%47, %$7] ; # Y
  %70 = phi i64 [%31, %$7] ; # P
  %71 = phi i64 [%43, %$7] ; # V
  %72 = phi i64 [%45, %$7] ; # Z
; # (loop (set $Bind (setq P (push (if (pair V) (++ V) $Nil) (needChk...
  br label %$21
$21:
  %73 = phi i64 [%68, %$13], [%119, %$31] ; # X
  %74 = phi i64 [%69, %$13], [%120, %$31] ; # Y
  %75 = phi i64 [%70, %$13], [%121, %$31] ; # P
  %76 = phi i64 [%71, %$13], [%122, %$31] ; # V
  %77 = phi i64 [%72, %$13], [%123, %$31] ; # Z
; # (set $Bind (setq P (push (if (pair V) (++ V) $Nil) (needChkVar Ex...
; # (if (pair V) (++ V) $Nil)
; # (pair V)
  %78 = and i64 %76, 15
  %79 = icmp eq i64 %78, 0
  br i1 %79, label %$22, label %$23
$22:
  %80 = phi i64 [%73, %$21] ; # X
  %81 = phi i64 [%74, %$21] ; # Y
  %82 = phi i64 [%75, %$21] ; # P
  %83 = phi i64 [%76, %$21] ; # V
  %84 = phi i64 [%77, %$21] ; # Z
; # (++ V)
  %85 = inttoptr i64 %83 to i64*
  %86 = load i64, i64* %85
  %87 = getelementptr i64, i64* %85, i32 1
  %88 = load i64, i64* %87
  br label %$24
$23:
  %89 = phi i64 [%73, %$21] ; # X
  %90 = phi i64 [%74, %$21] ; # Y
  %91 = phi i64 [%75, %$21] ; # P
  %92 = phi i64 [%76, %$21] ; # V
  %93 = phi i64 [%77, %$21] ; # Z
  br label %$24
$24:
  %94 = phi i64 [%80, %$22], [%89, %$23] ; # X
  %95 = phi i64 [%81, %$22], [%90, %$23] ; # Y
  %96 = phi i64 [%82, %$22], [%91, %$23] ; # P
  %97 = phi i64 [%88, %$22], [%92, %$23] ; # V
  %98 = phi i64 [%84, %$22], [%93, %$23] ; # Z
  %99 = phi i64 [%86, %$22], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$23] ; # ->
; # (++ Z)
  %100 = inttoptr i64 %98 to i64*
  %101 = load i64, i64* %100
  %102 = getelementptr i64, i64* %100, i32 1
  %103 = load i64, i64* %102
; # (needChkVar Exe (++ Z))
  %104 = and i64 %101, 6
  %105 = icmp ne i64 %104, 0
  br i1 %105, label %$25, label %$26
$25:
  call void @varErr(i64 %0, i64 %101)
  unreachable
$26:
  %106 = icmp uge i64 %101, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %106, label %$28, label %$27
$28:
  %107 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %101
  br label %$27
$27:
  %108 = phi i1 [0, %$26], [%107, %$28] ; # ->
  br i1 %108, label %$29, label %$30
$29:
  call void @protErr(i64 %0, i64 %101)
  unreachable
$30:
; # (push (if (pair V) (++ V) $Nil) (needChkVar Exe (++ Z)) P)
  %109 = alloca i64, i64 3, align 16
  %110 = ptrtoint i64* %109 to i64
  %111 = inttoptr i64 %110 to i64*
  store i64 %99, i64* %111
  %112 = add i64 %110, 8
  %113 = inttoptr i64 %112 to i64*
  store i64 %101, i64* %113
  %114 = add i64 %110, 16
  %115 = inttoptr i64 %114 to i64*
  store i64 %96, i64* %115
  %116 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %110, i64* %116
; # (? (atom Z))
; # (atom Z)
  %117 = and i64 %103, 15
  %118 = icmp ne i64 %117, 0
  br i1 %118, label %$32, label %$31
$31:
  %119 = phi i64 [%94, %$30] ; # X
  %120 = phi i64 [%95, %$30] ; # Y
  %121 = phi i64 [%110, %$30] ; # P
  %122 = phi i64 [%97, %$30] ; # V
  %123 = phi i64 [%103, %$30] ; # Z
  br label %$21
$32:
  %124 = phi i64 [%94, %$30] ; # X
  %125 = phi i64 [%95, %$30] ; # Y
  %126 = phi i64 [%110, %$30] ; # P
  %127 = phi i64 [%97, %$30] ; # V
  %128 = phi i64 [%103, %$30] ; # Z
  %129 = phi i64 [0, %$30] ; # ->
; # (unless (nil? Z) (set $Bind (setq P (push V (needChkVar Exe Z) P)...
; # (nil? Z)
  %130 = icmp eq i64 %128, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %130, label %$34, label %$33
$33:
  %131 = phi i64 [%124, %$32] ; # X
  %132 = phi i64 [%125, %$32] ; # Y
  %133 = phi i64 [%126, %$32] ; # P
  %134 = phi i64 [%127, %$32] ; # V
  %135 = phi i64 [%128, %$32] ; # Z
; # (set $Bind (setq P (push V (needChkVar Exe Z) P)))
; # (needChkVar Exe Z)
  %136 = and i64 %135, 6
  %137 = icmp ne i64 %136, 0
  br i1 %137, label %$35, label %$36
$35:
  call void @varErr(i64 %0, i64 %135)
  unreachable
$36:
  %138 = icmp uge i64 %135, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %138, label %$38, label %$37
$38:
  %139 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %135
  br label %$37
$37:
  %140 = phi i1 [0, %$36], [%139, %$38] ; # ->
  br i1 %140, label %$39, label %$40
$39:
  call void @protErr(i64 %0, i64 %135)
  unreachable
$40:
; # (push V (needChkVar Exe Z) P)
  %141 = alloca i64, i64 3, align 16
  %142 = ptrtoint i64* %141 to i64
  %143 = inttoptr i64 %142 to i64*
  store i64 %134, i64* %143
  %144 = add i64 %142, 8
  %145 = inttoptr i64 %144 to i64*
  store i64 %135, i64* %145
  %146 = add i64 %142, 16
  %147 = inttoptr i64 %146 to i64*
  store i64 %133, i64* %147
  %148 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %142, i64* %148
  br label %$34
$34:
  %149 = phi i64 [%124, %$32], [%131, %$40] ; # X
  %150 = phi i64 [%125, %$32], [%132, %$40] ; # Y
  %151 = phi i64 [%126, %$32], [%142, %$40] ; # P
  %152 = phi i64 [%127, %$32], [%134, %$40] ; # V
  %153 = phi i64 [%128, %$32], [%135, %$40] ; # Z
  br label %$14
$14:
  %154 = phi i64 [%50, %$20], [%149, %$34] ; # X
  %155 = phi i64 [%51, %$20], [%150, %$34] ; # Y
  %156 = phi i64 [%61, %$20], [%151, %$34] ; # P
  %157 = phi i64 [%53, %$20], [%152, %$34] ; # V
  %158 = phi i64 [%54, %$20], [%153, %$34] ; # Z
  br label %$4
$6:
  %159 = phi i64 [%24, %$4] ; # X
  %160 = phi i64 [%25, %$4] ; # Y
  %161 = phi i64 [%26, %$4] ; # P
; # (prog1 (if (== Y $At) (if (pair X) (let (L (push NIL (eval (car X...
; # (if (== Y $At) (if (pair X) (let (L (push NIL (eval (car X)) NIL)...
; # (== Y $At)
  %162 = icmp eq i64 %160, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64)
  br i1 %162, label %$41, label %$42
$41:
  %163 = phi i64 [%159, %$6] ; # X
  %164 = phi i64 [%160, %$6] ; # Y
  %165 = phi i64 [%161, %$6] ; # P
; # (if (pair X) (let (L (push NIL (eval (car X)) NIL) Q L) (link (of...
; # (pair X)
  %166 = and i64 %163, 15
  %167 = icmp eq i64 %166, 0
  br i1 %167, label %$44, label %$45
$44:
  %168 = phi i64 [%163, %$41] ; # X
  %169 = phi i64 [%164, %$41] ; # Y
  %170 = phi i64 [%165, %$41] ; # P
; # (let (L (push NIL (eval (car X)) NIL) Q L) (link (ofs L 1)) (whil...
; # (car X)
  %171 = inttoptr i64 %168 to i64*
  %172 = load i64, i64* %171
; # (eval (car X))
  %173 = and i64 %172, 6
  %174 = icmp ne i64 %173, 0
  br i1 %174, label %$49, label %$48
$49:
  br label %$47
$48:
  %175 = and i64 %172, 8
  %176 = icmp ne i64 %175, 0
  br i1 %176, label %$51, label %$50
$51:
  %177 = inttoptr i64 %172 to i64*
  %178 = load i64, i64* %177
  br label %$47
$50:
  %179 = call i64 @evList(i64 %172)
  br label %$47
$47:
  %180 = phi i64 [%172, %$49], [%178, %$51], [%179, %$50] ; # ->
; # (push NIL (eval (car X)) NIL)
  %181 = alloca i64, i64 3, align 16
  %182 = ptrtoint i64* %181 to i64
  %183 = add i64 %182, 8
  %184 = inttoptr i64 %183 to i64*
  store i64 %180, i64* %184
; # (ofs L 1)
  %185 = add i64 %182, 8
; # (link (ofs L 1))
  %186 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %187 = load i64, i64* %186
  %188 = inttoptr i64 %185 to i64*
  %189 = getelementptr i64, i64* %188, i32 1
  store i64 %187, i64* %189
  %190 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %185, i64* %190
; # (while (pair (shift X)) (setq L (set L (push NIL (eval (car X)) N...
  br label %$52
$52:
  %191 = phi i64 [%168, %$47], [%200, %$55] ; # X
  %192 = phi i64 [%169, %$47], [%201, %$55] ; # Y
  %193 = phi i64 [%170, %$47], [%202, %$55] ; # P
  %194 = phi i64 [%182, %$47], [%215, %$55] ; # L
; # (shift X)
  %195 = inttoptr i64 %191 to i64*
  %196 = getelementptr i64, i64* %195, i32 1
  %197 = load i64, i64* %196
; # (pair (shift X))
  %198 = and i64 %197, 15
  %199 = icmp eq i64 %198, 0
  br i1 %199, label %$53, label %$54
$53:
  %200 = phi i64 [%197, %$52] ; # X
  %201 = phi i64 [%192, %$52] ; # Y
  %202 = phi i64 [%193, %$52] ; # P
  %203 = phi i64 [%194, %$52] ; # L
; # (set L (push NIL (eval (car X)) NIL))
; # (car X)
  %204 = inttoptr i64 %200 to i64*
  %205 = load i64, i64* %204
; # (eval (car X))
  %206 = and i64 %205, 6
  %207 = icmp ne i64 %206, 0
  br i1 %207, label %$57, label %$56
$57:
  br label %$55
$56:
  %208 = and i64 %205, 8
  %209 = icmp ne i64 %208, 0
  br i1 %209, label %$59, label %$58
$59:
  %210 = inttoptr i64 %205 to i64*
  %211 = load i64, i64* %210
  br label %$55
$58:
  %212 = call i64 @evList(i64 %205)
  br label %$55
$55:
  %213 = phi i64 [%205, %$57], [%211, %$59], [%212, %$58] ; # ->
; # (push NIL (eval (car X)) NIL)
  %214 = alloca i64, i64 3, align 16
  %215 = ptrtoint i64* %214 to i64
  %216 = add i64 %215, 8
  %217 = inttoptr i64 %216 to i64*
  store i64 %213, i64* %217
  %218 = inttoptr i64 %203 to i64*
  store i64 %215, i64* %218
; # (ofs L 1)
  %219 = add i64 %215, 8
; # (link (ofs L 1))
  %220 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %221 = load i64, i64* %220
  %222 = inttoptr i64 %219 to i64*
  %223 = getelementptr i64, i64* %222, i32 1
  store i64 %221, i64* %223
  %224 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %219, i64* %224
  br label %$52
$54:
  %225 = phi i64 [%197, %$52] ; # X
  %226 = phi i64 [%192, %$52] ; # Y
  %227 = phi i64 [%193, %$52] ; # P
  %228 = phi i64 [%194, %$52] ; # L
; # (let Next (val $Next) (set L $Nil $Next Q) (loop (let Sym (val 2 ...
; # (val $Next)
  %229 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 128) to i64) to i64*
  %230 = load i64, i64* %229
; # (set L $Nil $Next Q)
  %231 = inttoptr i64 %228 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %231
  %232 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 128) to i64) to i64*
  store i64 %182, i64* %232
; # (loop (let Sym (val 2 P) (xchg Sym P) (? (== $At Sym)) (setq P (v...
  br label %$60
$60:
  %233 = phi i64 [%225, %$54], [%245, %$61] ; # X
  %234 = phi i64 [%226, %$54], [%246, %$61] ; # Y
  %235 = phi i64 [%227, %$54], [%251, %$61] ; # P
  %236 = phi i64 [%228, %$54], [%248, %$61] ; # L
; # (let Sym (val 2 P) (xchg Sym P) (? (== $At Sym)) (setq P (val 3 P...
; # (val 2 P)
  %237 = inttoptr i64 %235 to i64*
  %238 = getelementptr i64, i64* %237, i32 1
  %239 = load i64, i64* %238
; # (xchg Sym P)
  %240 = inttoptr i64 %239 to i64*
  %241 = load i64, i64* %240
  %242 = inttoptr i64 %235 to i64*
  %243 = load i64, i64* %242
  store i64 %243, i64* %240
  store i64 %241, i64* %242
; # (? (== $At Sym))
; # (== $At Sym)
  %244 = icmp eq i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64), %239
  br i1 %244, label %$62, label %$61
$61:
  %245 = phi i64 [%233, %$60] ; # X
  %246 = phi i64 [%234, %$60] ; # Y
  %247 = phi i64 [%235, %$60] ; # P
  %248 = phi i64 [%236, %$60] ; # L
; # (val 3 P)
  %249 = inttoptr i64 %247 to i64*
  %250 = getelementptr i64, i64* %249, i32 2
  %251 = load i64, i64* %250
  br label %$60
$62:
  %252 = phi i64 [%233, %$60] ; # X
  %253 = phi i64 [%234, %$60] ; # Y
  %254 = phi i64 [%235, %$60] ; # P
  %255 = phi i64 [%236, %$60] ; # L
  %256 = phi i64 [0, %$60] ; # ->
; # (prog1 (run (cdr Exe)) (set $Next Next) (drop (ofs Q 1)))
; # (cdr Exe)
  %257 = inttoptr i64 %0 to i64*
  %258 = getelementptr i64, i64* %257, i32 1
  %259 = load i64, i64* %258
; # (run (cdr Exe))
  br label %$63
$63:
  %260 = phi i64 [%259, %$62], [%282, %$72] ; # Prg
  %261 = inttoptr i64 %260 to i64*
  %262 = load i64, i64* %261
  %263 = getelementptr i64, i64* %261, i32 1
  %264 = load i64, i64* %263
  %265 = and i64 %264, 15
  %266 = icmp ne i64 %265, 0
  br i1 %266, label %$66, label %$64
$66:
  %267 = phi i64 [%264, %$63] ; # Prg
  %268 = and i64 %262, 6
  %269 = icmp ne i64 %268, 0
  br i1 %269, label %$69, label %$68
$69:
  br label %$67
$68:
  %270 = and i64 %262, 8
  %271 = icmp ne i64 %270, 0
  br i1 %271, label %$71, label %$70
$71:
  %272 = inttoptr i64 %262 to i64*
  %273 = load i64, i64* %272
  br label %$67
$70:
  %274 = call i64 @evList(i64 %262)
  br label %$67
$67:
  %275 = phi i64 [%262, %$69], [%273, %$71], [%274, %$70] ; # ->
  br label %$65
$64:
  %276 = phi i64 [%264, %$63] ; # Prg
  %277 = and i64 %262, 15
  %278 = icmp eq i64 %277, 0
  br i1 %278, label %$73, label %$72
$73:
  %279 = phi i64 [%276, %$64] ; # Prg
  %280 = call i64 @evList(i64 %262)
  %281 = icmp ne i64 %280, 0
  br label %$72
$72:
  %282 = phi i64 [%276, %$64], [%279, %$73] ; # Prg
  %283 = phi i1 [0, %$64], [%281, %$73] ; # ->
  br label %$63
$65:
  %284 = phi i64 [%267, %$67] ; # Prg
  %285 = phi i64 [%275, %$67] ; # ->
; # (set $Next Next)
  %286 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 128) to i64) to i64*
  store i64 %230, i64* %286
; # (ofs Q 1)
  %287 = add i64 %182, 8
; # (drop (ofs Q 1))
  %288 = inttoptr i64 %287 to i64*
  %289 = getelementptr i64, i64* %288, i32 1
  %290 = load i64, i64* %289
  %291 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %290, i64* %291
  br label %$46
$45:
  %292 = phi i64 [%163, %$41] ; # X
  %293 = phi i64 [%164, %$41] ; # Y
  %294 = phi i64 [%165, %$41] ; # P
; # (let Next (val $Next) (set $Next $Nil) (loop (let Sym (val 2 P) (...
; # (val $Next)
  %295 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 128) to i64) to i64*
  %296 = load i64, i64* %295
; # (set $Next $Nil)
  %297 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 128) to i64) to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %297
; # (loop (let Sym (val 2 P) (xchg Sym P) (? (== $At Sym)) (setq P (v...
  br label %$74
$74:
  %298 = phi i64 [%292, %$45], [%309, %$75] ; # X
  %299 = phi i64 [%293, %$45], [%310, %$75] ; # Y
  %300 = phi i64 [%294, %$45], [%314, %$75] ; # P
; # (let Sym (val 2 P) (xchg Sym P) (? (== $At Sym)) (setq P (val 3 P...
; # (val 2 P)
  %301 = inttoptr i64 %300 to i64*
  %302 = getelementptr i64, i64* %301, i32 1
  %303 = load i64, i64* %302
; # (xchg Sym P)
  %304 = inttoptr i64 %303 to i64*
  %305 = load i64, i64* %304
  %306 = inttoptr i64 %300 to i64*
  %307 = load i64, i64* %306
  store i64 %307, i64* %304
  store i64 %305, i64* %306
; # (? (== $At Sym))
; # (== $At Sym)
  %308 = icmp eq i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64), %303
  br i1 %308, label %$76, label %$75
$75:
  %309 = phi i64 [%298, %$74] ; # X
  %310 = phi i64 [%299, %$74] ; # Y
  %311 = phi i64 [%300, %$74] ; # P
; # (val 3 P)
  %312 = inttoptr i64 %311 to i64*
  %313 = getelementptr i64, i64* %312, i32 2
  %314 = load i64, i64* %313
  br label %$74
$76:
  %315 = phi i64 [%298, %$74] ; # X
  %316 = phi i64 [%299, %$74] ; # Y
  %317 = phi i64 [%300, %$74] ; # P
  %318 = phi i64 [0, %$74] ; # ->
; # (prog1 (run (cdr Exe)) (set $Next Next))
; # (cdr Exe)
  %319 = inttoptr i64 %0 to i64*
  %320 = getelementptr i64, i64* %319, i32 1
  %321 = load i64, i64* %320
; # (run (cdr Exe))
  br label %$77
$77:
  %322 = phi i64 [%321, %$76], [%344, %$86] ; # Prg
  %323 = inttoptr i64 %322 to i64*
  %324 = load i64, i64* %323
  %325 = getelementptr i64, i64* %323, i32 1
  %326 = load i64, i64* %325
  %327 = and i64 %326, 15
  %328 = icmp ne i64 %327, 0
  br i1 %328, label %$80, label %$78
$80:
  %329 = phi i64 [%326, %$77] ; # Prg
  %330 = and i64 %324, 6
  %331 = icmp ne i64 %330, 0
  br i1 %331, label %$83, label %$82
$83:
  br label %$81
$82:
  %332 = and i64 %324, 8
  %333 = icmp ne i64 %332, 0
  br i1 %333, label %$85, label %$84
$85:
  %334 = inttoptr i64 %324 to i64*
  %335 = load i64, i64* %334
  br label %$81
$84:
  %336 = call i64 @evList(i64 %324)
  br label %$81
$81:
  %337 = phi i64 [%324, %$83], [%335, %$85], [%336, %$84] ; # ->
  br label %$79
$78:
  %338 = phi i64 [%326, %$77] ; # Prg
  %339 = and i64 %324, 15
  %340 = icmp eq i64 %339, 0
  br i1 %340, label %$87, label %$86
$87:
  %341 = phi i64 [%338, %$78] ; # Prg
  %342 = call i64 @evList(i64 %324)
  %343 = icmp ne i64 %342, 0
  br label %$86
$86:
  %344 = phi i64 [%338, %$78], [%341, %$87] ; # Prg
  %345 = phi i1 [0, %$78], [%343, %$87] ; # ->
  br label %$77
$79:
  %346 = phi i64 [%329, %$81] ; # Prg
  %347 = phi i64 [%337, %$81] ; # ->
; # (set $Next Next)
  %348 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 128) to i64) to i64*
  store i64 %296, i64* %348
  br label %$46
$46:
  %349 = phi i64 [%252, %$65], [%315, %$79] ; # X
  %350 = phi i64 [%253, %$65], [%316, %$79] ; # Y
  %351 = phi i64 [%254, %$65], [%317, %$79] ; # P
  %352 = phi i64 [%285, %$65], [%347, %$79] ; # ->
  br label %$43
$42:
  %353 = phi i64 [%159, %$6] ; # X
  %354 = phi i64 [%160, %$6] ; # Y
  %355 = phi i64 [%161, %$6] ; # P
; # (unless (nil? Y) (needChkVar Exe Y) (set $Bind (push (val Y) Y P)...
; # (nil? Y)
  %356 = icmp eq i64 %354, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %356, label %$89, label %$88
$88:
  %357 = phi i64 [%353, %$42] ; # X
  %358 = phi i64 [%354, %$42] ; # Y
  %359 = phi i64 [%355, %$42] ; # P
; # (needChkVar Exe Y)
  %360 = and i64 %358, 6
  %361 = icmp ne i64 %360, 0
  br i1 %361, label %$90, label %$91
$90:
  call void @varErr(i64 %0, i64 %358)
  unreachable
$91:
  %362 = icmp uge i64 %358, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %362, label %$93, label %$92
$93:
  %363 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %358
  br label %$92
$92:
  %364 = phi i1 [0, %$91], [%363, %$93] ; # ->
  br i1 %364, label %$94, label %$95
$94:
  call void @protErr(i64 %0, i64 %358)
  unreachable
$95:
; # (set $Bind (push (val Y) Y P) Y X)
; # (val Y)
  %365 = inttoptr i64 %358 to i64*
  %366 = load i64, i64* %365
; # (push (val Y) Y P)
  %367 = alloca i64, i64 3, align 16
  %368 = ptrtoint i64* %367 to i64
  %369 = inttoptr i64 %368 to i64*
  store i64 %366, i64* %369
  %370 = add i64 %368, 8
  %371 = inttoptr i64 %370 to i64*
  store i64 %358, i64* %371
  %372 = add i64 %368, 16
  %373 = inttoptr i64 %372 to i64*
  store i64 %359, i64* %373
  %374 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %368, i64* %374
  %375 = inttoptr i64 %358 to i64*
  store i64 %357, i64* %375
  br label %$89
$89:
  %376 = phi i64 [%353, %$42], [%357, %$95] ; # X
  %377 = phi i64 [%354, %$42], [%358, %$95] ; # Y
  %378 = phi i64 [%355, %$42], [%359, %$95] ; # P
; # (loop (let Sym (val 2 P) (xchg Sym P) (? (== $At Sym)) (setq P (v...
  br label %$96
$96:
  %379 = phi i64 [%376, %$89], [%390, %$97] ; # X
  %380 = phi i64 [%377, %$89], [%391, %$97] ; # Y
  %381 = phi i64 [%378, %$89], [%395, %$97] ; # P
; # (let Sym (val 2 P) (xchg Sym P) (? (== $At Sym)) (setq P (val 3 P...
; # (val 2 P)
  %382 = inttoptr i64 %381 to i64*
  %383 = getelementptr i64, i64* %382, i32 1
  %384 = load i64, i64* %383
; # (xchg Sym P)
  %385 = inttoptr i64 %384 to i64*
  %386 = load i64, i64* %385
  %387 = inttoptr i64 %381 to i64*
  %388 = load i64, i64* %387
  store i64 %388, i64* %385
  store i64 %386, i64* %387
; # (? (== $At Sym))
; # (== $At Sym)
  %389 = icmp eq i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64), %384
  br i1 %389, label %$98, label %$97
$97:
  %390 = phi i64 [%379, %$96] ; # X
  %391 = phi i64 [%380, %$96] ; # Y
  %392 = phi i64 [%381, %$96] ; # P
; # (val 3 P)
  %393 = inttoptr i64 %392 to i64*
  %394 = getelementptr i64, i64* %393, i32 2
  %395 = load i64, i64* %394
  br label %$96
$98:
  %396 = phi i64 [%379, %$96] ; # X
  %397 = phi i64 [%380, %$96] ; # Y
  %398 = phi i64 [%381, %$96] ; # P
  %399 = phi i64 [0, %$96] ; # ->
; # (cdr Exe)
  %400 = inttoptr i64 %0 to i64*
  %401 = getelementptr i64, i64* %400, i32 1
  %402 = load i64, i64* %401
; # (run (cdr Exe))
  br label %$99
$99:
  %403 = phi i64 [%402, %$98], [%425, %$108] ; # Prg
  %404 = inttoptr i64 %403 to i64*
  %405 = load i64, i64* %404
  %406 = getelementptr i64, i64* %404, i32 1
  %407 = load i64, i64* %406
  %408 = and i64 %407, 15
  %409 = icmp ne i64 %408, 0
  br i1 %409, label %$102, label %$100
$102:
  %410 = phi i64 [%407, %$99] ; # Prg
  %411 = and i64 %405, 6
  %412 = icmp ne i64 %411, 0
  br i1 %412, label %$105, label %$104
$105:
  br label %$103
$104:
  %413 = and i64 %405, 8
  %414 = icmp ne i64 %413, 0
  br i1 %414, label %$107, label %$106
$107:
  %415 = inttoptr i64 %405 to i64*
  %416 = load i64, i64* %415
  br label %$103
$106:
  %417 = call i64 @evList(i64 %405)
  br label %$103
$103:
  %418 = phi i64 [%405, %$105], [%416, %$107], [%417, %$106] ; # ->
  br label %$101
$100:
  %419 = phi i64 [%407, %$99] ; # Prg
  %420 = and i64 %405, 15
  %421 = icmp eq i64 %420, 0
  br i1 %421, label %$109, label %$108
$109:
  %422 = phi i64 [%419, %$100] ; # Prg
  %423 = call i64 @evList(i64 %405)
  %424 = icmp ne i64 %423, 0
  br label %$108
$108:
  %425 = phi i64 [%419, %$100], [%422, %$109] ; # Prg
  %426 = phi i1 [0, %$100], [%424, %$109] ; # ->
  br label %$99
$101:
  %427 = phi i64 [%410, %$103] ; # Prg
  %428 = phi i64 [%418, %$103] ; # ->
  br label %$43
$43:
  %429 = phi i64 [%349, %$46], [%396, %$101] ; # X
  %430 = phi i64 [%350, %$46], [%397, %$101] ; # Y
  %431 = phi i64 [%351, %$46], [%398, %$101] ; # P
  %432 = phi i64 [%352, %$46], [%428, %$101] ; # ->
; # (val $Bind)
  %433 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  %434 = load i64, i64* %433
; # (loop (let Sym (val 2 P) (set Sym (val P)) (? (== $At Sym)) (setq...
  br label %$110
$110:
  %435 = phi i64 [%429, %$43], [%445, %$111] ; # X
  %436 = phi i64 [%430, %$43], [%446, %$111] ; # Y
  %437 = phi i64 [%434, %$43], [%450, %$111] ; # P
; # (let Sym (val 2 P) (set Sym (val P)) (? (== $At Sym)) (setq P (va...
; # (val 2 P)
  %438 = inttoptr i64 %437 to i64*
  %439 = getelementptr i64, i64* %438, i32 1
  %440 = load i64, i64* %439
; # (set Sym (val P))
; # (val P)
  %441 = inttoptr i64 %437 to i64*
  %442 = load i64, i64* %441
  %443 = inttoptr i64 %440 to i64*
  store i64 %442, i64* %443
; # (? (== $At Sym))
; # (== $At Sym)
  %444 = icmp eq i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64), %440
  br i1 %444, label %$112, label %$111
$111:
  %445 = phi i64 [%435, %$110] ; # X
  %446 = phi i64 [%436, %$110] ; # Y
  %447 = phi i64 [%437, %$110] ; # P
; # (val 3 P)
  %448 = inttoptr i64 %447 to i64*
  %449 = getelementptr i64, i64* %448, i32 2
  %450 = load i64, i64* %449
  br label %$110
$112:
  %451 = phi i64 [%435, %$110] ; # X
  %452 = phi i64 [%436, %$110] ; # Y
  %453 = phi i64 [%437, %$110] ; # P
  %454 = phi i64 [0, %$110] ; # ->
; # (set $Bind (val 3 P))
; # (val 3 P)
  %455 = inttoptr i64 %453 to i64*
  %456 = getelementptr i64, i64* %455, i32 2
  %457 = load i64, i64* %456
  %458 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %457, i64* %458
  ret i64 %432
}

define i64 @evList(i64) align 8 {
$1:
; # (let Fun (car Exe) (cond ((num? Fun) Exe) ((sym? Fun) (loop (sigC...
; # (car Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = load i64, i64* %1
; # (cond ((num? Fun) Exe) ((sym? Fun) (loop (sigChk Exe) (let V (val...
; # (num? Fun)
  %3 = and i64 %2, 6
  %4 = icmp ne i64 %3, 0
  br i1 %4, label %$4, label %$3
$4:
  %5 = phi i64 [%2, %$1] ; # Fun
  br label %$2
$3:
  %6 = phi i64 [%2, %$1] ; # Fun
; # (sym? Fun)
  %7 = and i64 %6, 8
  %8 = icmp ne i64 %7, 0
  br i1 %8, label %$6, label %$5
$6:
  %9 = phi i64 [%6, %$3] ; # Fun
; # (loop (sigChk Exe) (let V (val Fun) (? (num? V) (subr V Exe Fun))...
  br label %$7
$7:
  %10 = phi i64 [%9, %$6], [%14, %$15] ; # Fun
; # (sigChk Exe)
  %11 = load volatile i32, i32* bitcast ([16 x i32]* @$Signal to i32*)
  %12 = icmp ne i32 %11, 0
  br i1 %12, label %$8, label %$9
$8:
  call void @sighandler(i64 %0)
  br label %$9
$9:
; # (let V (val Fun) (? (num? V) (subr V Exe Fun)) (? (pair V) (evExp...
; # (val Fun)
  %13 = inttoptr i64 %10 to i64*
  %14 = load i64, i64* %13
; # (? (num? V) (subr V Exe Fun))
; # (num? V)
  %15 = and i64 %14, 6
  %16 = icmp ne i64 %15, 0
  br i1 %16, label %$12, label %$10
$12:
  %17 = phi i64 [%10, %$9] ; # Fun
; # (subr V Exe Fun)
  %18 = and i64 %14, -3
  %19 = inttoptr i64 %18 to i64(i64,i64)*
  %20 = call i64 %19(i64 %0,i64 %17)
  br label %$11
$10:
  %21 = phi i64 [%10, %$9] ; # Fun
; # (? (pair V) (evExpr V Exe))
; # (pair V)
  %22 = and i64 %14, 15
  %23 = icmp eq i64 %22, 0
  br i1 %23, label %$14, label %$13
$14:
  %24 = phi i64 [%21, %$10] ; # Fun
; # (evExpr V Exe)
  %25 = call i64 @evExpr(i64 %14, i64 %0)
  br label %$11
$13:
  %26 = phi i64 [%21, %$10] ; # Fun
; # (? (== V (val V)) (if (sharedLib Fun) (subr (val Fun) Exe Fun) (u...
; # (val V)
  %27 = inttoptr i64 %14 to i64*
  %28 = load i64, i64* %27
; # (== V (val V))
  %29 = icmp eq i64 %14, %28
  br i1 %29, label %$16, label %$15
$16:
  %30 = phi i64 [%26, %$13] ; # Fun
; # (if (sharedLib Fun) (subr (val Fun) Exe Fun) (undefined Fun Exe))...
; # (sharedLib Fun)
  %31 = call i1 @sharedLib(i64 %30)
  br i1 %31, label %$17, label %$18
$17:
  %32 = phi i64 [%30, %$16] ; # Fun
; # (val Fun)
  %33 = inttoptr i64 %32 to i64*
  %34 = load i64, i64* %33
; # (subr (val Fun) Exe Fun)
  %35 = and i64 %34, -3
  %36 = inttoptr i64 %35 to i64(i64,i64)*
  %37 = call i64 %36(i64 %0,i64 %32)
  br label %$19
$18:
  %38 = phi i64 [%30, %$16] ; # Fun
; # (undefined Fun Exe)
  call void @undefined(i64 %38, i64 %0)
  unreachable
$19:
  %39 = phi i64 [%32, %$17] ; # Fun
  %40 = phi i64 [%37, %$17] ; # ->
  br label %$11
$15:
  %41 = phi i64 [%26, %$13] ; # Fun
  br label %$7
$11:
  %42 = phi i64 [%17, %$12], [%24, %$14], [%39, %$19] ; # Fun
  %43 = phi i64 [%20, %$12], [%25, %$14], [%40, %$19] ; # ->
  br label %$2
$5:
  %44 = phi i64 [%6, %$3] ; # Fun
; # (stkChk Exe)
  %45 = load i8*, i8** @$StkLimit
  %46 = call i8* @llvm.stacksave()
  %47 = icmp ugt i8* %45, %46
  br i1 %47, label %$20, label %$21
$20:
  call void @stkErr(i64 %0)
  unreachable
$21:
; # (let F (save (evList Fun)) (loop (sigChk Exe) (? (num? F) (subr F...
; # (evList Fun)
  %48 = call i64 @evList(i64 %44)
; # (save (evList Fun))
  %49 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %50 = load i64, i64* %49
  %51 = alloca i64, i64 2, align 16
  %52 = ptrtoint i64* %51 to i64
  %53 = inttoptr i64 %52 to i64*
  store i64 %48, i64* %53
  %54 = add i64 %52, 8
  %55 = inttoptr i64 %54 to i64*
  store i64 %50, i64* %55
  %56 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %52, i64* %56
; # (loop (sigChk Exe) (? (num? F) (subr F Exe Fun)) (? (pair F) (evE...
  br label %$22
$22:
  %57 = phi i64 [%44, %$21], [%98, %$30] ; # Fun
  %58 = phi i64 [%48, %$21], [%78, %$30] ; # F
; # (sigChk Exe)
  %59 = load volatile i32, i32* bitcast ([16 x i32]* @$Signal to i32*)
  %60 = icmp ne i32 %59, 0
  br i1 %60, label %$23, label %$24
$23:
  call void @sighandler(i64 %0)
  br label %$24
$24:
; # (? (num? F) (subr F Exe Fun))
; # (num? F)
  %61 = and i64 %58, 6
  %62 = icmp ne i64 %61, 0
  br i1 %62, label %$27, label %$25
$27:
  %63 = phi i64 [%57, %$24] ; # Fun
  %64 = phi i64 [%58, %$24] ; # F
; # (subr F Exe Fun)
  %65 = and i64 %64, -3
  %66 = inttoptr i64 %65 to i64(i64,i64)*
  %67 = call i64 %66(i64 %0,i64 %63)
  br label %$26
$25:
  %68 = phi i64 [%57, %$24] ; # Fun
  %69 = phi i64 [%58, %$24] ; # F
; # (? (pair F) (evExpr F Exe))
; # (pair F)
  %70 = and i64 %69, 15
  %71 = icmp eq i64 %70, 0
  br i1 %71, label %$29, label %$28
$29:
  %72 = phi i64 [%68, %$25] ; # Fun
  %73 = phi i64 [%69, %$25] ; # F
; # (evExpr F Exe)
  %74 = call i64 @evExpr(i64 %73, i64 %0)
  br label %$26
$28:
  %75 = phi i64 [%68, %$25] ; # Fun
  %76 = phi i64 [%69, %$25] ; # F
; # (let V (val F) (? (== V (val V)) (if (sharedLib F) (subr (val F) ...
; # (val F)
  %77 = inttoptr i64 %76 to i64*
  %78 = load i64, i64* %77
; # (? (== V (val V)) (if (sharedLib F) (subr (val F) Exe F) (undefin...
; # (val V)
  %79 = inttoptr i64 %78 to i64*
  %80 = load i64, i64* %79
; # (== V (val V))
  %81 = icmp eq i64 %78, %80
  br i1 %81, label %$31, label %$30
$31:
  %82 = phi i64 [%75, %$28] ; # Fun
  %83 = phi i64 [%76, %$28] ; # F
; # (if (sharedLib F) (subr (val F) Exe F) (undefined F Exe))
; # (sharedLib F)
  %84 = call i1 @sharedLib(i64 %83)
  br i1 %84, label %$32, label %$33
$32:
  %85 = phi i64 [%82, %$31] ; # Fun
  %86 = phi i64 [%83, %$31] ; # F
; # (val F)
  %87 = inttoptr i64 %86 to i64*
  %88 = load i64, i64* %87
; # (subr (val F) Exe F)
  %89 = and i64 %88, -3
  %90 = inttoptr i64 %89 to i64(i64,i64)*
  %91 = call i64 %90(i64 %0,i64 %86)
  br label %$34
$33:
  %92 = phi i64 [%82, %$31] ; # Fun
  %93 = phi i64 [%83, %$31] ; # F
; # (undefined F Exe)
  call void @undefined(i64 %93, i64 %0)
  unreachable
$34:
  %94 = phi i64 [%85, %$32] ; # Fun
  %95 = phi i64 [%86, %$32] ; # F
  %96 = phi i64 [%91, %$32] ; # ->
  br label %$26
$30:
  %97 = phi i64 [%75, %$28] ; # Fun
  %98 = phi i64 [%76, %$28] ; # F
  br label %$22
$26:
  %99 = phi i64 [%63, %$27], [%72, %$29], [%94, %$34] ; # Fun
  %100 = phi i64 [%64, %$27], [%73, %$29], [%95, %$34] ; # F
  %101 = phi i64 [%67, %$27], [%74, %$29], [%96, %$34] ; # ->
; # (drop *Safe)
  %102 = inttoptr i64 %52 to i64*
  %103 = getelementptr i64, i64* %102, i32 1
  %104 = load i64, i64* %103
  %105 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %104, i64* %105
  br label %$2
$2:
  %106 = phi i64 [%5, %$4], [%42, %$11], [%99, %$26] ; # Fun
  %107 = phi i64 [%0, %$4], [%43, %$11], [%101, %$26] ; # ->
  ret i64 %107
}

define void @openErr(i64, i64) align 8 {
$1:
; # (strErrno)
  %2 = call i8* @strErrno()
; # (err Exe X ($ "Open error: %s") (strErrno))
  call void @err(i64 %0, i64 %1, i8* bitcast ([15 x i8]* @$30 to i8*), i8* %2)
  unreachable
}

define void @closeErr() align 8 {
$1:
; # (strErrno)
  %0 = call i8* @strErrno()
; # (err 0 0 ($ "Close error: %s") (strErrno))
  call void @err(i64 0, i64 0, i8* bitcast ([16 x i8]* @$31 to i8*), i8* %0)
  unreachable
}

define void @pipeErr(i64) align 8 {
$1:
; # (strErrno)
  %1 = call i8* @strErrno()
; # (err Exe 0 ($ "Pipe error: %s") (strErrno))
  call void @err(i64 %0, i64 0, i8* bitcast ([15 x i8]* @$32 to i8*), i8* %1)
  unreachable
}

define void @sizeErr(i64) align 8 {
$1:
; # (err Exe 0 ($ "Size overflow") null)
  call void @err(i64 %0, i64 0, i8* bitcast ([14 x i8]* @$33 to i8*), i8* null)
  unreachable
}

define void @eofErr() align 8 {
$1:
; # (err 0 0 ($ "EOF Overrun") null)
  call void @err(i64 0, i64 0, i8* bitcast ([12 x i8]* @$34 to i8*), i8* null)
  unreachable
}

define void @badInput() align 8 {
$1:
; # (let S (b8 2) (set S (i8 (val $Chr))) (set 2 S 0) (err 0 0 ($ "Ba...
; # (b8 2)
  %0 = alloca i8, i64 2
; # (set S (i8 (val $Chr)))
; # (val $Chr)
  %1 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
; # (i8 (val $Chr))
  %2 = trunc i32 %1 to i8
  store i8 %2, i8* %0
; # (set 2 S 0)
  %3 = getelementptr i8, i8* %0, i32 1
  store i8 0, i8* %3
; # (err 0 0 ($ "Bad input '%s'") S)
  call void @err(i64 0, i64 0, i8* bitcast ([15 x i8]* @$35 to i8*), i8* %0)
  unreachable
}

define void @badFd(i64, i64) align 8 {
$1:
; # (err Exe Fd ($ "Bad FD") null)
  call void @err(i64 %0, i64 %1, i8* bitcast ([7 x i8]* @$36 to i8*), i8* null)
  unreachable
}

define void @writeErr(i8*) align 8 {
$1:
; # (strErrno)
  %1 = call i8* @strErrno()
; # (err 0 0 Fmt (strErrno))
  call void @err(i64 0, i64 0, i8* %0, i8* %1)
  unreachable
}

define void @selectErr(i64) align 8 {
$1:
; # (strErrno)
  %1 = call i8* @strErrno()
; # (err Exe 0 ($ "Select error: %s") (strErrno))
  call void @err(i64 %0, i64 0, i8* bitcast ([17 x i8]* @$37 to i8*), i8* %1)
  unreachable
}

define void @closeOnExec(i64, i32) align 8 {
$1:
; # (when (lt0 (fcntlCloExec Fd)) (err Exe 0 ($ "SETFD %s") (strErrno...
; # (fcntlCloExec Fd)
  %2 = call i32 @fcntlCloExec(i32 %1)
; # (lt0 (fcntlCloExec Fd))
  %3 = icmp slt i32 %2, 0
  br i1 %3, label %$2, label %$3
$2:
; # (strErrno)
  %4 = call i8* @strErrno()
; # (err Exe 0 ($ "SETFD %s") (strErrno))
  call void @err(i64 %0, i64 0, i8* bitcast ([9 x i8]* @$38 to i8*), i8* %4)
  unreachable
$3:
  ret void
}

define void @rdLockWait(i32, i64) align 8 {
$1:
; # (while (lt0 (rdLock Fd 0 Len YES)) (unless (== (gErrno) EINTR) (l...
  br label %$2
$2:
; # (rdLock Fd 0 Len YES)
  %2 = call i32 @rdLock(i32 %0, i64 0, i64 %1, i1 1)
; # (lt0 (rdLock Fd 0 Len YES))
  %3 = icmp slt i32 %2, 0
  br i1 %3, label %$3, label %$4
$3:
; # (unless (== (gErrno) EINTR) (lockErr))
; # (gErrno)
  %4 = call i32 @gErrno()
; # (== (gErrno) EINTR)
  %5 = icmp eq i32 %4, 2
  br i1 %5, label %$6, label %$5
$5:
; # (lockErr)
  call void @lockErr()
  unreachable
$6:
  br label %$2
$4:
  ret void
}

define void @wrLockWait(i32, i64) align 8 {
$1:
; # (while (lt0 (wrLock Fd 0 Len YES)) (unless (== (gErrno) EINTR) (l...
  br label %$2
$2:
; # (wrLock Fd 0 Len YES)
  %2 = call i32 @wrLock(i32 %0, i64 0, i64 %1, i1 1)
; # (lt0 (wrLock Fd 0 Len YES))
  %3 = icmp slt i32 %2, 0
  br i1 %3, label %$3, label %$4
$3:
; # (unless (== (gErrno) EINTR) (lockErr))
; # (gErrno)
  %4 = call i32 @gErrno()
; # (== (gErrno) EINTR)
  %5 = icmp eq i32 %4, 2
  br i1 %5, label %$6, label %$5
$5:
; # (lockErr)
  call void @lockErr()
  unreachable
$6:
  br label %$2
$4:
  ret void
}

define i8* @initInFile(i32, i8*) align 8 {
$1:
; # (let I (val $InFDs) (when (>= Fd I) (let P (set $InFiles (i8** (a...
; # (val $InFDs)
  %2 = load i32, i32* @$InFDs
; # (when (>= Fd I) (let P (set $InFiles (i8** (alloc (i8* (val $InFi...
; # (>= Fd I)
  %3 = icmp sge i32 %0, %2
  br i1 %3, label %$2, label %$3
$2:
  %4 = phi i32 [%2, %$1] ; # I
; # (let P (set $InFiles (i8** (alloc (i8* (val $InFiles)) (* 8 (i64 ...
; # (set $InFiles (i8** (alloc (i8* (val $InFiles)) (* 8 (i64 (set $I...
; # (val $InFiles)
  %5 = load i8**, i8*** @$InFiles
; # (i8* (val $InFiles))
  %6 = bitcast i8** %5 to i8*
; # (set $InFDs (+ Fd 1))
; # (+ Fd 1)
  %7 = add i32 %0, 1
  store i32 %7, i32* @$InFDs
; # (i64 (set $InFDs (+ Fd 1)))
  %8 = sext i32 %7 to i64
; # (* 8 (i64 (set $InFDs (+ Fd 1))))
  %9 = mul i64 8, %8
; # (alloc (i8* (val $InFiles)) (* 8 (i64 (set $InFDs (+ Fd 1)))))
  %10 = call i8* @alloc(i8* %6, i64 %9)
; # (i8** (alloc (i8* (val $InFiles)) (* 8 (i64 (set $InFDs (+ Fd 1))...
  %11 = bitcast i8* %10 to i8**
  store i8** %11, i8*** @$InFiles
; # (loop (set (ofs P I) null) (? (== I Fd)) (inc 'I))
  br label %$4
$4:
  %12 = phi i32 [%4, %$2], [%16, %$5] ; # I
; # (set (ofs P I) null)
; # (ofs P I)
  %13 = getelementptr i8*, i8** %11, i32 %12
  store i8* null, i8** %13
; # (? (== I Fd))
; # (== I Fd)
  %14 = icmp eq i32 %12, %0
  br i1 %14, label %$6, label %$5
$5:
  %15 = phi i32 [%12, %$4] ; # I
; # (inc 'I)
  %16 = add i32 %15, 1
  br label %$4
$6:
  %17 = phi i32 [%12, %$4] ; # I
  %18 = phi i64 [0, %$4] ; # ->
  br label %$3
$3:
  %19 = phi i32 [%2, %$1], [%17, %$6] ; # I
; # (let In: (inFile (let P (ofs (val $InFiles) Fd) (if (val P) @ (se...
; # (let P (ofs (val $InFiles) Fd) (if (val P) @ (set P (alloc null (...
; # (val $InFiles)
  %20 = load i8**, i8*** @$InFiles
; # (ofs (val $InFiles) Fd)
  %21 = getelementptr i8*, i8** %20, i32 %0
; # (if (val P) @ (set P (alloc null (inFile T))))
; # (val P)
  %22 = load i8*, i8** %21
  %23 = icmp ne i8* %22, null
  br i1 %23, label %$7, label %$8
$7:
  br label %$9
$8:
; # (set P (alloc null (inFile T)))
; # (alloc null (inFile T))
  %24 = call i8* @alloc(i8* null, i64 4129)
  store i8* %24, i8** %21
  br label %$9
$9:
  %25 = phi i8* [%22, %$7], [%24, %$8] ; # ->
; # (In: name Nm)
  %26 = bitcast i8* %25 to i8**
  store i8* %1, i8** %26
; # (In: tty (n0 (isatty (In: fd Fd))))
  %27 = getelementptr i8, i8* %25, i32 4128
  %28 = bitcast i8* %27 to i1*
  %29 = getelementptr i8, i8* %25, i32 8
  %30 = bitcast i8* %29 to i32*
  store i32 %0, i32* %30
  %31 = call i32 @isatty(i32 %0)
  %32 = icmp ne i32 %31, 0
  store i1 %32, i1* %28
; # (In: chr 0)
  %33 = getelementptr i8, i8* %25, i32 12
  %34 = bitcast i8* %33 to i32*
  store i32 0, i32* %34
; # (In: line (In: src 1))
  %35 = getelementptr i8, i8* %25, i32 16
  %36 = bitcast i8* %35 to i32*
  %37 = getelementptr i8, i8* %25, i32 20
  %38 = bitcast i8* %37 to i32*
  store i32 1, i32* %38
  store i32 1, i32* %36
; # (In: ix (In: cnt 0))
  %39 = getelementptr i8, i8* %25, i32 24
  %40 = bitcast i8* %39 to i32*
  %41 = getelementptr i8, i8* %25, i32 28
  %42 = bitcast i8* %41 to i32*
  store i32 0, i32* %42
  store i32 0, i32* %40
; # (In:)
  ret i8* %25
}

define i8* @initOutFile(i32) align 8 {
$1:
; # (let I (val $OutFDs) (when (>= Fd I) (let P (set $OutFiles (i8** ...
; # (val $OutFDs)
  %1 = load i32, i32* @$OutFDs
; # (when (>= Fd I) (let P (set $OutFiles (i8** (alloc (i8* (val $Out...
; # (>= Fd I)
  %2 = icmp sge i32 %0, %1
  br i1 %2, label %$2, label %$3
$2:
  %3 = phi i32 [%1, %$1] ; # I
; # (let P (set $OutFiles (i8** (alloc (i8* (val $OutFiles)) (* 8 (i6...
; # (set $OutFiles (i8** (alloc (i8* (val $OutFiles)) (* 8 (i64 (set ...
; # (val $OutFiles)
  %4 = load i8**, i8*** @$OutFiles
; # (i8* (val $OutFiles))
  %5 = bitcast i8** %4 to i8*
; # (set $OutFDs (+ Fd 1))
; # (+ Fd 1)
  %6 = add i32 %0, 1
  store i32 %6, i32* @$OutFDs
; # (i64 (set $OutFDs (+ Fd 1)))
  %7 = sext i32 %6 to i64
; # (* 8 (i64 (set $OutFDs (+ Fd 1))))
  %8 = mul i64 8, %7
; # (alloc (i8* (val $OutFiles)) (* 8 (i64 (set $OutFDs (+ Fd 1)))))
  %9 = call i8* @alloc(i8* %5, i64 %8)
; # (i8** (alloc (i8* (val $OutFiles)) (* 8 (i64 (set $OutFDs (+ Fd 1...
  %10 = bitcast i8* %9 to i8**
  store i8** %10, i8*** @$OutFiles
; # (loop (set (ofs P I) null) (? (== I Fd)) (inc 'I))
  br label %$4
$4:
  %11 = phi i32 [%3, %$2], [%15, %$5] ; # I
; # (set (ofs P I) null)
; # (ofs P I)
  %12 = getelementptr i8*, i8** %10, i32 %11
  store i8* null, i8** %12
; # (? (== I Fd))
; # (== I Fd)
  %13 = icmp eq i32 %11, %0
  br i1 %13, label %$6, label %$5
$5:
  %14 = phi i32 [%11, %$4] ; # I
; # (inc 'I)
  %15 = add i32 %14, 1
  br label %$4
$6:
  %16 = phi i32 [%11, %$4] ; # I
  %17 = phi i64 [0, %$4] ; # ->
  br label %$3
$3:
  %18 = phi i32 [%1, %$1], [%16, %$6] ; # I
; # (let Out: (outFile (let P (ofs (val $OutFiles) Fd) (if (val P) @ ...
; # (let P (ofs (val $OutFiles) Fd) (if (val P) @ (set P (alloc null ...
; # (val $OutFiles)
  %19 = load i8**, i8*** @$OutFiles
; # (ofs (val $OutFiles) Fd)
  %20 = getelementptr i8*, i8** %19, i32 %0
; # (if (val P) @ (set P (alloc null (outFile T))))
; # (val P)
  %21 = load i8*, i8** %20
  %22 = icmp ne i8* %21, null
  br i1 %22, label %$7, label %$8
$7:
  br label %$9
$8:
; # (set P (alloc null (outFile T)))
; # (alloc null (outFile T))
  %23 = call i8* @alloc(i8* null, i64 4105)
  store i8* %23, i8** %20
  br label %$9
$9:
  %24 = phi i8* [%21, %$7], [%23, %$8] ; # ->
; # (Out: tty (n0 (isatty (Out: fd Fd))))
  %25 = getelementptr i8, i8* %24, i32 4104
  %26 = bitcast i8* %25 to i1*
  %27 = bitcast i8* %24 to i32*
  store i32 %0, i32* %27
  %28 = call i32 @isatty(i32 %0)
  %29 = icmp ne i32 %28, 0
  store i1 %29, i1* %26
; # (Out: ix 0)
  %30 = getelementptr i8, i8* %24, i32 4
  %31 = bitcast i8* %30 to i32*
  store i32 0, i32* %31
; # (Out:)
  ret i8* %24
}

define void @closeInFile(i32) align 8 {
$1:
; # (when (> (val $InFDs) Fd) (let P (ofs (val $InFiles) Fd) (when (v...
; # (val $InFDs)
  %1 = load i32, i32* @$InFDs
; # (> (val $InFDs) Fd)
  %2 = icmp sgt i32 %1, %0
  br i1 %2, label %$2, label %$3
$2:
; # (let P (ofs (val $InFiles) Fd) (when (val P) (let In: (inFile @) ...
; # (val $InFiles)
  %3 = load i8**, i8*** @$InFiles
; # (ofs (val $InFiles) Fd)
  %4 = getelementptr i8*, i8** %3, i32 %0
; # (when (val P) (let In: (inFile @) (free (In: name)) (In: name nul...
; # (val P)
  %5 = load i8*, i8** %4
  %6 = icmp ne i8* %5, null
  br i1 %6, label %$4, label %$5
$4:
; # (let In: (inFile @) (free (In: name)) (In: name null) (In: fd -1)...
; # (In: name)
  %7 = bitcast i8* %5 to i8**
  %8 = load i8*, i8** %7
; # (free (In: name))
  call void @free(i8* %8)
; # (In: name null)
  %9 = bitcast i8* %5 to i8**
  store i8* null, i8** %9
; # (In: fd -1)
  %10 = getelementptr i8, i8* %5, i32 8
  %11 = bitcast i8* %10 to i32*
  store i32 -1, i32* %11
  br label %$5
$5:
  br label %$3
$3:
  ret void
}

define void @closeOutFile(i32) align 8 {
$1:
; # (when (> (val $OutFDs) Fd) (let P (ofs (val $OutFiles) Fd) (when ...
; # (val $OutFDs)
  %1 = load i32, i32* @$OutFDs
; # (> (val $OutFDs) Fd)
  %2 = icmp sgt i32 %1, %0
  br i1 %2, label %$2, label %$3
$2:
; # (let P (ofs (val $OutFiles) Fd) (when (val P) ((outFile @) fd -1)...
; # (val $OutFiles)
  %3 = load i8**, i8*** @$OutFiles
; # (ofs (val $OutFiles) Fd)
  %4 = getelementptr i8*, i8** %3, i32 %0
; # (when (val P) ((outFile @) fd -1))
; # (val P)
  %5 = load i8*, i8** %4
  %6 = icmp ne i8* %5, null
  br i1 %6, label %$4, label %$5
$4:
; # ((outFile @) fd -1)
  %7 = bitcast i8* %5 to i32*
  store i32 -1, i32* %7
  br label %$5
$5:
  br label %$3
$3:
  ret void
}

define i32 @slow(i8*) align 8 {
$1:
; # (let In: (inFile In) (In: ix 0) (loop (? (ge0 (i32 (read (In: fd)...
; # (In: ix 0)
  %1 = getelementptr i8, i8* %0, i32 24
  %2 = bitcast i8* %1 to i32*
  store i32 0, i32* %2
; # (loop (? (ge0 (i32 (read (In: fd) (In: (buf)) BUFSIZ))) (In: cnt ...
  br label %$2
$2:
; # (? (ge0 (i32 (read (In: fd) (In: (buf)) BUFSIZ))) (In: cnt @))
; # (In: fd)
  %3 = getelementptr i8, i8* %0, i32 8
  %4 = bitcast i8* %3 to i32*
  %5 = load i32, i32* %4
; # (In: (buf))
  %6 = getelementptr i8, i8* %0, i32 32
; # (read (In: fd) (In: (buf)) BUFSIZ)
  %7 = call i64 @read(i32 %5, i8* %6, i64 4096)
; # (i32 (read (In: fd) (In: (buf)) BUFSIZ))
  %8 = trunc i64 %7 to i32
; # (ge0 (i32 (read (In: fd) (In: (buf)) BUFSIZ)))
  %9 = icmp sge i32 %8, 0
  br i1 %9, label %$5, label %$3
$5:
; # (In: cnt @)
  %10 = getelementptr i8, i8* %0, i32 28
  %11 = bitcast i8* %10 to i32*
  store i32 %8, i32* %11
  br label %$4
$3:
; # (? (<> (gErrno) EINTR) (In: cnt 0))
; # (gErrno)
  %12 = call i32 @gErrno()
; # (<> (gErrno) EINTR)
  %13 = icmp ne i32 %12, 2
  br i1 %13, label %$7, label %$6
$7:
; # (In: cnt 0)
  %14 = getelementptr i8, i8* %0, i32 28
  %15 = bitcast i8* %14 to i32*
  store i32 0, i32* %15
  br label %$4
$6:
; # (sigChk 0)
  %16 = load volatile i32, i32* bitcast ([16 x i32]* @$Signal to i32*)
  %17 = icmp ne i32 %16, 0
  br i1 %17, label %$8, label %$9
$8:
  call void @sighandler(i64 0)
  br label %$9
$9:
  br label %$2
$4:
  %18 = phi i32 [%8, %$5], [0, %$7] ; # ->
  ret i32 %18
}

define i32 @slowNb(i8*) align 8 {
$1:
; # (let In: (inFile In) (loop (let (Flg (nonBlocking (In: fd)) N (i3...
; # (loop (let (Flg (nonBlocking (In: fd)) N (i32 (read (In: fd) (In:...
  br label %$2
$2:
; # (let (Flg (nonBlocking (In: fd)) N (i32 (read (In: fd) (In: (buf)...
; # (In: fd)
  %1 = getelementptr i8, i8* %0, i32 8
  %2 = bitcast i8* %1 to i32*
  %3 = load i32, i32* %2
; # (nonBlocking (In: fd))
  %4 = call i32 @nonBlocking(i32 %3)
; # (In: fd)
  %5 = getelementptr i8, i8* %0, i32 8
  %6 = bitcast i8* %5 to i32*
  %7 = load i32, i32* %6
; # (In: (buf))
  %8 = getelementptr i8, i8* %0, i32 32
; # (read (In: fd) (In: (buf)) BUFSIZ)
  %9 = call i64 @read(i32 %7, i8* %8, i64 4096)
; # (i32 (read (In: fd) (In: (buf)) BUFSIZ))
  %10 = trunc i64 %9 to i32
; # (In: fd)
  %11 = getelementptr i8, i8* %0, i32 8
  %12 = bitcast i8* %11 to i32*
  %13 = load i32, i32* %12
; # (fcntlSetFl (In: fd) Flg)
  call void @fcntlSetFl(i32 %13, i32 %4)
; # (? (gt0 N) (In: ix 0) (In: cnt N))
; # (gt0 N)
  %14 = icmp sgt i32 %10, 0
  br i1 %14, label %$5, label %$3
$5:
; # (In: ix 0)
  %15 = getelementptr i8, i8* %0, i32 24
  %16 = bitcast i8* %15 to i32*
  store i32 0, i32* %16
; # (In: cnt N)
  %17 = getelementptr i8, i8* %0, i32 28
  %18 = bitcast i8* %17 to i32*
  store i32 %10, i32* %18
  br label %$4
$3:
; # (? (=0 N) (In: ix (In: cnt -1)) 0)
; # (=0 N)
  %19 = icmp eq i32 %10, 0
  br i1 %19, label %$7, label %$6
$7:
; # (In: ix (In: cnt -1))
  %20 = getelementptr i8, i8* %0, i32 24
  %21 = bitcast i8* %20 to i32*
  %22 = getelementptr i8, i8* %0, i32 28
  %23 = bitcast i8* %22 to i32*
  store i32 -1, i32* %23
  store i32 -1, i32* %21
  br label %$4
$6:
; # (? (== (gErrno) EAGAIN) -1)
; # (gErrno)
  %24 = call i32 @gErrno()
; # (== (gErrno) EAGAIN)
  %25 = icmp eq i32 %24, 4
  br i1 %25, label %$9, label %$8
$9:
  br label %$4
$8:
; # (? (<> @ EINTR) (In: ix (In: cnt 0)))
; # (<> @ EINTR)
  %26 = icmp ne i32 %24, 2
  br i1 %26, label %$11, label %$10
$11:
; # (In: ix (In: cnt 0))
  %27 = getelementptr i8, i8* %0, i32 24
  %28 = bitcast i8* %27 to i32*
  %29 = getelementptr i8, i8* %0, i32 28
  %30 = bitcast i8* %29 to i32*
  store i32 0, i32* %30
  store i32 0, i32* %28
  br label %$4
$10:
; # (sigChk 0)
  %31 = load volatile i32, i32* bitcast ([16 x i32]* @$Signal to i32*)
  %32 = icmp ne i32 %31, 0
  br i1 %32, label %$12, label %$13
$12:
  call void @sighandler(i64 0)
  br label %$13
$13:
  br label %$2
$4:
  %33 = phi i32 [%10, %$5], [0, %$7], [-1, %$9], [0, %$11] ; # ->
  ret i32 %33
}

define i1 @rdBytes(i32, i8*, i32) align 8 {
$1:
; # (loop (loop (? (gt0 (i32 (read Fd P (i64 Cnt)))) (inc 'P @) (dec ...
  br label %$2
$2:
  %3 = phi i8* [%1, %$1], [%37, %$13] ; # P
  %4 = phi i32 [%2, %$1], [%38, %$13] ; # Cnt
; # (loop (? (gt0 (i32 (read Fd P (i64 Cnt)))) (inc 'P @) (dec 'Cnt @...
  br label %$3
$3:
  %5 = phi i8* [%3, %$2], [%27, %$12] ; # P
  %6 = phi i32 [%4, %$2], [%28, %$12] ; # Cnt
; # (? (gt0 (i32 (read Fd P (i64 Cnt)))) (inc 'P @) (dec 'Cnt @))
; # (i64 Cnt)
  %7 = sext i32 %6 to i64
; # (read Fd P (i64 Cnt))
  %8 = call i64 @read(i32 %0, i8* %5, i64 %7)
; # (i32 (read Fd P (i64 Cnt)))
  %9 = trunc i64 %8 to i32
; # (gt0 (i32 (read Fd P (i64 Cnt))))
  %10 = icmp sgt i32 %9, 0
  br i1 %10, label %$6, label %$4
$6:
  %11 = phi i8* [%5, %$3] ; # P
  %12 = phi i32 [%6, %$3] ; # Cnt
; # (inc 'P @)
  %13 = getelementptr i8, i8* %11, i32 %9
; # (dec 'Cnt @)
  %14 = sub i32 %12, %9
  br label %$5
$4:
  %15 = phi i8* [%5, %$3] ; # P
  %16 = phi i32 [%6, %$3] ; # Cnt
; # (unless (and @ (== (gErrno) EINTR)) (ret NO))
; # (and @ (== (gErrno) EINTR))
  %17 = icmp ne i32 %9, 0
  br i1 %17, label %$8, label %$7
$8:
  %18 = phi i8* [%15, %$4] ; # P
  %19 = phi i32 [%16, %$4] ; # Cnt
; # (gErrno)
  %20 = call i32 @gErrno()
; # (== (gErrno) EINTR)
  %21 = icmp eq i32 %20, 2
  br label %$7
$7:
  %22 = phi i8* [%15, %$4], [%18, %$8] ; # P
  %23 = phi i32 [%16, %$4], [%19, %$8] ; # Cnt
  %24 = phi i1 [0, %$4], [%21, %$8] ; # ->
  br i1 %24, label %$10, label %$9
$9:
  %25 = phi i8* [%22, %$7] ; # P
  %26 = phi i32 [%23, %$7] ; # Cnt
; # (ret NO)
  ret i1 0
$10:
  %27 = phi i8* [%22, %$7] ; # P
  %28 = phi i32 [%23, %$7] ; # Cnt
; # (sigChk 0)
  %29 = load volatile i32, i32* bitcast ([16 x i32]* @$Signal to i32*)
  %30 = icmp ne i32 %29, 0
  br i1 %30, label %$11, label %$12
$11:
  call void @sighandler(i64 0)
  br label %$12
$12:
  br label %$3
$5:
  %31 = phi i8* [%13, %$6] ; # P
  %32 = phi i32 [%14, %$6] ; # Cnt
  %33 = phi i32 [%14, %$6] ; # ->
; # (? (=0 Cnt) YES)
; # (=0 Cnt)
  %34 = icmp eq i32 %32, 0
  br i1 %34, label %$15, label %$13
$15:
  %35 = phi i8* [%31, %$5] ; # P
  %36 = phi i32 [%32, %$5] ; # Cnt
  br label %$14
$13:
  %37 = phi i8* [%31, %$5] ; # P
  %38 = phi i32 [%32, %$5] ; # Cnt
  br label %$2
$14:
  %39 = phi i8* [%35, %$15] ; # P
  %40 = phi i32 [%36, %$15] ; # Cnt
  %41 = phi i1 [1, %$15] ; # ->
  ret i1 %41
}

define i64 @rdBytesNb(i32, i8*, i32) align 8 {
$1:
; # (loop (let (Flg (nonBlocking Fd) N (i32 (read Fd P (i64 Cnt)))) (...
  br label %$2
$2:
  %3 = phi i8* [%1, %$1], [%75, %$25] ; # P
  %4 = phi i32 [%2, %$1], [%76, %$25] ; # Cnt
; # (let (Flg (nonBlocking Fd) N (i32 (read Fd P (i64 Cnt)))) (fcntlS...
; # (nonBlocking Fd)
  %5 = call i32 @nonBlocking(i32 %0)
; # (i64 Cnt)
  %6 = sext i32 %4 to i64
; # (read Fd P (i64 Cnt))
  %7 = call i64 @read(i32 %0, i8* %3, i64 %6)
; # (i32 (read Fd P (i64 Cnt)))
  %8 = trunc i64 %7 to i32
; # (fcntlSetFl Fd Flg)
  call void @fcntlSetFl(i32 %0, i32 %5)
; # (when (gt0 N) (loop (unless (dec 'Cnt N) (ret 1)) (inc 'P N) (whi...
; # (gt0 N)
  %9 = icmp sgt i32 %8, 0
  br i1 %9, label %$3, label %$4
$3:
  %10 = phi i8* [%3, %$2] ; # P
  %11 = phi i32 [%4, %$2] ; # Cnt
  %12 = phi i32 [%8, %$2] ; # N
; # (loop (unless (dec 'Cnt N) (ret 1)) (inc 'P N) (while (le0 (setq ...
  br label %$5
$5:
  %13 = phi i8* [%10, %$3], [%53, %$10] ; # P
  %14 = phi i32 [%11, %$3], [%54, %$10] ; # Cnt
  %15 = phi i32 [%12, %$3], [%55, %$10] ; # N
; # (unless (dec 'Cnt N) (ret 1))
; # (dec 'Cnt N)
  %16 = sub i32 %14, %15
  %17 = icmp ne i32 %16, 0
  br i1 %17, label %$7, label %$6
$6:
  %18 = phi i8* [%13, %$5] ; # P
  %19 = phi i32 [%16, %$5] ; # Cnt
  %20 = phi i32 [%15, %$5] ; # N
; # (ret 1)
  ret i64 1
$7:
  %21 = phi i8* [%13, %$5] ; # P
  %22 = phi i32 [%16, %$5] ; # Cnt
  %23 = phi i32 [%15, %$5] ; # N
; # (inc 'P N)
  %24 = getelementptr i8, i8* %21, i32 %23
; # (while (le0 (setq N (i32 (read Fd P (i64 Cnt))))) (unless (and N ...
  br label %$8
$8:
  %25 = phi i8* [%24, %$7], [%48, %$16] ; # P
  %26 = phi i32 [%22, %$7], [%49, %$16] ; # Cnt
  %27 = phi i32 [%23, %$7], [%50, %$16] ; # N
; # (i64 Cnt)
  %28 = sext i32 %26 to i64
; # (read Fd P (i64 Cnt))
  %29 = call i64 @read(i32 %0, i8* %25, i64 %28)
; # (i32 (read Fd P (i64 Cnt)))
  %30 = trunc i64 %29 to i32
; # (le0 (setq N (i32 (read Fd P (i64 Cnt)))))
  %31 = icmp sle i32 %30, 0
  br i1 %31, label %$9, label %$10
$9:
  %32 = phi i8* [%25, %$8] ; # P
  %33 = phi i32 [%26, %$8] ; # Cnt
  %34 = phi i32 [%30, %$8] ; # N
; # (unless (and N (== (gErrno) EINTR)) (ret 0))
; # (and N (== (gErrno) EINTR))
  %35 = icmp ne i32 %34, 0
  br i1 %35, label %$12, label %$11
$12:
  %36 = phi i8* [%32, %$9] ; # P
  %37 = phi i32 [%33, %$9] ; # Cnt
  %38 = phi i32 [%34, %$9] ; # N
; # (gErrno)
  %39 = call i32 @gErrno()
; # (== (gErrno) EINTR)
  %40 = icmp eq i32 %39, 2
  br label %$11
$11:
  %41 = phi i8* [%32, %$9], [%36, %$12] ; # P
  %42 = phi i32 [%33, %$9], [%37, %$12] ; # Cnt
  %43 = phi i32 [%34, %$9], [%38, %$12] ; # N
  %44 = phi i1 [0, %$9], [%40, %$12] ; # ->
  br i1 %44, label %$14, label %$13
$13:
  %45 = phi i8* [%41, %$11] ; # P
  %46 = phi i32 [%42, %$11] ; # Cnt
  %47 = phi i32 [%43, %$11] ; # N
; # (ret 0)
  ret i64 0
$14:
  %48 = phi i8* [%41, %$11] ; # P
  %49 = phi i32 [%42, %$11] ; # Cnt
  %50 = phi i32 [%43, %$11] ; # N
; # (sigChk 0)
  %51 = load volatile i32, i32* bitcast ([16 x i32]* @$Signal to i32*)
  %52 = icmp ne i32 %51, 0
  br i1 %52, label %$15, label %$16
$15:
  call void @sighandler(i64 0)
  br label %$16
$16:
  br label %$8
$10:
  %53 = phi i8* [%25, %$8] ; # P
  %54 = phi i32 [%26, %$8] ; # Cnt
  %55 = phi i32 [%30, %$8] ; # N
  br label %$5
$4:
  %56 = phi i8* [%3, %$2] ; # P
  %57 = phi i32 [%4, %$2] ; # Cnt
  %58 = phi i32 [%8, %$2] ; # N
; # (? (=0 N) 0)
; # (=0 N)
  %59 = icmp eq i32 %58, 0
  br i1 %59, label %$19, label %$17
$19:
  %60 = phi i8* [%56, %$4] ; # P
  %61 = phi i32 [%57, %$4] ; # Cnt
  %62 = phi i32 [%58, %$4] ; # N
  br label %$18
$17:
  %63 = phi i8* [%56, %$4] ; # P
  %64 = phi i32 [%57, %$4] ; # Cnt
  %65 = phi i32 [%58, %$4] ; # N
; # (? (== (gErrno) EAGAIN) -1)
; # (gErrno)
  %66 = call i32 @gErrno()
; # (== (gErrno) EAGAIN)
  %67 = icmp eq i32 %66, 4
  br i1 %67, label %$21, label %$20
$21:
  %68 = phi i8* [%63, %$17] ; # P
  %69 = phi i32 [%64, %$17] ; # Cnt
  br label %$18
$20:
  %70 = phi i8* [%63, %$17] ; # P
  %71 = phi i32 [%64, %$17] ; # Cnt
; # (? (<> @ EINTR) 0)
; # (<> @ EINTR)
  %72 = icmp ne i32 %66, 2
  br i1 %72, label %$23, label %$22
$23:
  %73 = phi i8* [%70, %$20] ; # P
  %74 = phi i32 [%71, %$20] ; # Cnt
  br label %$18
$22:
  %75 = phi i8* [%70, %$20] ; # P
  %76 = phi i32 [%71, %$20] ; # Cnt
; # (sigChk 0)
  %77 = load volatile i32, i32* bitcast ([16 x i32]* @$Signal to i32*)
  %78 = icmp ne i32 %77, 0
  br i1 %78, label %$24, label %$25
$24:
  call void @sighandler(i64 0)
  br label %$25
$25:
  br label %$2
$18:
  %79 = phi i8* [%60, %$19], [%68, %$21], [%73, %$23] ; # P
  %80 = phi i32 [%61, %$19], [%69, %$21], [%74, %$23] ; # Cnt
  %81 = phi i64 [0, %$19], [-1, %$21], [0, %$23] ; # ->
  ret i64 %81
}

define i1 @wrBytes(i32, i8*, i32) align 8 {
$1:
; # (loop (? (lt0 Fd) NO) (let N (i32 (write Fd P (i64 Cnt))) (if (lt...
  br label %$2
$2:
  %3 = phi i8* [%1, %$1], [%53, %$8] ; # P
  %4 = phi i32 [%2, %$1], [%54, %$8] ; # Cnt
; # (? (lt0 Fd) NO)
; # (lt0 Fd)
  %5 = icmp slt i32 %0, 0
  br i1 %5, label %$5, label %$3
$5:
  %6 = phi i8* [%3, %$2] ; # P
  %7 = phi i32 [%4, %$2] ; # Cnt
  br label %$4
$3:
  %8 = phi i8* [%3, %$2] ; # P
  %9 = phi i32 [%4, %$2] ; # Cnt
; # (let N (i32 (write Fd P (i64 Cnt))) (if (lt0 N) (let E (gErrno) (...
; # (i64 Cnt)
  %10 = sext i32 %9 to i64
; # (write Fd P (i64 Cnt))
  %11 = call i64 @write(i32 %0, i8* %8, i64 %10)
; # (i32 (write Fd P (i64 Cnt)))
  %12 = trunc i64 %11 to i32
; # (if (lt0 N) (let E (gErrno) (? (== E EBADF) NO) (? (== E EPIPE) N...
; # (lt0 N)
  %13 = icmp slt i32 %12, 0
  br i1 %13, label %$6, label %$7
$6:
  %14 = phi i8* [%8, %$3] ; # P
  %15 = phi i32 [%9, %$3] ; # Cnt
; # (let E (gErrno) (? (== E EBADF) NO) (? (== E EPIPE) NO) (? (== E ...
; # (gErrno)
  %16 = call i32 @gErrno()
; # (? (== E EBADF) NO)
; # (== E EBADF)
  %17 = icmp eq i32 %16, 3
  br i1 %17, label %$10, label %$9
$10:
  %18 = phi i8* [%14, %$6] ; # P
  %19 = phi i32 [%15, %$6] ; # Cnt
  br label %$4
$9:
  %20 = phi i8* [%14, %$6] ; # P
  %21 = phi i32 [%15, %$6] ; # Cnt
; # (? (== E EPIPE) NO)
; # (== E EPIPE)
  %22 = icmp eq i32 %16, 6
  br i1 %22, label %$12, label %$11
$12:
  %23 = phi i8* [%20, %$9] ; # P
  %24 = phi i32 [%21, %$9] ; # Cnt
  br label %$4
$11:
  %25 = phi i8* [%20, %$9] ; # P
  %26 = phi i32 [%21, %$9] ; # Cnt
; # (? (== E ECONNRESET) NO)
; # (== E ECONNRESET)
  %27 = icmp eq i32 %16, 7
  br i1 %27, label %$14, label %$13
$14:
  %28 = phi i8* [%25, %$11] ; # P
  %29 = phi i32 [%26, %$11] ; # Cnt
  br label %$4
$13:
  %30 = phi i8* [%25, %$11] ; # P
  %31 = phi i32 [%26, %$11] ; # Cnt
; # (unless (== E EINTR) (when (== Fd 2) (bye 2)) (writeErr ($ "bytes...
; # (== E EINTR)
  %32 = icmp eq i32 %16, 2
  br i1 %32, label %$16, label %$15
$15:
  %33 = phi i8* [%30, %$13] ; # P
  %34 = phi i32 [%31, %$13] ; # Cnt
; # (when (== Fd 2) (bye 2))
; # (== Fd 2)
  %35 = icmp eq i32 %0, 2
  br i1 %35, label %$17, label %$18
$17:
  %36 = phi i8* [%33, %$15] ; # P
  %37 = phi i32 [%34, %$15] ; # Cnt
; # (bye 2)
  call void @bye(i32 2)
  unreachable
$18:
  %38 = phi i8* [%33, %$15] ; # P
  %39 = phi i32 [%34, %$15] ; # Cnt
; # (writeErr ($ "bytes write: %s"))
  call void @writeErr(i8* bitcast ([16 x i8]* @$39 to i8*))
  unreachable
$16:
  %40 = phi i8* [%30, %$13] ; # P
  %41 = phi i32 [%31, %$13] ; # Cnt
; # (sigChk 0)
  %42 = load volatile i32, i32* bitcast ([16 x i32]* @$Signal to i32*)
  %43 = icmp ne i32 %42, 0
  br i1 %43, label %$19, label %$20
$19:
  call void @sighandler(i64 0)
  br label %$20
$20:
  br label %$8
$7:
  %44 = phi i8* [%8, %$3] ; # P
  %45 = phi i32 [%9, %$3] ; # Cnt
; # (? (=0 (dec 'Cnt N)) YES)
; # (dec 'Cnt N)
  %46 = sub i32 %45, %12
; # (=0 (dec 'Cnt N))
  %47 = icmp eq i32 %46, 0
  br i1 %47, label %$22, label %$21
$22:
  %48 = phi i8* [%44, %$7] ; # P
  %49 = phi i32 [%46, %$7] ; # Cnt
  br label %$4
$21:
  %50 = phi i8* [%44, %$7] ; # P
  %51 = phi i32 [%46, %$7] ; # Cnt
; # (inc 'P N)
  %52 = getelementptr i8, i8* %50, i32 %12
  br label %$8
$8:
  %53 = phi i8* [%40, %$20], [%52, %$21] ; # P
  %54 = phi i32 [%41, %$20], [%51, %$21] ; # Cnt
  br label %$2
$4:
  %55 = phi i8* [%6, %$5], [%18, %$10], [%23, %$12], [%28, %$14], [%48, %$22] ; # P
  %56 = phi i32 [%7, %$5], [%19, %$10], [%24, %$12], [%29, %$14], [%49, %$22] ; # Cnt
  %57 = phi i1 [0, %$5], [0, %$10], [0, %$12], [0, %$14], [1, %$22] ; # ->
  ret i1 %57
}

define void @clsChild(i8*) align 8 {
$1:
; # (let Cld: (child Cld) (when (== (Cld: pid) (val $Talking)) (set $...
; # (when (== (Cld: pid) (val $Talking)) (set $Talking 0))
; # (Cld: pid)
  %1 = getelementptr i8, i8* %0, i32 16
  %2 = bitcast i8* %1 to i32*
  %3 = load i32, i32* %2
; # (val $Talking)
  %4 = load i32, i32* @$Talking
; # (== (Cld: pid) (val $Talking))
  %5 = icmp eq i32 %3, %4
  br i1 %5, label %$2, label %$3
$2:
; # (set $Talking 0)
  store i32 0, i32* @$Talking
  br label %$3
$3:
; # (Cld: pid 0)
  %6 = getelementptr i8, i8* %0, i32 16
  %7 = bitcast i8* %6 to i32*
  store i32 0, i32* %7
; # (Cld: hear)
  %8 = getelementptr i8, i8* %0, i32 20
  %9 = bitcast i8* %8 to i32*
  %10 = load i32, i32* %9
; # (close (Cld: hear))
  %11 = call i32 @close(i32 %10)
; # (Cld: tell)
  %12 = getelementptr i8, i8* %0, i32 24
  %13 = bitcast i8* %12 to i32*
  %14 = load i32, i32* %13
; # (close (Cld: tell))
  %15 = call i32 @close(i32 %14)
; # (Cld: buf)
  %16 = bitcast i8* %0 to i8**
  %17 = load i8*, i8** %16
; # (free (Cld: buf))
  call void @free(i8* %17)
  ret void
}

define void @wrChild(i8*, i8*, i32) align 8 {
$1:
; # (let (Cld: (child Cld) C (Cld: cnt)) (unless C (loop (let N (i32 ...
; # (Cld: cnt)
  %3 = getelementptr i8, i8* %0, i32 12
  %4 = bitcast i8* %3 to i32*
  %5 = load i32, i32* %4
; # (unless C (loop (let N (i32 (write (Cld: tell) P (i64 Cnt))) (if ...
  %6 = icmp ne i32 %5, 0
  br i1 %6, label %$3, label %$2
$2:
  %7 = phi i8* [%1, %$1] ; # P
  %8 = phi i32 [%2, %$1] ; # Cnt
; # (loop (let N (i32 (write (Cld: tell) P (i64 Cnt))) (if (lt0 N) (l...
  br label %$4
$4:
  %9 = phi i8* [%7, %$2], [%49, %$7] ; # P
  %10 = phi i32 [%8, %$2], [%50, %$7] ; # Cnt
; # (let N (i32 (write (Cld: tell) P (i64 Cnt))) (if (lt0 N) (let E (...
; # (Cld: tell)
  %11 = getelementptr i8, i8* %0, i32 24
  %12 = bitcast i8* %11 to i32*
  %13 = load i32, i32* %12
; # (i64 Cnt)
  %14 = sext i32 %10 to i64
; # (write (Cld: tell) P (i64 Cnt))
  %15 = call i64 @write(i32 %13, i8* %9, i64 %14)
; # (i32 (write (Cld: tell) P (i64 Cnt)))
  %16 = trunc i64 %15 to i32
; # (if (lt0 N) (let E (gErrno) (? (== E EAGAIN)) (when (or (== E EPI...
; # (lt0 N)
  %17 = icmp slt i32 %16, 0
  br i1 %17, label %$5, label %$6
$5:
  %18 = phi i8* [%9, %$4] ; # P
  %19 = phi i32 [%10, %$4] ; # Cnt
; # (let E (gErrno) (? (== E EAGAIN)) (when (or (== E EPIPE) (== E EC...
; # (gErrno)
  %20 = call i32 @gErrno()
; # (? (== E EAGAIN))
; # (== E EAGAIN)
  %21 = icmp eq i32 %20, 4
  br i1 %21, label %$9, label %$8
$8:
  %22 = phi i8* [%18, %$5] ; # P
  %23 = phi i32 [%19, %$5] ; # Cnt
; # (when (or (== E EPIPE) (== E ECONNRESET)) (clsChild Cld) (ret))
; # (or (== E EPIPE) (== E ECONNRESET))
; # (== E EPIPE)
  %24 = icmp eq i32 %20, 6
  br i1 %24, label %$10, label %$11
$11:
  %25 = phi i8* [%22, %$8] ; # P
  %26 = phi i32 [%23, %$8] ; # Cnt
; # (== E ECONNRESET)
  %27 = icmp eq i32 %20, 7
  br label %$10
$10:
  %28 = phi i8* [%22, %$8], [%25, %$11] ; # P
  %29 = phi i32 [%23, %$8], [%26, %$11] ; # Cnt
  %30 = phi i1 [1, %$8], [%27, %$11] ; # ->
  br i1 %30, label %$12, label %$13
$12:
  %31 = phi i8* [%28, %$10] ; # P
  %32 = phi i32 [%29, %$10] ; # Cnt
; # (clsChild Cld)
  call void @clsChild(i8* %0)
; # (ret)
  ret void
$13:
  %33 = phi i8* [%28, %$10] ; # P
  %34 = phi i32 [%29, %$10] ; # Cnt
; # (unless (== E EINTR) (writeErr ($ "child write: %s")))
; # (== E EINTR)
  %35 = icmp eq i32 %20, 2
  br i1 %35, label %$15, label %$14
$14:
  %36 = phi i8* [%33, %$13] ; # P
  %37 = phi i32 [%34, %$13] ; # Cnt
; # (writeErr ($ "child write: %s"))
  call void @writeErr(i8* bitcast ([16 x i8]* @$40 to i8*))
  unreachable
$15:
  %38 = phi i8* [%33, %$13] ; # P
  %39 = phi i32 [%34, %$13] ; # Cnt
  br label %$7
$6:
  %40 = phi i8* [%9, %$4] ; # P
  %41 = phi i32 [%10, %$4] ; # Cnt
; # (unless (dec 'Cnt N) (ret))
; # (dec 'Cnt N)
  %42 = sub i32 %41, %16
  %43 = icmp ne i32 %42, 0
  br i1 %43, label %$17, label %$16
$16:
  %44 = phi i8* [%40, %$6] ; # P
  %45 = phi i32 [%42, %$6] ; # Cnt
; # (ret)
  ret void
$17:
  %46 = phi i8* [%40, %$6] ; # P
  %47 = phi i32 [%42, %$6] ; # Cnt
; # (inc 'P N)
  %48 = getelementptr i8, i8* %46, i32 %16
  br label %$7
$7:
  %49 = phi i8* [%38, %$15], [%48, %$17] ; # P
  %50 = phi i32 [%39, %$15], [%47, %$17] ; # Cnt
  br label %$4
$9:
  %51 = phi i8* [%18, %$5] ; # P
  %52 = phi i32 [%19, %$5] ; # Cnt
  %53 = phi i64 [0, %$5] ; # ->
  br label %$3
$3:
  %54 = phi i8* [%1, %$1], [%51, %$9] ; # P
  %55 = phi i32 [%2, %$1], [%52, %$9] ; # Cnt
; # (let Siz (+ C Cnt 4) (when (> Siz (hex "3FFFFFFF")) (sizeErr 0)) ...
; # (+ C Cnt 4)
  %56 = add i32 %5, %55
  %57 = add i32 %56, 4
; # (when (> Siz (hex "3FFFFFFF")) (sizeErr 0))
; # (> Siz (hex "3FFFFFFF"))
  %58 = icmp sgt i32 %57, 1073741823
  br i1 %58, label %$18, label %$19
$18:
  %59 = phi i8* [%54, %$3] ; # P
  %60 = phi i32 [%55, %$3] ; # Cnt
; # (sizeErr 0)
  call void @sizeErr(i64 0)
  unreachable
$19:
  %61 = phi i8* [%54, %$3] ; # P
  %62 = phi i32 [%55, %$3] ; # Cnt
; # (let Q (ofs (Cld: buf (alloc (Cld: buf) (i64 Siz))) C) (set (i32*...
; # (Cld: buf (alloc (Cld: buf) (i64 Siz)))
  %63 = bitcast i8* %0 to i8**
  %64 = bitcast i8* %0 to i8**
  %65 = load i8*, i8** %64
  %66 = sext i32 %57 to i64
  %67 = call i8* @alloc(i8* %65, i64 %66)
  store i8* %67, i8** %63
; # (ofs (Cld: buf (alloc (Cld: buf) (i64 Siz))) C)
  %68 = getelementptr i8, i8* %67, i32 %5
; # (set (i32* Q) Cnt)
; # (i32* Q)
  %69 = bitcast i8* %68 to i32*
  store i32 %62, i32* %69
; # (ofs Q 4)
  %70 = getelementptr i8, i8* %68, i32 4
; # (i64 Cnt)
  %71 = sext i32 %62 to i64
; # (memcpy (ofs Q 4) P (i64 Cnt))
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* %70, i8* %61, i64 %71, i1 0)
; # (Cld: cnt Siz)
  %72 = getelementptr i8, i8* %0, i32 12
  %73 = bitcast i8* %72 to i32*
  store i32 %57, i32* %73
  ret void
}

define i1 @flush(i8*) align 8 {
$1:
; # (ifn Out YES (let Out: (outFile Out) (ifn (Out: ix) YES (Out: ix ...
  %1 = icmp ne i8* %0, null
  br i1 %1, label %$3, label %$2
$2:
  br label %$4
$3:
; # (let Out: (outFile Out) (ifn (Out: ix) YES (Out: ix 0) (wrBytes (...
; # (ifn (Out: ix) YES (Out: ix 0) (wrBytes (Out: fd) (Out: (buf)) @)...
; # (Out: ix)
  %2 = getelementptr i8, i8* %0, i32 4
  %3 = bitcast i8* %2 to i32*
  %4 = load i32, i32* %3
  %5 = icmp ne i32 %4, 0
  br i1 %5, label %$6, label %$5
$5:
  br label %$7
$6:
; # (Out: ix 0)
  %6 = getelementptr i8, i8* %0, i32 4
  %7 = bitcast i8* %6 to i32*
  store i32 0, i32* %7
; # (Out: fd)
  %8 = bitcast i8* %0 to i32*
  %9 = load i32, i32* %8
; # (Out: (buf))
  %10 = getelementptr i8, i8* %0, i32 8
; # (wrBytes (Out: fd) (Out: (buf)) @)
  %11 = call i1 @wrBytes(i32 %9, i8* %10, i32 %4)
  br label %$7
$7:
  %12 = phi i1 [1, %$5], [%11, %$6] ; # ->
  br label %$4
$4:
  %13 = phi i1 [1, %$2], [%12, %$7] ; # ->
  ret i1 %13
}

define void @flushAll() align 8 {
$1:
; # (let (A (val $OutFiles) N (val $OutFDs) I (i32 0)) (while (> N I)...
; # (val $OutFiles)
  %0 = load i8**, i8*** @$OutFiles
; # (val $OutFDs)
  %1 = load i32, i32* @$OutFDs
; # (i32 0)
; # (while (> N I) (flush (val (ofs A I))) (inc 'I))
  br label %$2
$2:
  %2 = phi i32 [0, %$1], [%8, %$3] ; # I
; # (> N I)
  %3 = icmp sgt i32 %1, %2
  br i1 %3, label %$3, label %$4
$3:
  %4 = phi i32 [%2, %$2] ; # I
; # (ofs A I)
  %5 = getelementptr i8*, i8** %0, i32 %4
; # (val (ofs A I))
  %6 = load i8*, i8** %5
; # (flush (val (ofs A I)))
  %7 = call i1 @flush(i8* %6)
; # (inc 'I)
  %8 = add i32 %4, 1
  br label %$2
$4:
  %9 = phi i32 [%2, %$2] ; # I
  ret void
}

define i32 @stdinByte() align 8 {
$1:
; # (let In: (inFile (val (val $InFiles))) (cond ((and (ge0 (In: fd))...
; # (val $InFiles)
  %0 = load i8**, i8*** @$InFiles
; # (val (val $InFiles))
  %1 = load i8*, i8** %0
; # (cond ((and (ge0 (In: fd)) (or (<> (In: ix) (In: cnt)) (and (ge0 ...
; # (and (ge0 (In: fd)) (or (<> (In: ix) (In: cnt)) (and (ge0 @) (slo...
; # (In: fd)
  %2 = getelementptr i8, i8* %1, i32 8
  %3 = bitcast i8* %2 to i32*
  %4 = load i32, i32* %3
; # (ge0 (In: fd))
  %5 = icmp sge i32 %4, 0
  br i1 %5, label %$4, label %$3
$4:
; # (or (<> (In: ix) (In: cnt)) (and (ge0 @) (slow (In:))))
; # (In: ix)
  %6 = getelementptr i8, i8* %1, i32 24
  %7 = bitcast i8* %6 to i32*
  %8 = load i32, i32* %7
; # (In: cnt)
  %9 = getelementptr i8, i8* %1, i32 28
  %10 = bitcast i8* %9 to i32*
  %11 = load i32, i32* %10
; # (<> (In: ix) (In: cnt))
  %12 = icmp ne i32 %8, %11
  br i1 %12, label %$5, label %$6
$6:
; # (and (ge0 @) (slow (In:)))
; # (ge0 @)
  %13 = icmp sge i32 %8, 0
  br i1 %13, label %$8, label %$7
$8:
; # (In:)
; # (slow (In:))
  %14 = call i32 @slow(i8* %1)
  %15 = icmp ne i32 %14, 0
  br label %$7
$7:
  %16 = phi i1 [0, %$6], [%15, %$8] ; # ->
  br label %$5
$5:
  %17 = phi i1 [1, %$4], [%16, %$7] ; # ->
  br label %$3
$3:
  %18 = phi i1 [0, %$1], [%17, %$5] ; # ->
  br i1 %18, label %$10, label %$9
$10:
; # (let I (In: ix) (In: ix (+ I 1)) (i32 (val (ofs (In: (buf)) I))))...
; # (In: ix)
  %19 = getelementptr i8, i8* %1, i32 24
  %20 = bitcast i8* %19 to i32*
  %21 = load i32, i32* %20
; # (In: ix (+ I 1))
  %22 = getelementptr i8, i8* %1, i32 24
  %23 = bitcast i8* %22 to i32*
  %24 = add i32 %21, 1
  store i32 %24, i32* %23
; # (In: (buf))
  %25 = getelementptr i8, i8* %1, i32 32
; # (ofs (In: (buf)) I)
  %26 = getelementptr i8, i8* %25, i32 %21
; # (val (ofs (In: (buf)) I))
  %27 = load i8, i8* %26
; # (i32 (val (ofs (In: (buf)) I)))
  %28 = zext i8 %27 to i32
  br label %$2
$9:
; # (In: tty)
  %29 = getelementptr i8, i8* %1, i32 4128
  %30 = bitcast i8* %29 to i1*
  %31 = load i1, i1* %30
  br i1 %31, label %$12, label %$11
$12:
; # (bye 0)
  call void @bye(i32 0)
  unreachable
$11:
  br label %$2
$2:
  %32 = phi i32 [%28, %$10], [-1, %$11] ; # ->
  ret i32 %32
}

define i32 @getBinary() align 8 {
$1:
; # (let (In: (inFile (val $InFile)) I (In: ix)) (when (== I (In: cnt...
; # (val $InFile)
  %0 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 72) to i8**)
; # (In: ix)
  %1 = getelementptr i8, i8* %0, i32 24
  %2 = bitcast i8* %1 to i32*
  %3 = load i32, i32* %2
; # (when (== I (In: cnt)) (when (or (lt0 I) (=0 (slow (In:)))) (ret ...
; # (In: cnt)
  %4 = getelementptr i8, i8* %0, i32 28
  %5 = bitcast i8* %4 to i32*
  %6 = load i32, i32* %5
; # (== I (In: cnt))
  %7 = icmp eq i32 %3, %6
  br i1 %7, label %$2, label %$3
$2:
  %8 = phi i32 [%3, %$1] ; # I
; # (when (or (lt0 I) (=0 (slow (In:)))) (ret -1))
; # (or (lt0 I) (=0 (slow (In:))))
; # (lt0 I)
  %9 = icmp slt i32 %8, 0
  br i1 %9, label %$4, label %$5
$5:
  %10 = phi i32 [%8, %$2] ; # I
; # (In:)
; # (slow (In:))
  %11 = call i32 @slow(i8* %0)
; # (=0 (slow (In:)))
  %12 = icmp eq i32 %11, 0
  br label %$4
$4:
  %13 = phi i32 [%8, %$2], [%10, %$5] ; # I
  %14 = phi i1 [1, %$2], [%12, %$5] ; # ->
  br i1 %14, label %$6, label %$7
$6:
  %15 = phi i32 [%13, %$4] ; # I
; # (ret -1)
  ret i32 -1
$7:
  %16 = phi i32 [%13, %$4] ; # I
  br label %$3
$3:
  %17 = phi i32 [%3, %$1], [0, %$7] ; # I
; # (In: ix (+ I 1))
  %18 = getelementptr i8, i8* %0, i32 24
  %19 = bitcast i8* %18 to i32*
  %20 = add i32 %17, 1
  store i32 %20, i32* %19
; # (In: (buf))
  %21 = getelementptr i8, i8* %0, i32 32
; # (ofs (In: (buf)) I)
  %22 = getelementptr i8, i8* %21, i32 %17
; # (val (ofs (In: (buf)) I))
  %23 = load i8, i8* %22
; # (i32 (val (ofs (In: (buf)) I)))
  %24 = zext i8 %23 to i32
  ret i32 %24
}

define i64 @binRead() align 8 {
$1:
; # (case (call $GetBin) (NIX $Nil) (BEG (ifn (binRead) 0 (let (X (co...
; # (call $GetBin)
  %0 = load i32()*, i32()** @$GetBin
  %1 = call i32 %0()
  switch i32 %1, label %$2 [
    i32 0, label %$4
    i32 1, label %$5
    i32 2, label %$6
    i32 3, label %$7
  ]
$4:
  br label %$3
$5:
; # (ifn (binRead) 0 (let (X (cons @ $Nil) R (save X)) (loop (? (=0 (...
; # (binRead)
  %2 = call i64 @binRead()
  %3 = icmp ne i64 %2, 0
  br i1 %3, label %$9, label %$8
$8:
  br label %$10
$9:
; # (let (X (cons @ $Nil) R (save X)) (loop (? (=0 (binRead)) @) (? (...
; # (cons @ $Nil)
  %4 = call i64 @cons(i64 %2, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (save X)
  %5 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %6 = load i64, i64* %5
  %7 = alloca i64, i64 2, align 16
  %8 = ptrtoint i64* %7 to i64
  %9 = inttoptr i64 %8 to i64*
  store i64 %4, i64* %9
  %10 = add i64 %8, 8
  %11 = inttoptr i64 %10 to i64*
  store i64 %6, i64* %11
  %12 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %8, i64* %12
; # (loop (? (=0 (binRead)) @) (? (== @ END) R) (? (== @ -ZERO) (ifn ...
  br label %$11
$11:
  %13 = phi i64 [%4, %$9], [%37, %$17] ; # X
; # (? (=0 (binRead)) @)
; # (binRead)
  %14 = call i64 @binRead()
; # (=0 (binRead))
  %15 = icmp eq i64 %14, 0
  br i1 %15, label %$14, label %$12
$14:
  %16 = phi i64 [%13, %$11] ; # X
  br label %$13
$12:
  %17 = phi i64 [%13, %$11] ; # X
; # (? (== @ END) R)
; # (== @ END)
  %18 = icmp eq i64 %14, 3
  br i1 %18, label %$16, label %$15
$16:
  %19 = phi i64 [%17, %$12] ; # X
  br label %$13
$15:
  %20 = phi i64 [%17, %$12] ; # X
; # (? (== @ -ZERO) (ifn (binRead) 0 (set 2 X (if (== @ END) R @)) R)...
; # (== @ -ZERO)
  %21 = icmp eq i64 %14, 10
  br i1 %21, label %$18, label %$17
$18:
  %22 = phi i64 [%20, %$15] ; # X
; # (ifn (binRead) 0 (set 2 X (if (== @ END) R @)) R)
; # (binRead)
  %23 = call i64 @binRead()
  %24 = icmp ne i64 %23, 0
  br i1 %24, label %$20, label %$19
$19:
  %25 = phi i64 [%22, %$18] ; # X
  br label %$21
$20:
  %26 = phi i64 [%22, %$18] ; # X
; # (set 2 X (if (== @ END) R @))
; # (if (== @ END) R @)
; # (== @ END)
  %27 = icmp eq i64 %23, 3
  br i1 %27, label %$22, label %$23
$22:
  %28 = phi i64 [%26, %$20] ; # X
  br label %$24
$23:
  %29 = phi i64 [%26, %$20] ; # X
  br label %$24
$24:
  %30 = phi i64 [%28, %$22], [%29, %$23] ; # X
  %31 = phi i64 [%4, %$22], [%23, %$23] ; # ->
  %32 = inttoptr i64 %26 to i64*
  %33 = getelementptr i64, i64* %32, i32 1
  store i64 %31, i64* %33
  br label %$21
$21:
  %34 = phi i64 [%25, %$19], [%30, %$24] ; # X
  %35 = phi i64 [0, %$19], [%4, %$24] ; # ->
  br label %$13
$17:
  %36 = phi i64 [%20, %$15] ; # X
; # (set 2 X (cons @ $Nil))
; # (cons @ $Nil)
  %37 = call i64 @cons(i64 %14, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %38 = inttoptr i64 %36 to i64*
  %39 = getelementptr i64, i64* %38, i32 1
  store i64 %37, i64* %39
  br label %$11
$13:
  %40 = phi i64 [%16, %$14], [%19, %$16], [%34, %$21] ; # X
  %41 = phi i64 [%14, %$14], [%4, %$16], [%35, %$21] ; # ->
; # (drop *Safe)
  %42 = inttoptr i64 %8 to i64*
  %43 = getelementptr i64, i64* %42, i32 1
  %44 = load i64, i64* %43
  %45 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %44, i64* %45
  br label %$10
$10:
  %46 = phi i64 [0, %$8], [%41, %$13] ; # ->
  br label %$3
$6:
  br label %$3
$7:
; # (i64 @)
  %47 = sext i32 %1 to i64
  br label %$3
$2:
; # (if (lt0 @) 0 (let (Tag (& @ 3) Cnt (shr @ 2) P (i64* (push NIL N...
; # (lt0 @)
  %48 = icmp slt i32 %1, 0
  br i1 %48, label %$25, label %$26
$25:
  br label %$27
$26:
; # (let (Tag (& @ 3) Cnt (shr @ 2) P (i64* (push NIL NIL ZERO NIL)) ...
; # (& @ 3)
  %49 = and i32 %1, 3
; # (shr @ 2)
  %50 = lshr i32 %1, 2
; # (push NIL NIL ZERO NIL)
  %51 = alloca i64, i64 4, align 16
  %52 = ptrtoint i64* %51 to i64
  %53 = add i64 %52, 16
  %54 = inttoptr i64 %53 to i64*
  store i64 2, i64* %54
; # (i64* (push NIL NIL ZERO NIL))
  %55 = inttoptr i64 %52 to i64*
; # (ofs P 2)
  %56 = getelementptr i64, i64* %55, i32 2
; # (link (ofs P 2))
  %57 = ptrtoint i64* %56 to i64
  %58 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %59 = load i64, i64* %58
  %60 = inttoptr i64 %57 to i64*
  %61 = getelementptr i64, i64* %60, i32 1
  store i64 %59, i64* %61
  %62 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %57, i64* %62
; # (cond ((== Tag NUMBER) (set P 3) (when (== Cnt 63) (loop (loop (w...
; # (== Tag NUMBER)
  %63 = icmp eq i32 %49, 0
  br i1 %63, label %$30, label %$29
$30:
  %64 = phi i32 [%50, %$26] ; # Cnt
; # (set P 3)
  store i64 3, i64* %55
; # (when (== Cnt 63) (loop (loop (when (lt0 (call $GetBin)) (: 1 (dr...
; # (== Cnt 63)
  %65 = icmp eq i32 %64, 63
  br i1 %65, label %$31, label %$32
$31:
  %66 = phi i32 [%64, %$30] ; # Cnt
; # (loop (loop (when (lt0 (call $GetBin)) (: 1 (drop Q) (ret 0))) (b...
  br label %$33
$33:
  %67 = phi i32 [%66, %$31], [%91, %$41] ; # Cnt
; # (loop (when (lt0 (call $GetBin)) (: 1 (drop Q) (ret 0))) (byteNum...
  br label %$34
$34:
  %68 = phi i32 [%67, %$33], [%82, %$37] ; # Cnt
; # (when (lt0 (call $GetBin)) (: 1 (drop Q) (ret 0)))
; # (call $GetBin)
  %69 = load i32()*, i32()** @$GetBin
  %70 = call i32 %69()
; # (lt0 (call $GetBin))
  %71 = icmp slt i32 %70, 0
  br i1 %71, label %$35, label %$36
$35:
  %72 = phi i32 [%68, %$34] ; # Cnt
; # (: 1 (drop Q) (ret 0))
  br label %$-1
$-1:
  %73 = phi i32 [%72, %$35], [%88, %$39], [%102, %$46], [%138, %$57], [%149, %$61], [%163, %$68] ; # Cnt
; # (drop Q)
  %74 = inttoptr i64 %57 to i64*
  %75 = getelementptr i64, i64* %74, i32 1
  %76 = load i64, i64* %75
  %77 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %76, i64* %77
; # (ret 0)
  ret i64 0
$36:
  %78 = phi i32 [%68, %$34] ; # Cnt
; # (i8 @)
  %79 = trunc i32 %70 to i8
; # (byteNum (i8 @) P)
  call void @byteNum(i8 %79, i64* %55)
; # (? (=0 (dec 'Cnt)))
; # (dec 'Cnt)
  %80 = sub i32 %78, 1
; # (=0 (dec 'Cnt))
  %81 = icmp eq i32 %80, 0
  br i1 %81, label %$38, label %$37
$37:
  %82 = phi i32 [%80, %$36] ; # Cnt
  br label %$34
$38:
  %83 = phi i32 [%80, %$36] ; # Cnt
  %84 = phi i64 [0, %$36] ; # ->
; # (when (lt0 (setq Cnt (call $GetBin))) (goto 1))
; # (call $GetBin)
  %85 = load i32()*, i32()** @$GetBin
  %86 = call i32 %85()
; # (lt0 (setq Cnt (call $GetBin)))
  %87 = icmp slt i32 %86, 0
  br i1 %87, label %$39, label %$40
$39:
  %88 = phi i32 [%86, %$38] ; # Cnt
; # (goto 1)
  br label %$-1
$40:
  %89 = phi i32 [%86, %$38] ; # Cnt
; # (? (<> Cnt 255))
; # (<> Cnt 255)
  %90 = icmp ne i32 %89, 255
  br i1 %90, label %$42, label %$41
$41:
  %91 = phi i32 [%89, %$40] ; # Cnt
  br label %$33
$42:
  %92 = phi i32 [%89, %$40] ; # Cnt
  %93 = phi i64 [0, %$40] ; # ->
; # (unless Cnt (goto 2))
  %94 = icmp ne i32 %92, 0
  br i1 %94, label %$44, label %$43
$43:
  %95 = phi i32 [%92, %$42] ; # Cnt
; # (goto 2)
  br label %$-2
$44:
  %96 = phi i32 [%92, %$42] ; # Cnt
  br label %$32
$32:
  %97 = phi i32 [%64, %$30], [%96, %$44] ; # Cnt
; # (loop (when (lt0 (call $GetBin)) (goto 1)) (byteNum (i8 @) P) (? ...
  br label %$45
$45:
  %98 = phi i32 [%97, %$32], [%107, %$48] ; # Cnt
; # (when (lt0 (call $GetBin)) (goto 1))
; # (call $GetBin)
  %99 = load i32()*, i32()** @$GetBin
  %100 = call i32 %99()
; # (lt0 (call $GetBin))
  %101 = icmp slt i32 %100, 0
  br i1 %101, label %$46, label %$47
$46:
  %102 = phi i32 [%98, %$45] ; # Cnt
; # (goto 1)
  br label %$-1
$47:
  %103 = phi i32 [%98, %$45] ; # Cnt
; # (i8 @)
  %104 = trunc i32 %100 to i8
; # (byteNum (i8 @) P)
  call void @byteNum(i8 %104, i64* %55)
; # (? (=0 (dec 'Cnt)))
; # (dec 'Cnt)
  %105 = sub i32 %103, 1
; # (=0 (dec 'Cnt))
  %106 = icmp eq i32 %105, 0
  br i1 %106, label %$49, label %$48
$48:
  %107 = phi i32 [%105, %$47] ; # Cnt
  br label %$45
$49:
  %108 = phi i32 [%105, %$47] ; # Cnt
  %109 = phi i64 [0, %$47] ; # ->
; # (: 2 (drop Q (if (cnt? (val Q)) @ (let S (& (val (dig @)) 1) (| (...
  br label %$-2
$-2:
  %110 = phi i32 [%95, %$43], [%108, %$49] ; # Cnt
; # (drop Q (if (cnt? (val Q)) @ (let S (& (val (dig @)) 1) (| (half ...
; # (if (cnt? (val Q)) @ (let S (& (val (dig @)) 1) (| (half @) (shl ...
; # (val Q)
  %111 = inttoptr i64 %57 to i64*
  %112 = load i64, i64* %111
; # (cnt? (val Q))
  %113 = and i64 %112, 2
  %114 = icmp ne i64 %113, 0
  br i1 %114, label %$50, label %$51
$50:
  %115 = phi i32 [%110, %$-2] ; # Cnt
  br label %$52
$51:
  %116 = phi i32 [%110, %$-2] ; # Cnt
; # (let S (& (val (dig @)) 1) (| (half @) (shl S 3)))
; # (dig @)
  %117 = add i64 %112, -4
; # (val (dig @))
  %118 = inttoptr i64 %117 to i64*
  %119 = load i64, i64* %118
; # (& (val (dig @)) 1)
  %120 = and i64 %119, 1
; # (half @)
  %121 = call i64 @half(i64 %112)
; # (shl S 3)
  %122 = shl i64 %120, 3
; # (| (half @) (shl S 3))
  %123 = or i64 %121, %122
  br label %$52
$52:
  %124 = phi i32 [%115, %$50], [%116, %$51] ; # Cnt
  %125 = phi i64 [%112, %$50], [%123, %$51] ; # ->
  %126 = inttoptr i64 %57 to i64*
  %127 = getelementptr i64, i64* %126, i32 1
  %128 = load i64, i64* %127
  %129 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %128, i64* %129
  br label %$28
$29:
  %130 = phi i32 [%50, %$26] ; # Cnt
; # (set P 4)
  store i64 4, i64* %55
; # (when (== Cnt 63) (loop (loop (when (lt0 (call $GetBin)) (goto 1)...
; # (== Cnt 63)
  %131 = icmp eq i32 %130, 63
  br i1 %131, label %$53, label %$54
$53:
  %132 = phi i32 [%130, %$29] ; # Cnt
; # (loop (loop (when (lt0 (call $GetBin)) (goto 1)) (byteSym (i8 @) ...
  br label %$55
$55:
  %133 = phi i32 [%132, %$53], [%152, %$63] ; # Cnt
; # (loop (when (lt0 (call $GetBin)) (goto 1)) (byteSym (i8 @) P) (? ...
  br label %$56
$56:
  %134 = phi i32 [%133, %$55], [%143, %$59] ; # Cnt
; # (when (lt0 (call $GetBin)) (goto 1))
; # (call $GetBin)
  %135 = load i32()*, i32()** @$GetBin
  %136 = call i32 %135()
; # (lt0 (call $GetBin))
  %137 = icmp slt i32 %136, 0
  br i1 %137, label %$57, label %$58
$57:
  %138 = phi i32 [%134, %$56] ; # Cnt
; # (goto 1)
  br label %$-1
$58:
  %139 = phi i32 [%134, %$56] ; # Cnt
; # (i8 @)
  %140 = trunc i32 %136 to i8
; # (byteSym (i8 @) P)
  call void @byteSym(i8 %140, i64* %55)
; # (? (=0 (dec 'Cnt)))
; # (dec 'Cnt)
  %141 = sub i32 %139, 1
; # (=0 (dec 'Cnt))
  %142 = icmp eq i32 %141, 0
  br i1 %142, label %$60, label %$59
$59:
  %143 = phi i32 [%141, %$58] ; # Cnt
  br label %$56
$60:
  %144 = phi i32 [%141, %$58] ; # Cnt
  %145 = phi i64 [0, %$58] ; # ->
; # (when (lt0 (setq Cnt (call $GetBin))) (goto 1))
; # (call $GetBin)
  %146 = load i32()*, i32()** @$GetBin
  %147 = call i32 %146()
; # (lt0 (setq Cnt (call $GetBin)))
  %148 = icmp slt i32 %147, 0
  br i1 %148, label %$61, label %$62
$61:
  %149 = phi i32 [%147, %$60] ; # Cnt
; # (goto 1)
  br label %$-1
$62:
  %150 = phi i32 [%147, %$60] ; # Cnt
; # (? (<> Cnt 255))
; # (<> Cnt 255)
  %151 = icmp ne i32 %150, 255
  br i1 %151, label %$64, label %$63
$63:
  %152 = phi i32 [%150, %$62] ; # Cnt
  br label %$55
$64:
  %153 = phi i32 [%150, %$62] ; # Cnt
  %154 = phi i64 [0, %$62] ; # ->
; # (unless Cnt (goto 3))
  %155 = icmp ne i32 %153, 0
  br i1 %155, label %$66, label %$65
$65:
  %156 = phi i32 [%153, %$64] ; # Cnt
; # (goto 3)
  br label %$-3
$66:
  %157 = phi i32 [%153, %$64] ; # Cnt
  br label %$54
$54:
  %158 = phi i32 [%130, %$29], [%157, %$66] ; # Cnt
; # (loop (when (lt0 (call $GetBin)) (goto 1)) (byteSym (i8 @) P) (? ...
  br label %$67
$67:
  %159 = phi i32 [%158, %$54], [%168, %$70] ; # Cnt
; # (when (lt0 (call $GetBin)) (goto 1))
; # (call $GetBin)
  %160 = load i32()*, i32()** @$GetBin
  %161 = call i32 %160()
; # (lt0 (call $GetBin))
  %162 = icmp slt i32 %161, 0
  br i1 %162, label %$68, label %$69
$68:
  %163 = phi i32 [%159, %$67] ; # Cnt
; # (goto 1)
  br label %$-1
$69:
  %164 = phi i32 [%159, %$67] ; # Cnt
; # (i8 @)
  %165 = trunc i32 %161 to i8
; # (byteSym (i8 @) P)
  call void @byteSym(i8 %165, i64* %55)
; # (? (=0 (dec 'Cnt)))
; # (dec 'Cnt)
  %166 = sub i32 %164, 1
; # (=0 (dec 'Cnt))
  %167 = icmp eq i32 %166, 0
  br i1 %167, label %$71, label %$70
$70:
  %168 = phi i32 [%166, %$69] ; # Cnt
  br label %$67
$71:
  %169 = phi i32 [%166, %$69] ; # Cnt
  %170 = phi i64 [0, %$69] ; # ->
; # (: 3 (drop Q (let Nm (val Q) (case Tag (TRANSIENT (consStr Nm)) (...
  br label %$-3
$-3:
  %171 = phi i32 [%156, %$65], [%169, %$71] ; # Cnt
; # (drop Q (let Nm (val Q) (case Tag (TRANSIENT (consStr Nm)) (INTER...
; # (let Nm (val Q) (case Tag (TRANSIENT (consStr Nm)) (INTERN (reque...
; # (val Q)
  %172 = inttoptr i64 %57 to i64*
  %173 = load i64, i64* %172
; # (case Tag (TRANSIENT (consStr Nm)) (INTERN (requestSym Nm)) (T (w...
  switch i32 %49, label %$72 [
    i32 2, label %$74
    i32 1, label %$75
  ]
$74:
  %174 = phi i32 [%171, %$-3] ; # Cnt
  %175 = phi i64 [%173, %$-3] ; # Nm
; # (consStr Nm)
  %176 = call i64 @consStr(i64 %175)
  br label %$73
$75:
  %177 = phi i32 [%171, %$-3] ; # Cnt
  %178 = phi i64 [%173, %$-3] ; # Nm
; # (requestSym Nm)
  %179 = call i64 @requestSym(i64 %178)
  br label %$73
$72:
  %180 = phi i32 [%171, %$-3] ; # Cnt
  %181 = phi i64 [%173, %$-3] ; # Nm
; # (when (val $Extn) (let N (shl (& (i64 (+ (objFile Nm) @)) (hex "F...
; # (val $Extn)
  %182 = load i32, i32* @$Extn
  %183 = icmp ne i32 %182, 0
  br i1 %183, label %$76, label %$77
$76:
  %184 = phi i32 [%180, %$72] ; # Cnt
  %185 = phi i64 [%181, %$72] ; # Nm
; # (let N (shl (& (i64 (+ (objFile Nm) @)) (hex "FFFF")) 24) (setq N...
; # (objFile Nm)
  %186 = call i32 @objFile(i64 %185)
; # (+ (objFile Nm) @)
  %187 = add i32 %186, %182
; # (i64 (+ (objFile Nm) @))
  %188 = sext i32 %187 to i64
; # (& (i64 (+ (objFile Nm) @)) (hex "FFFF"))
  %189 = and i64 %188, 65535
; # (shl (& (i64 (+ (objFile Nm) @)) (hex "FFFF")) 24)
  %190 = shl i64 %189, 24
; # (& Nm (hex "FFF00FFF00FFFFFF"))
  %191 = and i64 %185, 18442258061990035455
; # (shl N 12)
  %192 = shl i64 %190, 12
; # (| N (shl N 12))
  %193 = or i64 %190, %192
; # (& (| N (shl N 12)) (hex "000FF000FF000000"))
  %194 = and i64 %193, 4486011719516160
; # (| (& Nm (hex "FFF00FFF00FFFFFF")) (& (| N (shl N 12)) (hex "000F...
  %195 = or i64 %191, %194
  br label %$77
$77:
  %196 = phi i32 [%180, %$72], [%184, %$76] ; # Cnt
  %197 = phi i64 [%181, %$72], [%195, %$76] ; # Nm
; # (extern Nm)
  %198 = call i64 @extern(i64 %197)
  br label %$73
$73:
  %199 = phi i32 [%174, %$74], [%177, %$75], [%196, %$77] ; # Cnt
  %200 = phi i64 [%175, %$74], [%178, %$75], [%197, %$77] ; # Nm
  %201 = phi i64 [%176, %$74], [%179, %$75], [%198, %$77] ; # ->
  %202 = inttoptr i64 %57 to i64*
  %203 = getelementptr i64, i64* %202, i32 1
  %204 = load i64, i64* %203
  %205 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %204, i64* %205
  br label %$28
$28:
  %206 = phi i32 [%124, %$52], [%199, %$73] ; # Cnt
  %207 = phi i64 [%125, %$52], [%201, %$73] ; # ->
  br label %$27
$27:
  %208 = phi i64 [0, %$25], [%207, %$28] ; # ->
  br label %$3
$3:
  %209 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$4], [%46, %$10], [10, %$6], [%47, %$7], [%208, %$27] ; # ->
  ret i64 %209
}

define void @prCnt(i8, i64) align 8 {
$1:
; # (let N Num (while (setq N (shr N 8)) (inc 'Tag 4)))
; # (while (setq N (shr N 8)) (inc 'Tag 4))
  br label %$2
$2:
  %2 = phi i8 [%0, %$1], [%10, %$3] ; # Tag
  %3 = phi i64 [%1, %$1], [%8, %$3] ; # Num
  %4 = phi i64 [%1, %$1], [%9, %$3] ; # N
; # (shr N 8)
  %5 = lshr i64 %4, 8
  %6 = icmp ne i64 %5, 0
  br i1 %6, label %$3, label %$4
$3:
  %7 = phi i8 [%2, %$2] ; # Tag
  %8 = phi i64 [%3, %$2] ; # Num
  %9 = phi i64 [%5, %$2] ; # N
; # (inc 'Tag 4)
  %10 = add i8 %7, 4
  br label %$2
$4:
  %11 = phi i8 [%2, %$2] ; # Tag
  %12 = phi i64 [%3, %$2] ; # Num
  %13 = phi i64 [%5, %$2] ; # N
; # (call $PutBin Tag)
  %14 = load void(i8)*, void(i8)** @$PutBin
  call void %14(i8 %11)
; # (loop (call $PutBin (i8 Num)) (? (=0 (setq Num (shr Num 8)))))
  br label %$5
$5:
  %15 = phi i8 [%11, %$4], [%21, %$6] ; # Tag
  %16 = phi i64 [%12, %$4], [%22, %$6] ; # Num
; # (i8 Num)
  %17 = trunc i64 %16 to i8
; # (call $PutBin (i8 Num))
  %18 = load void(i8)*, void(i8)** @$PutBin
  call void %18(i8 %17)
; # (? (=0 (setq Num (shr Num 8))))
; # (shr Num 8)
  %19 = lshr i64 %16, 8
; # (=0 (setq Num (shr Num 8)))
  %20 = icmp eq i64 %19, 0
  br i1 %20, label %$7, label %$6
$6:
  %21 = phi i8 [%15, %$5] ; # Tag
  %22 = phi i64 [%19, %$5] ; # Num
  br label %$5
$7:
  %23 = phi i8 [%15, %$5] ; # Tag
  %24 = phi i64 [%19, %$5] ; # Num
  %25 = phi i64 [0, %$5] ; # ->
  ret void
}

define void @binPrint(i64) align 8 {
$1:
; # (cond ((cnt? X) (tailcall (prCnt (+ NUMBER 4) (shr X 3)))) ((big?...
; # (cnt? X)
  %1 = and i64 %0, 2
  %2 = icmp ne i64 %1, 0
  br i1 %2, label %$4, label %$3
$4:
  %3 = phi i64 [%0, %$1] ; # X
; # (+ NUMBER 4)
; # (shr X 3)
  %4 = lshr i64 %3, 3
; # (prCnt (+ NUMBER 4) (shr X 3))
  tail call void @prCnt(i8 4, i64 %4)
  br label %$2
$3:
  %5 = phi i64 [%0, %$1] ; # X
; # (big? X)
  %6 = and i64 %5, 4
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$6, label %$5
$6:
  %8 = phi i64 [%5, %$3] ; # X
; # (let (Y (pos X) Z Y N 8) (loop (let C (val (dig Z)) (? (cnt? (set...
; # (pos X)
  %9 = and i64 %8, -9
; # (loop (let C (val (dig Z)) (? (cnt? (setq Z (val (big Z)))) (setq...
  br label %$7
$7:
  %10 = phi i64 [%8, %$6], [%39, %$8] ; # X
  %11 = phi i64 [%9, %$6], [%40, %$8] ; # Y
  %12 = phi i64 [%9, %$6], [%41, %$8] ; # Z
  %13 = phi i64 [8, %$6], [%44, %$8] ; # N
; # (let C (val (dig Z)) (? (cnt? (setq Z (val (big Z)))) (setq Z (in...
; # (dig Z)
  %14 = add i64 %12, -4
; # (val (dig Z))
  %15 = inttoptr i64 %14 to i64*
  %16 = load i64, i64* %15
; # (? (cnt? (setq Z (val (big Z)))) (setq Z (int Z) C (add C C) Z (a...
; # (big Z)
  %17 = add i64 %12, 4
; # (val (big Z))
  %18 = inttoptr i64 %17 to i64*
  %19 = load i64, i64* %18
; # (cnt? (setq Z (val (big Z))))
  %20 = and i64 %19, 2
  %21 = icmp ne i64 %20, 0
  br i1 %21, label %$10, label %$8
$10:
  %22 = phi i64 [%10, %$7] ; # X
  %23 = phi i64 [%11, %$7] ; # Y
  %24 = phi i64 [%19, %$7] ; # Z
  %25 = phi i64 [%13, %$7] ; # N
  %26 = phi i64 [%16, %$7] ; # C
; # (int Z)
  %27 = lshr i64 %24, 4
; # (add C C)
  %28 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %26, i64 %26)
  %29 = extractvalue {i64, i1} %28, 1
  %30 = extractvalue {i64, i1} %28, 0
; # (add Z Z @@)
  %31 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %27, i64 %27)
  %32 = extractvalue {i64, i1} %31, 1
  %33 = extractvalue {i64, i1} %31, 0
  %34 = zext i1 %29 to i64
  %35 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %33, i64 %34)
  %36 = extractvalue {i64, i1} %35, 1
  %37 = or i1 %32, %36
  %38 = extractvalue {i64, i1} %35, 0
  br label %$9
$8:
  %39 = phi i64 [%10, %$7] ; # X
  %40 = phi i64 [%11, %$7] ; # Y
  %41 = phi i64 [%19, %$7] ; # Z
  %42 = phi i64 [%13, %$7] ; # N
  %43 = phi i64 [%16, %$7] ; # C
; # (inc 'N 8)
  %44 = add i64 %42, 8
  br label %$7
$9:
  %45 = phi i64 [%22, %$10] ; # X
  %46 = phi i64 [%23, %$10] ; # Y
  %47 = phi i64 [%38, %$10] ; # Z
  %48 = phi i64 [%25, %$10] ; # N
  %49 = phi i64 [%38, %$10] ; # ->
; # (when Z (loop (inc 'N) (? (=0 (setq Z (shr Z 8))))))
  %50 = icmp ne i64 %47, 0
  br i1 %50, label %$11, label %$12
$11:
  %51 = phi i64 [%45, %$9] ; # X
  %52 = phi i64 [%46, %$9] ; # Y
  %53 = phi i64 [%47, %$9] ; # Z
  %54 = phi i64 [%48, %$9] ; # N
; # (loop (inc 'N) (? (=0 (setq Z (shr Z 8)))))
  br label %$13
$13:
  %55 = phi i64 [%51, %$11], [%62, %$14] ; # X
  %56 = phi i64 [%52, %$11], [%63, %$14] ; # Y
  %57 = phi i64 [%53, %$11], [%64, %$14] ; # Z
  %58 = phi i64 [%54, %$11], [%65, %$14] ; # N
; # (inc 'N)
  %59 = add i64 %58, 1
; # (? (=0 (setq Z (shr Z 8))))
; # (shr Z 8)
  %60 = lshr i64 %57, 8
; # (=0 (setq Z (shr Z 8)))
  %61 = icmp eq i64 %60, 0
  br i1 %61, label %$15, label %$14
$14:
  %62 = phi i64 [%55, %$13] ; # X
  %63 = phi i64 [%56, %$13] ; # Y
  %64 = phi i64 [%60, %$13] ; # Z
  %65 = phi i64 [%59, %$13] ; # N
  br label %$13
$15:
  %66 = phi i64 [%55, %$13] ; # X
  %67 = phi i64 [%56, %$13] ; # Y
  %68 = phi i64 [%60, %$13] ; # Z
  %69 = phi i64 [%59, %$13] ; # N
  %70 = phi i64 [0, %$13] ; # ->
  br label %$12
$12:
  %71 = phi i64 [%45, %$9], [%66, %$15] ; # X
  %72 = phi i64 [%46, %$9], [%67, %$15] ; # Y
  %73 = phi i64 [%47, %$9], [%68, %$15] ; # Z
  %74 = phi i64 [%48, %$9], [%69, %$15] ; # N
; # (let (M (- N 63) D (val (dig Y))) (when (ge0 M) (setq N 63)) (set...
; # (- N 63)
  %75 = sub i64 %74, 63
; # (dig Y)
  %76 = add i64 %72, -4
; # (val (dig Y))
  %77 = inttoptr i64 %76 to i64*
  %78 = load i64, i64* %77
; # (when (ge0 M) (setq N 63))
; # (ge0 M)
  %79 = icmp sge i64 %75, 0
  br i1 %79, label %$16, label %$17
$16:
  %80 = phi i64 [%71, %$12] ; # X
  %81 = phi i64 [%72, %$12] ; # Y
  %82 = phi i64 [%73, %$12] ; # Z
  %83 = phi i64 [%74, %$12] ; # N
  %84 = phi i64 [%75, %$12] ; # M
  %85 = phi i64 [%78, %$12] ; # D
  br label %$17
$17:
  %86 = phi i64 [%71, %$12], [%80, %$16] ; # X
  %87 = phi i64 [%72, %$12], [%81, %$16] ; # Y
  %88 = phi i64 [%73, %$12], [%82, %$16] ; # Z
  %89 = phi i64 [%74, %$12], [63, %$16] ; # N
  %90 = phi i64 [%75, %$12], [%84, %$16] ; # M
  %91 = phi i64 [%78, %$12], [%85, %$16] ; # D
; # (big Y)
  %92 = add i64 %87, 4
; # (val (big Y))
  %93 = inttoptr i64 %92 to i64*
  %94 = load i64, i64* %93
; # (shr X X 4)
  %95 = call i64 @llvm.fshr.i64(i64 %86, i64 %86, i64 4)
; # (add X X)
  %96 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %95, i64 %95)
  %97 = extractvalue {i64, i1} %96, 1
  %98 = extractvalue {i64, i1} %96, 0
; # (add D D @@)
  %99 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %91, i64 %91)
  %100 = extractvalue {i64, i1} %99, 1
  %101 = extractvalue {i64, i1} %99, 0
  %102 = zext i1 %97 to i64
  %103 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %101, i64 %102)
  %104 = extractvalue {i64, i1} %103, 1
  %105 = or i1 %100, %104
  %106 = extractvalue {i64, i1} %103, 0
; # (shl N 2)
  %107 = shl i64 %89, 2
; # (i8 (shl N 2))
  %108 = trunc i64 %107 to i8
; # (call $PutBin (i8 (shl N 2)))
  %109 = load void(i8)*, void(i8)** @$PutBin
  call void %109(i8 %108)
; # (let (S @@ C 8) (loop (loop (call $PutBin (i8 D)) (if (dec 'C) (s...
; # (loop (loop (call $PutBin (i8 D)) (if (dec 'C) (setq D (shr D 8))...
  br label %$18
$18:
  %110 = phi i64 [%95, %$17], [%253, %$33] ; # X
  %111 = phi i64 [%94, %$17], [%254, %$33] ; # Y
  %112 = phi i64 [%88, %$17], [%255, %$33] ; # Z
  %113 = phi i64 [%89, %$17], [%256, %$33] ; # N
  %114 = phi i64 [%90, %$17], [%257, %$33] ; # M
  %115 = phi i64 [%106, %$17], [%258, %$33] ; # D
  %116 = phi i1 [%105, %$17], [%259, %$33] ; # S
  %117 = phi i64 [8, %$17], [%260, %$33] ; # C
; # (loop (call $PutBin (i8 D)) (if (dec 'C) (setq D (shr D 8)) (setq...
  br label %$19
$19:
  %118 = phi i64 [%110, %$18], [%199, %$26] ; # X
  %119 = phi i64 [%111, %$18], [%200, %$26] ; # Y
  %120 = phi i64 [%112, %$18], [%201, %$26] ; # Z
  %121 = phi i64 [%113, %$18], [%202, %$26] ; # N
  %122 = phi i64 [%114, %$18], [%203, %$26] ; # M
  %123 = phi i64 [%115, %$18], [%204, %$26] ; # D
  %124 = phi i1 [%116, %$18], [%205, %$26] ; # S
  %125 = phi i64 [%117, %$18], [%206, %$26] ; # C
; # (i8 D)
  %126 = trunc i64 %123 to i8
; # (call $PutBin (i8 D))
  %127 = load void(i8)*, void(i8)** @$PutBin
  call void %127(i8 %126)
; # (if (dec 'C) (setq D (shr D 8)) (setq C 8) (if (cnt? Y) (setq D (...
; # (dec 'C)
  %128 = sub i64 %125, 1
  %129 = icmp ne i64 %128, 0
  br i1 %129, label %$20, label %$21
$20:
  %130 = phi i64 [%118, %$19] ; # X
  %131 = phi i64 [%119, %$19] ; # Y
  %132 = phi i64 [%120, %$19] ; # Z
  %133 = phi i64 [%121, %$19] ; # N
  %134 = phi i64 [%122, %$19] ; # M
  %135 = phi i64 [%123, %$19] ; # D
  %136 = phi i1 [%124, %$19] ; # S
  %137 = phi i64 [%128, %$19] ; # C
; # (shr D 8)
  %138 = lshr i64 %135, 8
  br label %$22
$21:
  %139 = phi i64 [%118, %$19] ; # X
  %140 = phi i64 [%119, %$19] ; # Y
  %141 = phi i64 [%120, %$19] ; # Z
  %142 = phi i64 [%121, %$19] ; # N
  %143 = phi i64 [%122, %$19] ; # M
  %144 = phi i64 [%123, %$19] ; # D
  %145 = phi i1 [%124, %$19] ; # S
  %146 = phi i64 [%128, %$19] ; # C
; # (if (cnt? Y) (setq D (int Y)) (setq D (val (dig Y)) Y (val (big Y...
; # (cnt? Y)
  %147 = and i64 %140, 2
  %148 = icmp ne i64 %147, 0
  br i1 %148, label %$23, label %$24
$23:
  %149 = phi i64 [%139, %$21] ; # X
  %150 = phi i64 [%140, %$21] ; # Y
  %151 = phi i64 [%141, %$21] ; # Z
  %152 = phi i64 [%142, %$21] ; # N
  %153 = phi i64 [%143, %$21] ; # M
  %154 = phi i64 [%144, %$21] ; # D
  %155 = phi i1 [%145, %$21] ; # S
  %156 = phi i64 [8, %$21] ; # C
; # (int Y)
  %157 = lshr i64 %150, 4
  br label %$25
$24:
  %158 = phi i64 [%139, %$21] ; # X
  %159 = phi i64 [%140, %$21] ; # Y
  %160 = phi i64 [%141, %$21] ; # Z
  %161 = phi i64 [%142, %$21] ; # N
  %162 = phi i64 [%143, %$21] ; # M
  %163 = phi i64 [%144, %$21] ; # D
  %164 = phi i1 [%145, %$21] ; # S
  %165 = phi i64 [8, %$21] ; # C
; # (dig Y)
  %166 = add i64 %159, -4
; # (val (dig Y))
  %167 = inttoptr i64 %166 to i64*
  %168 = load i64, i64* %167
; # (big Y)
  %169 = add i64 %159, 4
; # (val (big Y))
  %170 = inttoptr i64 %169 to i64*
  %171 = load i64, i64* %170
  br label %$25
$25:
  %172 = phi i64 [%149, %$23], [%158, %$24] ; # X
  %173 = phi i64 [%150, %$23], [%171, %$24] ; # Y
  %174 = phi i64 [%151, %$23], [%160, %$24] ; # Z
  %175 = phi i64 [%152, %$23], [%161, %$24] ; # N
  %176 = phi i64 [%153, %$23], [%162, %$24] ; # M
  %177 = phi i64 [%157, %$23], [%168, %$24] ; # D
  %178 = phi i1 [%155, %$23], [%164, %$24] ; # S
  %179 = phi i64 [%156, %$23], [%165, %$24] ; # C
  %180 = phi i64 [%157, %$23], [%171, %$24] ; # ->
; # (add D D S)
  %181 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %177, i64 %177)
  %182 = extractvalue {i64, i1} %181, 1
  %183 = extractvalue {i64, i1} %181, 0
  %184 = zext i1 %178 to i64
  %185 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %183, i64 %184)
  %186 = extractvalue {i64, i1} %185, 1
  %187 = or i1 %182, %186
  %188 = extractvalue {i64, i1} %185, 0
  br label %$22
$22:
  %189 = phi i64 [%130, %$20], [%172, %$25] ; # X
  %190 = phi i64 [%131, %$20], [%173, %$25] ; # Y
  %191 = phi i64 [%132, %$20], [%174, %$25] ; # Z
  %192 = phi i64 [%133, %$20], [%175, %$25] ; # N
  %193 = phi i64 [%134, %$20], [%176, %$25] ; # M
  %194 = phi i64 [%138, %$20], [%188, %$25] ; # D
  %195 = phi i1 [%136, %$20], [%187, %$25] ; # S
  %196 = phi i64 [%137, %$20], [%179, %$25] ; # C
; # (? (=0 (dec 'N)))
; # (dec 'N)
  %197 = sub i64 %192, 1
; # (=0 (dec 'N))
  %198 = icmp eq i64 %197, 0
  br i1 %198, label %$27, label %$26
$26:
  %199 = phi i64 [%189, %$22] ; # X
  %200 = phi i64 [%190, %$22] ; # Y
  %201 = phi i64 [%191, %$22] ; # Z
  %202 = phi i64 [%197, %$22] ; # N
  %203 = phi i64 [%193, %$22] ; # M
  %204 = phi i64 [%194, %$22] ; # D
  %205 = phi i1 [%195, %$22] ; # S
  %206 = phi i64 [%196, %$22] ; # C
  br label %$19
$27:
  %207 = phi i64 [%189, %$22] ; # X
  %208 = phi i64 [%190, %$22] ; # Y
  %209 = phi i64 [%191, %$22] ; # Z
  %210 = phi i64 [%197, %$22] ; # N
  %211 = phi i64 [%193, %$22] ; # M
  %212 = phi i64 [%194, %$22] ; # D
  %213 = phi i1 [%195, %$22] ; # S
  %214 = phi i64 [%196, %$22] ; # C
  %215 = phi i64 [0, %$22] ; # ->
; # (? (lt0 M))
; # (lt0 M)
  %216 = icmp slt i64 %211, 0
  br i1 %216, label %$29, label %$28
$28:
  %217 = phi i64 [%207, %$27] ; # X
  %218 = phi i64 [%208, %$27] ; # Y
  %219 = phi i64 [%209, %$27] ; # Z
  %220 = phi i64 [%210, %$27] ; # N
  %221 = phi i64 [%211, %$27] ; # M
  %222 = phi i64 [%212, %$27] ; # D
  %223 = phi i1 [%213, %$27] ; # S
  %224 = phi i64 [%214, %$27] ; # C
; # (? (=0 M) (call $PutBin 0))
; # (=0 M)
  %225 = icmp eq i64 %221, 0
  br i1 %225, label %$31, label %$30
$31:
  %226 = phi i64 [%217, %$28] ; # X
  %227 = phi i64 [%218, %$28] ; # Y
  %228 = phi i64 [%219, %$28] ; # Z
  %229 = phi i64 [%220, %$28] ; # N
  %230 = phi i64 [%221, %$28] ; # M
  %231 = phi i64 [%222, %$28] ; # D
  %232 = phi i1 [%223, %$28] ; # S
  %233 = phi i64 [%224, %$28] ; # C
; # (call $PutBin 0)
  %234 = load void(i8)*, void(i8)** @$PutBin
  call void %234(i8 0)
  br label %$29
$30:
  %235 = phi i64 [%217, %$28] ; # X
  %236 = phi i64 [%218, %$28] ; # Y
  %237 = phi i64 [%219, %$28] ; # Z
  %238 = phi i64 [%220, %$28] ; # N
  %239 = phi i64 [%221, %$28] ; # M
  %240 = phi i64 [%222, %$28] ; # D
  %241 = phi i1 [%223, %$28] ; # S
  %242 = phi i64 [%224, %$28] ; # C
; # (when (ge0 (setq M (- (setq N M) 255))) (setq N 255))
; # (- (setq N M) 255)
  %243 = sub i64 %239, 255
; # (ge0 (setq M (- (setq N M) 255)))
  %244 = icmp sge i64 %243, 0
  br i1 %244, label %$32, label %$33
$32:
  %245 = phi i64 [%235, %$30] ; # X
  %246 = phi i64 [%236, %$30] ; # Y
  %247 = phi i64 [%237, %$30] ; # Z
  %248 = phi i64 [%239, %$30] ; # N
  %249 = phi i64 [%243, %$30] ; # M
  %250 = phi i64 [%240, %$30] ; # D
  %251 = phi i1 [%241, %$30] ; # S
  %252 = phi i64 [%242, %$30] ; # C
  br label %$33
$33:
  %253 = phi i64 [%235, %$30], [%245, %$32] ; # X
  %254 = phi i64 [%236, %$30], [%246, %$32] ; # Y
  %255 = phi i64 [%237, %$30], [%247, %$32] ; # Z
  %256 = phi i64 [%239, %$30], [255, %$32] ; # N
  %257 = phi i64 [%243, %$30], [%249, %$32] ; # M
  %258 = phi i64 [%240, %$30], [%250, %$32] ; # D
  %259 = phi i1 [%241, %$30], [%251, %$32] ; # S
  %260 = phi i64 [%242, %$30], [%252, %$32] ; # C
; # (i8 N)
  %261 = trunc i64 %256 to i8
; # (call $PutBin (i8 N))
  %262 = load void(i8)*, void(i8)** @$PutBin
  call void %262(i8 %261)
  br label %$18
$29:
  %263 = phi i64 [%207, %$27], [%226, %$31] ; # X
  %264 = phi i64 [%208, %$27], [%227, %$31] ; # Y
  %265 = phi i64 [%209, %$27], [%228, %$31] ; # Z
  %266 = phi i64 [%210, %$27], [%229, %$31] ; # N
  %267 = phi i64 [%211, %$27], [%230, %$31] ; # M
  %268 = phi i64 [%212, %$27], [%231, %$31] ; # D
  %269 = phi i1 [%213, %$27], [%232, %$31] ; # S
  %270 = phi i64 [%214, %$27], [%233, %$31] ; # C
  br label %$2
$5:
  %271 = phi i64 [%5, %$3] ; # X
; # (nil? X)
  %272 = icmp eq i64 %271, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %272, label %$35, label %$34
$35:
  %273 = phi i64 [%271, %$5] ; # X
; # (call $PutBin NIX)
  %274 = load void(i8)*, void(i8)** @$PutBin
  call void %274(i8 0)
  br label %$2
$34:
  %275 = phi i64 [%271, %$5] ; # X
; # (pair X)
  %276 = and i64 %275, 15
  %277 = icmp eq i64 %276, 0
  br i1 %277, label %$37, label %$36
$37:
  %278 = phi i64 [%275, %$34] ; # X
; # (call $PutBin BEG)
  %279 = load void(i8)*, void(i8)** @$PutBin
  call void %279(i8 1)
; # (let (P (circ X) Z X) (loop (binPrint (car X)) (? (nil? (shift X)...
; # (circ X)
  %280 = call i64 @circ(i64 %278)
; # (loop (binPrint (car X)) (? (nil? (shift X)) (call $PutBin END)) ...
  br label %$38
$38:
  %281 = phi i64 [%278, %$37], [%313, %$47] ; # X
  %282 = phi i64 [%278, %$37], [%314, %$47] ; # Z
; # (car X)
  %283 = inttoptr i64 %281 to i64*
  %284 = load i64, i64* %283
; # (binPrint (car X))
  call void @binPrint(i64 %284)
; # (? (nil? (shift X)) (call $PutBin END))
; # (shift X)
  %285 = inttoptr i64 %281 to i64*
  %286 = getelementptr i64, i64* %285, i32 1
  %287 = load i64, i64* %286
; # (nil? (shift X))
  %288 = icmp eq i64 %287, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %288, label %$41, label %$39
$41:
  %289 = phi i64 [%287, %$38] ; # X
  %290 = phi i64 [%282, %$38] ; # Z
; # (call $PutBin END)
  %291 = load void(i8)*, void(i8)** @$PutBin
  call void %291(i8 3)
  br label %$40
$39:
  %292 = phi i64 [%287, %$38] ; # X
  %293 = phi i64 [%282, %$38] ; # Z
; # (? (atom X) (call $PutBin DOT) (binPrint X))
; # (atom X)
  %294 = and i64 %292, 15
  %295 = icmp ne i64 %294, 0
  br i1 %295, label %$43, label %$42
$43:
  %296 = phi i64 [%292, %$39] ; # X
  %297 = phi i64 [%293, %$39] ; # Z
; # (call $PutBin DOT)
  %298 = load void(i8)*, void(i8)** @$PutBin
  call void %298(i8 2)
; # (binPrint X)
  call void @binPrint(i64 %296)
  br label %$40
$42:
  %299 = phi i64 [%292, %$39] ; # X
  %300 = phi i64 [%293, %$39] ; # Z
; # (? (== Z X) (call $PutBin DOT) (call $PutBin END))
; # (== Z X)
  %301 = icmp eq i64 %300, %299
  br i1 %301, label %$45, label %$44
$45:
  %302 = phi i64 [%299, %$42] ; # X
  %303 = phi i64 [%300, %$42] ; # Z
; # (call $PutBin DOT)
  %304 = load void(i8)*, void(i8)** @$PutBin
  call void %304(i8 2)
; # (call $PutBin END)
  %305 = load void(i8)*, void(i8)** @$PutBin
  call void %305(i8 3)
  br label %$40
$44:
  %306 = phi i64 [%299, %$42] ; # X
  %307 = phi i64 [%300, %$42] ; # Z
; # (when (== P X) (call $PutBin DOT) (call $PutBin BEG) (setq Z P))
; # (== P X)
  %308 = icmp eq i64 %280, %306
  br i1 %308, label %$46, label %$47
$46:
  %309 = phi i64 [%306, %$44] ; # X
  %310 = phi i64 [%307, %$44] ; # Z
; # (call $PutBin DOT)
  %311 = load void(i8)*, void(i8)** @$PutBin
  call void %311(i8 2)
; # (call $PutBin BEG)
  %312 = load void(i8)*, void(i8)** @$PutBin
  call void %312(i8 1)
  br label %$47
$47:
  %313 = phi i64 [%306, %$44], [%309, %$46] ; # X
  %314 = phi i64 [%307, %$44], [%280, %$46] ; # Z
  br label %$38
$40:
  %315 = phi i64 [%289, %$41], [%296, %$43], [%302, %$45] ; # X
  %316 = phi i64 [%290, %$41], [%297, %$43], [%303, %$45] ; # Z
  br label %$2
$36:
  %317 = phi i64 [%275, %$34] ; # X
; # (tail X)
  %318 = add i64 %317, -8
; # (val (tail X))
  %319 = inttoptr i64 %318 to i64*
  %320 = load i64, i64* %319
; # (sym? (val (tail X)))
  %321 = and i64 %320, 8
  %322 = icmp ne i64 %321, 0
  br i1 %322, label %$49, label %$48
$49:
  %323 = phi i64 [%317, %$36] ; # X
; # (let Nm (name (& @ -9)) (when (val $Extn) (let N (shl (& (i64 (- ...
; # (& @ -9)
  %324 = and i64 %320, -9
; # (name (& @ -9))
  br label %$50
$50:
  %325 = phi i64 [%324, %$49], [%331, %$51] ; # Tail
  %326 = and i64 %325, 6
  %327 = icmp ne i64 %326, 0
  br i1 %327, label %$52, label %$51
$51:
  %328 = phi i64 [%325, %$50] ; # Tail
  %329 = inttoptr i64 %328 to i64*
  %330 = getelementptr i64, i64* %329, i32 1
  %331 = load i64, i64* %330
  br label %$50
$52:
  %332 = phi i64 [%325, %$50] ; # Tail
; # (when (val $Extn) (let N (shl (& (i64 (- (objFile Nm) @)) (hex "F...
; # (val $Extn)
  %333 = load i32, i32* @$Extn
  %334 = icmp ne i32 %333, 0
  br i1 %334, label %$53, label %$54
$53:
  %335 = phi i64 [%323, %$52] ; # X
  %336 = phi i64 [%332, %$52] ; # Nm
; # (let N (shl (& (i64 (- (objFile Nm) @)) (hex "FFFF")) 24) (setq N...
; # (objFile Nm)
  %337 = call i32 @objFile(i64 %336)
; # (- (objFile Nm) @)
  %338 = sub i32 %337, %333
; # (i64 (- (objFile Nm) @))
  %339 = sext i32 %338 to i64
; # (& (i64 (- (objFile Nm) @)) (hex "FFFF"))
  %340 = and i64 %339, 65535
; # (shl (& (i64 (- (objFile Nm) @)) (hex "FFFF")) 24)
  %341 = shl i64 %340, 24
; # (& Nm (hex "FFF00FFF00FFFFFF"))
  %342 = and i64 %336, 18442258061990035455
; # (shl N 12)
  %343 = shl i64 %341, 12
; # (| N (shl N 12))
  %344 = or i64 %341, %343
; # (& (| N (shl N 12)) (hex "000FF000FF000000"))
  %345 = and i64 %344, 4486011719516160
; # (| (& Nm (hex "FFF00FFF00FFFFFF")) (& (| N (shl N 12)) (hex "000F...
  %346 = or i64 %342, %345
  br label %$54
$54:
  %347 = phi i64 [%323, %$52], [%335, %$53] ; # X
  %348 = phi i64 [%332, %$52], [%346, %$53] ; # Nm
; # (+ EXTERN 4)
; # (shl Nm 2)
  %349 = shl i64 %348, 2
; # (shr (shl Nm 2) 6)
  %350 = lshr i64 %349, 6
; # (prCnt (+ EXTERN 4) (shr (shl Nm 2) 6))
  tail call void @prCnt(i8 7, i64 %350)
  br label %$2
$48:
  %351 = phi i64 [%317, %$36] ; # X
; # (name @)
  br label %$55
$55:
  %352 = phi i64 [%320, %$48], [%358, %$56] ; # Tail
  %353 = and i64 %352, 6
  %354 = icmp ne i64 %353, 0
  br i1 %354, label %$57, label %$56
$56:
  %355 = phi i64 [%352, %$55] ; # Tail
  %356 = inttoptr i64 %355 to i64*
  %357 = getelementptr i64, i64* %356, i32 1
  %358 = load i64, i64* %357
  br label %$55
$57:
  %359 = phi i64 [%352, %$55] ; # Tail
; # (== (name @) ZERO)
  %360 = icmp eq i64 %359, 2
  br i1 %360, label %$59, label %$58
$59:
  %361 = phi i64 [%351, %$57] ; # X
; # (call $PutBin NIX)
  %362 = load void(i8)*, void(i8)** @$PutBin
  call void %362(i8 0)
  br label %$2
$58:
  %363 = phi i64 [%351, %$57] ; # X
; # (let (Nm @ Tag (if (findSym X Nm (val $Intern)) (i8 INTERN) (i8 T...
; # (if (findSym X Nm (val $Intern)) (i8 INTERN) (i8 TRANSIENT))
; # (val $Intern)
  %364 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 0) to i64) to i64*
  %365 = load i64, i64* %364
; # (findSym X Nm (val $Intern))
  %366 = call i1 @findSym(i64 %363, i64 %359, i64 %365)
  br i1 %366, label %$60, label %$61
$60:
  %367 = phi i64 [%363, %$58] ; # X
; # (i8 INTERN)
  br label %$62
$61:
  %368 = phi i64 [%363, %$58] ; # X
; # (i8 TRANSIENT)
  br label %$62
$62:
  %369 = phi i64 [%367, %$60], [%368, %$61] ; # X
  %370 = phi i8 [1, %$60], [2, %$61] ; # ->
; # (if (cnt? Nm) (prCnt (+ Tag 4) (int Nm)) (let (Y Nm N 8) (while (...
; # (cnt? Nm)
  %371 = and i64 %359, 2
  %372 = icmp ne i64 %371, 0
  br i1 %372, label %$63, label %$64
$63:
  %373 = phi i64 [%369, %$62] ; # X
; # (+ Tag 4)
  %374 = add i8 %370, 4
; # (int Nm)
  %375 = lshr i64 %359, 4
; # (prCnt (+ Tag 4) (int Nm))
  call void @prCnt(i8 %374, i64 %375)
  br label %$65
$64:
  %376 = phi i64 [%369, %$62] ; # X
; # (let (Y Nm N 8) (while (big? (setq Y (val (big Y)))) (inc 'N 8)) ...
; # (while (big? (setq Y (val (big Y)))) (inc 'N 8))
  br label %$66
$66:
  %377 = phi i64 [%376, %$64], [%385, %$67] ; # X
  %378 = phi i64 [%359, %$64], [%386, %$67] ; # Y
  %379 = phi i64 [8, %$64], [%388, %$67] ; # N
; # (big Y)
  %380 = add i64 %378, 4
; # (val (big Y))
  %381 = inttoptr i64 %380 to i64*
  %382 = load i64, i64* %381
; # (big? (setq Y (val (big Y))))
  %383 = and i64 %382, 4
  %384 = icmp ne i64 %383, 0
  br i1 %384, label %$67, label %$68
$67:
  %385 = phi i64 [%377, %$66] ; # X
  %386 = phi i64 [%382, %$66] ; # Y
  %387 = phi i64 [%379, %$66] ; # N
; # (inc 'N 8)
  %388 = add i64 %387, 8
  br label %$66
$68:
  %389 = phi i64 [%377, %$66] ; # X
  %390 = phi i64 [%382, %$66] ; # Y
  %391 = phi i64 [%379, %$66] ; # N
; # (int Y)
  %392 = lshr i64 %390, 4
; # (while Y (inc 'N) (setq Y (shr Y 8)))
  br label %$69
$69:
  %393 = phi i64 [%389, %$68], [%397, %$70] ; # X
  %394 = phi i64 [%392, %$68], [%401, %$70] ; # Y
  %395 = phi i64 [%391, %$68], [%400, %$70] ; # N
  %396 = icmp ne i64 %394, 0
  br i1 %396, label %$70, label %$71
$70:
  %397 = phi i64 [%393, %$69] ; # X
  %398 = phi i64 [%394, %$69] ; # Y
  %399 = phi i64 [%395, %$69] ; # N
; # (inc 'N)
  %400 = add i64 %399, 1
; # (shr Y 8)
  %401 = lshr i64 %398, 8
  br label %$69
$71:
  %402 = phi i64 [%393, %$69] ; # X
  %403 = phi i64 [%394, %$69] ; # Y
  %404 = phi i64 [%395, %$69] ; # N
; # (let (P (push 0 Nm) M (- N 63) C 8) (when (ge0 M) (setq N 63)) (c...
; # (push 0 Nm)
  %405 = alloca i64, i64 2, align 16
  store i64 0, i64* %405
  %406 = getelementptr i64, i64* %405, i32 1
  store i64 %359, i64* %406
; # (- N 63)
  %407 = sub i64 %404, 63
; # (when (ge0 M) (setq N 63))
; # (ge0 M)
  %408 = icmp sge i64 %407, 0
  br i1 %408, label %$72, label %$73
$72:
  %409 = phi i64 [%402, %$71] ; # X
  %410 = phi i64 [%403, %$71] ; # Y
  %411 = phi i64 [%404, %$71] ; # N
  %412 = phi i64 [%407, %$71] ; # M
  br label %$73
$73:
  %413 = phi i64 [%402, %$71], [%409, %$72] ; # X
  %414 = phi i64 [%403, %$71], [%410, %$72] ; # Y
  %415 = phi i64 [%404, %$71], [63, %$72] ; # N
  %416 = phi i64 [%407, %$71], [%412, %$72] ; # M
; # (shl N 2)
  %417 = shl i64 %415, 2
; # (i8 (shl N 2))
  %418 = trunc i64 %417 to i8
; # (+ Tag (i8 (shl N 2)))
  %419 = add i8 %370, %418
; # (call $PutBin (+ Tag (i8 (shl N 2))))
  %420 = load void(i8)*, void(i8)** @$PutBin
  call void %420(i8 %419)
; # (loop (loop (call $PutBin (symByte P)) (? (=0 (dec 'N)))) (? (lt0...
  br label %$74
$74:
  %421 = phi i64 [%413, %$73], [%463, %$83] ; # X
  %422 = phi i64 [%414, %$73], [%464, %$83] ; # Y
  %423 = phi i64 [%415, %$73], [%465, %$83] ; # N
  %424 = phi i64 [%416, %$73], [%466, %$83] ; # M
; # (loop (call $PutBin (symByte P)) (? (=0 (dec 'N))))
  br label %$75
$75:
  %425 = phi i64 [%421, %$74], [%433, %$76] ; # X
  %426 = phi i64 [%422, %$74], [%434, %$76] ; # Y
  %427 = phi i64 [%423, %$74], [%435, %$76] ; # N
  %428 = phi i64 [%424, %$74], [%436, %$76] ; # M
; # (symByte P)
  %429 = call i8 @symByte(i64* %405)
; # (call $PutBin (symByte P))
  %430 = load void(i8)*, void(i8)** @$PutBin
  call void %430(i8 %429)
; # (? (=0 (dec 'N)))
; # (dec 'N)
  %431 = sub i64 %427, 1
; # (=0 (dec 'N))
  %432 = icmp eq i64 %431, 0
  br i1 %432, label %$77, label %$76
$76:
  %433 = phi i64 [%425, %$75] ; # X
  %434 = phi i64 [%426, %$75] ; # Y
  %435 = phi i64 [%431, %$75] ; # N
  %436 = phi i64 [%428, %$75] ; # M
  br label %$75
$77:
  %437 = phi i64 [%425, %$75] ; # X
  %438 = phi i64 [%426, %$75] ; # Y
  %439 = phi i64 [%431, %$75] ; # N
  %440 = phi i64 [%428, %$75] ; # M
  %441 = phi i64 [0, %$75] ; # ->
; # (? (lt0 M))
; # (lt0 M)
  %442 = icmp slt i64 %440, 0
  br i1 %442, label %$79, label %$78
$78:
  %443 = phi i64 [%437, %$77] ; # X
  %444 = phi i64 [%438, %$77] ; # Y
  %445 = phi i64 [%439, %$77] ; # N
  %446 = phi i64 [%440, %$77] ; # M
; # (? (=0 M) (call $PutBin 0))
; # (=0 M)
  %447 = icmp eq i64 %446, 0
  br i1 %447, label %$81, label %$80
$81:
  %448 = phi i64 [%443, %$78] ; # X
  %449 = phi i64 [%444, %$78] ; # Y
  %450 = phi i64 [%445, %$78] ; # N
  %451 = phi i64 [%446, %$78] ; # M
; # (call $PutBin 0)
  %452 = load void(i8)*, void(i8)** @$PutBin
  call void %452(i8 0)
  br label %$79
$80:
  %453 = phi i64 [%443, %$78] ; # X
  %454 = phi i64 [%444, %$78] ; # Y
  %455 = phi i64 [%445, %$78] ; # N
  %456 = phi i64 [%446, %$78] ; # M
; # (when (ge0 (setq M (- (setq N M) 255))) (setq N 255))
; # (- (setq N M) 255)
  %457 = sub i64 %456, 255
; # (ge0 (setq M (- (setq N M) 255)))
  %458 = icmp sge i64 %457, 0
  br i1 %458, label %$82, label %$83
$82:
  %459 = phi i64 [%453, %$80] ; # X
  %460 = phi i64 [%454, %$80] ; # Y
  %461 = phi i64 [%456, %$80] ; # N
  %462 = phi i64 [%457, %$80] ; # M
  br label %$83
$83:
  %463 = phi i64 [%453, %$80], [%459, %$82] ; # X
  %464 = phi i64 [%454, %$80], [%460, %$82] ; # Y
  %465 = phi i64 [%456, %$80], [255, %$82] ; # N
  %466 = phi i64 [%457, %$80], [%462, %$82] ; # M
; # (i8 N)
  %467 = trunc i64 %465 to i8
; # (call $PutBin (i8 N))
  %468 = load void(i8)*, void(i8)** @$PutBin
  call void %468(i8 %467)
  br label %$74
$79:
  %469 = phi i64 [%437, %$77], [%448, %$81] ; # X
  %470 = phi i64 [%438, %$77], [%449, %$81] ; # Y
  %471 = phi i64 [%439, %$77], [%450, %$81] ; # N
  %472 = phi i64 [%440, %$77], [%451, %$81] ; # M
  br label %$65
$65:
  %473 = phi i64 [%373, %$63], [%469, %$79] ; # X
  br label %$2
$2:
  %474 = phi i64 [%3, %$4], [%263, %$29], [%273, %$35], [%315, %$40], [%347, %$54], [%361, %$59], [%473, %$65] ; # X
  ret void
}

define void @pr(i64) align 8 {
$1:
; # (set $PutBin (fun (void i8) _putStdout))
; # (fun (void i8) _putStdout)
  store void(i8)* @_putStdout, void(i8)** @$PutBin
; # (binPrint X)
  tail call void @binPrint(i64 %0)
  ret void
}

define void @putTell(i8) align 8 {
$1:
; # (let P (val $Ptr) (set P B) (when (== (set $Ptr (inc P)) (val $En...
; # (val $Ptr)
  %1 = load i8*, i8** @$Ptr
; # (set P B)
  store i8 %0, i8* %1
; # (when (== (set $Ptr (inc P)) (val $End)) (err 0 0 ($ "Tell PIPE_B...
; # (set $Ptr (inc P))
; # (inc P)
  %2 = getelementptr i8, i8* %1, i32 1
  store i8* %2, i8** @$Ptr
; # (val $End)
  %3 = load i8*, i8** @$End
; # (== (set $Ptr (inc P)) (val $End))
  %4 = icmp eq i8* %2, %3
  br i1 %4, label %$2, label %$3
$2:
; # (err 0 0 ($ "Tell PIPE_BUF") null)
  call void @err(i64 0, i64 0, i8* bitcast ([14 x i8]* @$41 to i8*), i8* null)
  unreachable
$3:
  ret void
}

define void @prTell(i64) align 8 {
$1:
; # (set $PutBin (fun (void i8) putTell) $Extn 0)
; # (fun (void i8) putTell)
  store void(i8)* @putTell, void(i8)** @$PutBin
  store i32 0, i32* @$Extn
; # (binPrint X)
  tail call void @binPrint(i64 %0)
  ret void
}

define void @tellBeg(i8*) align 8 {
$1:
; # (set $TellBuf P $End (ofs P (dec (val PipeBufSize))) (inc 'P 8) B...
  store i8* %0, i8** @$TellBuf
; # (val PipeBufSize)
  %1 = load i32, i32* @PipeBufSize
; # (dec (val PipeBufSize))
  %2 = sub i32 %1, 1
; # (ofs P (dec (val PipeBufSize)))
  %3 = getelementptr i8, i8* %0, i32 %2
  store i8* %3, i8** @$End
; # (inc 'P 8)
  %4 = getelementptr i8, i8* %0, i32 8
  store i8 1, i8* %4
; # (inc P)
  %5 = getelementptr i8, i8* %4, i32 1
  store i8* %5, i8** @$Ptr
  ret void
}

define void @tellEnd(i32) align 8 {
$1:
; # (let (P (val $Ptr) Q (val $TellBuf)) (set P END) (inc 'P) (let (D...
; # (val $Ptr)
  %1 = load i8*, i8** @$Ptr
; # (val $TellBuf)
  %2 = load i8*, i8** @$TellBuf
; # (set P END)
  store i8 3, i8* %1
; # (inc 'P)
  %3 = getelementptr i8, i8* %1, i32 1
; # (let (D (i32 (- P Q)) N (- D 8)) (set (i32* Q) Pid (inc (i32* Q))...
; # (- P Q)
  %4 = ptrtoint i8* %3 to i64
  %5 = ptrtoint i8* %2 to i64
  %6 = sub i64 %4, %5
; # (i32 (- P Q))
  %7 = trunc i64 %6 to i32
; # (- D 8)
  %8 = sub i32 %7, 8
; # (set (i32* Q) Pid (inc (i32* Q)) N)
; # (i32* Q)
  %9 = bitcast i8* %2 to i32*
  store i32 %0, i32* %9
; # (i32* Q)
  %10 = bitcast i8* %2 to i32*
; # (inc (i32* Q))
  %11 = getelementptr i32, i32* %10, i32 1
  store i32 %8, i32* %11
; # (when (val $Tell) (let Fd @ (unless (wrBytes Fd Q D) (close Fd) (...
; # (val $Tell)
  %12 = load i32, i32* @$Tell
  %13 = icmp ne i32 %12, 0
  br i1 %13, label %$2, label %$3
$2:
  %14 = phi i8* [%3, %$1] ; # P
  %15 = phi i8* [%2, %$1] ; # Q
; # (let Fd @ (unless (wrBytes Fd Q D) (close Fd) (set $Tell 0)))
; # (unless (wrBytes Fd Q D) (close Fd) (set $Tell 0))
; # (wrBytes Fd Q D)
  %16 = call i1 @wrBytes(i32 %12, i8* %15, i32 %7)
  br i1 %16, label %$5, label %$4
$4:
  %17 = phi i8* [%14, %$2] ; # P
  %18 = phi i8* [%15, %$2] ; # Q
; # (close Fd)
  %19 = call i32 @close(i32 %12)
; # (set $Tell 0)
  store i32 0, i32* @$Tell
  br label %$5
$5:
  %20 = phi i8* [%14, %$2], [%17, %$4] ; # P
  %21 = phi i8* [%15, %$2], [%18, %$4] ; # Q
  br label %$3
$3:
  %22 = phi i8* [%3, %$1], [%20, %$5] ; # P
  %23 = phi i8* [%2, %$1], [%21, %$5] ; # Q
; # (let (Cld (val $Child) 
  br label %$9
$9:
  %55 = phi i8* [%33, %$7], [%51, %$11] ; # P
  %56 = phi i8* [%34, %$7], [%52, %$11] ; # Q
  %57 = phi i8* [%35, %$7], [%53, %$11] ; # Cld
  %58 = phi i1 [0, %$7], [%54, %$11] ; # ->
  br i1 %58, label %$13, label %$14
$13:
  %59 = phi i8* [%55, %$9] ; # P
  %60 = phi i8* [%56, %$9] ; # Q
  %61 = phi i8* [%57, %$9] ; # Cld
; # (wrChild Cld Q N)
  call void @wrChild(i8* %61, i8* %60, i32 %8)
  br label %$14
$14:
  %62 = phi i8* [%55, %$9], [%59, %$13] ; # P
  %63 = phi i8* [%56, %$9], [%60, %$13] ; # Q
  %64 = phi i8* [%57, %$9], [%61, %$13] ; # Cld
; # (ofs Cld (child T))
  %65 = getelementptr i8, i8* %64, i32 32
  br label %$6
$8:
  %66 = phi i8* [%29, %$6] ; # P
  %67 = phi i8* [%30, %$6] ; # Q
  %68 = phi i8* [%31, %$6] ; # Cld
  ret void
}

define void @unsync() align 8 {
$1:
; # (when (val $Tell) (let Fd @ (unless (wrBytes Fd (i8* (push -1)) 8...
; # (val $Tell)
  %0 = load i32, i32* @$Tell
  %1 = icmp ne i32 %0, 0
  br i1 %1, label %$2, label %$3
$2:
; # (let Fd @ (unless (wrBytes Fd (i8* (push -1)) 8) (close Fd) (set ...
; # (unless (wrBytes Fd (i8* (push -1)) 8) (close Fd) (set $Tell 0))
; # (push -1)
  %2 = alloca i64, i64 1
  store i64 -1, i64* %2
; # (i8* (push -1))
  %3 = bitcast i64* %2 to i8*
; # (wrBytes Fd (i8* (push -1)) 8)
  %4 = call i1 @wrBytes(i32 %0, i8* %3, i32 8)
  br i1 %4, label %$5, label %$4
$4:
; # (close Fd)
  %5 = call i32 @close(i32 %0)
; # (set $Tell 0)
  store i32 0, i32* @$Tell
  br label %$5
$5:
  br label %$3
$3:
; # (set $Sync NO)
  store i1 0, i1* @$Sync
  ret void
}

define void @waitFile(i32) align 8 {
$1:
; # (let Res (b32 1) (while (lt0 (waitpid Pid Res 0)) (unless (== (gE...
; # (b32 1)
  %1 = alloca i32, i64 1
; # (while (lt0 (waitpid Pid Res 0)) (unless (== (gErrno) EINTR) (clo...
  br label %$2
$2:
; # (waitpid Pid Res 0)
  %2 = call i32 @waitpid(i32 %0, i32* %1, i32 0)
; # (lt0 (waitpid Pid Res 0))
  %3 = icmp slt i32 %2, 0
  br i1 %3, label %$3, label %$4
$3:
; # (unless (== (gErrno) EINTR) (closeErr))
; # (gErrno)
  %4 = call i32 @gErrno()
; # (== (gErrno) EINTR)
  %5 = icmp eq i32 %4, 2
  br i1 %5, label %$6, label %$5
$5:
; # (closeErr)
  call void @closeErr()
  unreachable
$6:
; # (sigChk 0)
  %6 = load volatile i32, i32* bitcast ([16 x i32]* @$Signal to i32*)
  %7 = icmp ne i32 %6, 0
  br i1 %7, label %$7, label %$8
$7:
  call void @sighandler(i64 0)
  br label %$8
$8:
  br label %$2
$4:
; # (set $At2 (cnt (i64 (val Res))))
; # (val Res)
  %8 = load i32, i32* %1
; # (i64 (val Res))
  %9 = sext i32 %8 to i64
; # (cnt (i64 (val Res)))
  %10 = shl i64 %9, 4
  %11 = or i64 %10, 2
  %12 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 456) to i64) to i64*
  store i64 %11, i64* %12
  ret void
}

define i32 @currFd(i64) align 8 {
$1:
; # (let (In: (ioFrame (val $InFrames)) Out: (ioFrame (val $OutFrames...
; # (val $InFrames)
  %1 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 40) to i8**)
; # (val $OutFrames)
  %2 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 48) to i8**)
; # (nond ((or (In: file) (Out: file)) (err Exe 0 ($ "No current fd")...
; # (or (In: file) (Out: file))
; # (In: file)
  %3 = getelementptr i8, i8* %1, i32 8
  %4 = bitcast i8* %3 to i8**
  %5 = load i8*, i8** %4
  %6 = icmp ne i8* %5, null
  br i1 %6, label %$3, label %$4
$4:
; # (Out: file)
  %7 = getelementptr i8, i8* %2, i32 8
  %8 = bitcast i8* %7 to i8**
  %9 = load i8*, i8** %8
  %10 = icmp ne i8* %9, null
  br label %$3
$3:
  %11 = phi i1 [1, %$1], [%10, %$4] ; # ->
  br i1 %11, label %$5, label %$6
$6:
; # (err Exe 0 ($ "No current fd") null)
  call void @err(i64 %0, i64 0, i8* bitcast ([14 x i8]* @$42 to i8*), i8* null)
  unreachable
$5:
; # (Out: file)
  %12 = getelementptr i8, i8* %2, i32 8
  %13 = bitcast i8* %12 to i8**
  %14 = load i8*, i8** %13
  %15 = icmp ne i8* %14, null
  br i1 %15, label %$7, label %$8
$8:
; # (In: file)
  %16 = getelementptr i8, i8* %1, i32 8
  %17 = bitcast i8* %16 to i8**
  %18 = load i8*, i8** %17
; # ((inFile (In: file)) fd)
  %19 = getelementptr i8, i8* %18, i32 8
  %20 = bitcast i8* %19 to i32*
  %21 = load i32, i32* %20
  br label %$2
$7:
; # (In: file)
  %22 = getelementptr i8, i8* %1, i32 8
  %23 = bitcast i8* %22 to i8**
  %24 = load i8*, i8** %23
  %25 = icmp ne i8* %24, null
  br i1 %25, label %$9, label %$10
$10:
; # (Out: file)
  %26 = getelementptr i8, i8* %2, i32 8
  %27 = bitcast i8* %26 to i8**
  %28 = load i8*, i8** %27
; # ((outFile (Out: file)) fd)
  %29 = bitcast i8* %28 to i32*
  %30 = load i32, i32* %29
  br label %$2
$9:
; # (if (if (> (In:) (stack)) (> (Out:) (In:)) (> (In:) (Out:))) ((in...
; # (if (> (In:) (stack)) (> (Out:) (In:)) (> (In:) (Out:)))
; # (In:)
; # (stack)
  %31 = call i8* @llvm.stacksave()
; # (> (In:) (stack))
  %32 = icmp ugt i8* %1, %31
  br i1 %32, label %$11, label %$12
$11:
; # (Out:)
; # (In:)
; # (> (Out:) (In:))
  %33 = icmp ugt i8* %2, %1
  br label %$13
$12:
; # (In:)
; # (Out:)
; # (> (In:) (Out:))
  %34 = icmp ugt i8* %1, %2
  br label %$13
$13:
  %35 = phi i1 [%33, %$11], [%34, %$12] ; # ->
  br i1 %35, label %$14, label %$15
$14:
; # (In: file)
  %36 = getelementptr i8, i8* %1, i32 8
  %37 = bitcast i8* %36 to i8**
  %38 = load i8*, i8** %37
; # ((inFile (In: file)) fd)
  %39 = getelementptr i8, i8* %38, i32 8
  %40 = bitcast i8* %39 to i32*
  %41 = load i32, i32* %40
  br label %$16
$15:
; # (Out: file)
  %42 = getelementptr i8, i8* %2, i32 8
  %43 = bitcast i8* %42 to i8**
  %44 = load i8*, i8** %43
; # ((outFile (Out: file)) fd)
  %45 = bitcast i8* %44 to i32*
  %46 = load i32, i32* %45
  br label %$16
$16:
  %47 = phi i32 [%41, %$14], [%46, %$15] ; # ->
  br label %$2
$2:
  %48 = phi i32 [%21, %$8], [%30, %$10], [%47, %$16] ; # ->
  ret i32 %48
}

define i32 @getIn() align 8 {
$1:
; # (set $Chr (cond ((val $IoChar) (set $IoChar (shr @ 8)) (i32 (i8 @...
; # (cond ((val $IoChar) (set $IoChar (shr @ 8)) (i32 (i8 @))) ((nil?...
; # (val $IoChar)
  %0 = load i64, i64* @$IoChar
  %1 = icmp ne i64 %0, 0
  br i1 %1, label %$4, label %$3
$4:
; # (set $IoChar (shr @ 8))
; # (shr @ 8)
  %2 = lshr i64 %0, 8
  store i64 %2, i64* @$IoChar
; # (i8 @)
  %3 = trunc i64 %0 to i8
; # (i32 (i8 @))
  %4 = zext i8 %3 to i32
  br label %$2
$3:
; # (let (Iox: (ioxFrame (val $InFrames)) At (save (val $At))) (prog2...
; # (val $InFrames)
  %5 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 40) to i8**)
; # (val $At)
  %6 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  %7 = load i64, i64* %6
; # (save (val $At))
  %8 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %9 = load i64, i64* %8
  %10 = alloca i64, i64 2, align 16
  %11 = ptrtoint i64* %10 to i64
  %12 = inttoptr i64 %11 to i64*
  store i64 %7, i64* %12
  %13 = add i64 %11, 8
  %14 = inttoptr i64 %13 to i64*
  store i64 %9, i64* %14
  %15 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %11, i64* %15
; # (prog2 (set $Chr (Iox: chr) (i8** $Get) (Iox: fun) $InFrames (Iox...
; # (set $Chr (Iox: chr) (i8** $Get) (Iox: fun) $InFrames (Iox: link)...
; # (Iox: chr)
  %16 = getelementptr i8, i8* %5, i32 32
  %17 = bitcast i8* %16 to i32*
  %18 = load i32, i32* %17
  store i32 %18, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
; # (i8** $Get)
  %19 = bitcast i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**) to i8**
; # (Iox: fun)
  %20 = getelementptr i8, i8* %5, i32 16
  %21 = bitcast i8* %20 to i8**
  %22 = load i8*, i8** %21
  store i8* %22, i8** %19
; # (Iox: link)
  %23 = bitcast i8* %5 to i8**
  %24 = load i8*, i8** %23
  store i8* %24, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 40) to i8**)
; # (Iox: exe)
  %25 = getelementptr i8, i8* %5, i32 24
  %26 = ptrtoint i8* %25 to i64
  %27 = inttoptr i64 %26 to i64*
  %28 = load i64, i64* %27
; # (eval (Iox: exe))
  %29 = and i64 %28, 6
  %30 = icmp ne i64 %29, 0
  br i1 %30, label %$7, label %$6
$7:
  br label %$5
$6:
  %31 = and i64 %28, 8
  %32 = icmp ne i64 %31, 0
  br i1 %32, label %$9, label %$8
$9:
  %33 = inttoptr i64 %28 to i64*
  %34 = load i64, i64* %33
  br label %$5
$8:
  %35 = call i64 @evList(i64 %28)
  br label %$5
$5:
  %36 = phi i64 [%28, %$7], [%34, %$9], [%35, %$8] ; # ->
; # (set $InFrames (Iox:) $Get (fun (i32) getIn) $At At)
; # (Iox:)
  store i8* %5, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 40) to i8**)
; # (fun (i32) getIn)
  store i32()* @getIn, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %37 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  store i64 %7, i64* %37
; # (Iox: chr (val $Chr))
  %38 = getelementptr i8, i8* %5, i32 32
  %39 = bitcast i8* %38 to i32*
  %40 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
  store i32 %40, i32* %39
; # (drop *Safe)
  %41 = inttoptr i64 %11 to i64*
  %42 = getelementptr i64, i64* %41, i32 1
  %43 = load i64, i64* %42
  %44 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %43, i64* %44
; # (nil? (let (Iox: (ioxFrame (val $InFrames)) At (save (val $At))) ...
  %45 = icmp eq i64 %36, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %45, label %$11, label %$10
$11:
  br label %$2
$10:
; # (sym? @)
  %46 = and i64 %36, 8
  %47 = icmp ne i64 %46, 0
  br i1 %47, label %$13, label %$12
$13:
; # (let (S @ V (val (tail @))) (if (or (sym? V) (not (cnt? (setq V (...
; # (tail @)
  %48 = add i64 %36, -8
; # (val (tail @))
  %49 = inttoptr i64 %48 to i64*
  %50 = load i64, i64* %49
; # (if (or (sym? V) (not (cnt? (setq V (name V))))) (charErr 0 S) (l...
; # (or (sym? V) (not (cnt? (setq V (name V)))))
; # (sym? V)
  %51 = and i64 %50, 8
  %52 = icmp ne i64 %51, 0
  br i1 %52, label %$14, label %$15
$15:
  %53 = phi i64 [%50, %$13] ; # V
; # (name V)
  br label %$16
$16:
  %54 = phi i64 [%53, %$15], [%60, %$17] ; # Tail
  %55 = and i64 %54, 6
  %56 = icmp ne i64 %55, 0
  br i1 %56, label %$18, label %$17
$17:
  %57 = phi i64 [%54, %$16] ; # Tail
  %58 = inttoptr i64 %57 to i64*
  %59 = getelementptr i64, i64* %58, i32 1
  %60 = load i64, i64* %59
  br label %$16
$18:
  %61 = phi i64 [%54, %$16] ; # Tail
; # (cnt? (setq V (name V)))
  %62 = and i64 %61, 2
  %63 = icmp ne i64 %62, 0
; # (not (cnt? (setq V (name V))))
  %64 = icmp eq i1 %63, 0
  br label %$14
$14:
  %65 = phi i64 [%50, %$13], [%61, %$18] ; # V
  %66 = phi i1 [1, %$13], [%64, %$18] ; # ->
  br i1 %66, label %$19, label %$20
$19:
  %67 = phi i64 [%65, %$14] ; # V
; # (charErr 0 S)
  call void @charErr(i64 0, i64 %36)
  unreachable
$20:
  %68 = phi i64 [%65, %$14] ; # V
; # (let C (int V) (set $IoChar (shr C 8)) (i32 (i8 C)))
; # (int V)
  %69 = lshr i64 %68, 4
; # (set $IoChar (shr C 8))
; # (shr C 8)
  %70 = lshr i64 %69, 8
  store i64 %70, i64* @$IoChar
; # (i8 C)
  %71 = trunc i64 %69 to i8
; # (i32 (i8 C))
  %72 = zext i8 %71 to i32
  br label %$21
$21:
  %73 = phi i64 [%68, %$20] ; # V
  %74 = phi i32 [%72, %$20] ; # ->
  br label %$2
$12:
; # (symErr 0 @)
  call void @symErr(i64 0, i64 %36)
  unreachable
$2:
  %75 = phi i32 [%4, %$4], [-1, %$11], [%74, %$21] ; # ->
  store i32 %75, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
  ret i32 %75
}

define void @put1(i8*, i32, i32) align 8 {
$1:
; # (let (Iox: (ioxFrame Iox) At (save (val $At)) At2 (save (val $At2...
; # (val $At)
  %3 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  %4 = load i64, i64* %3
; # (save (val $At))
  %5 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %6 = load i64, i64* %5
  %7 = alloca i64, i64 2, align 16
  %8 = ptrtoint i64* %7 to i64
  %9 = inttoptr i64 %8 to i64*
  store i64 %4, i64* %9
  %10 = add i64 %8, 8
  %11 = inttoptr i64 %10 to i64*
  store i64 %6, i64* %11
  %12 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %8, i64* %12
; # (val $At2)
  %13 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 456) to i64) to i64*
  %14 = load i64, i64* %13
; # (save (val $At2))
  %15 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %16 = load i64, i64* %15
  %17 = alloca i64, i64 2, align 16
  %18 = ptrtoint i64* %17 to i64
  %19 = inttoptr i64 %18 to i64*
  store i64 %14, i64* %19
  %20 = add i64 %18, 8
  %21 = inttoptr i64 %20 to i64*
  store i64 %16, i64* %21
  %22 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %18, i64* %22
; # (val $At3)
  %23 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 472) to i64) to i64*
  %24 = load i64, i64* %23
; # (save (val $At3))
  %25 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %26 = load i64, i64* %25
  %27 = alloca i64, i64 2, align 16
  %28 = ptrtoint i64* %27 to i64
  %29 = inttoptr i64 %28 to i64*
  store i64 %24, i64* %29
  %30 = add i64 %28, 8
  %31 = inttoptr i64 %30 to i64*
  store i64 %26, i64* %31
  %32 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %28, i64* %32
; # (set (i8** $Put) (Iox: fun) $OutFrames (Iox: link) $At2 (consStr ...
; # (i8** $Put)
  %33 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**) to i8**
; # (Iox: fun)
  %34 = getelementptr i8, i8* %0, i32 16
  %35 = bitcast i8* %34 to i8**
  %36 = load i8*, i8** %35
  store i8* %36, i8** %33
; # (Iox: link)
  %37 = bitcast i8* %0 to i8**
  %38 = load i8*, i8** %37
  store i8* %38, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 48) to i8**)
; # (i64 C)
  %39 = sext i32 %1 to i64
; # (cnt (i64 C))
  %40 = shl i64 %39, 4
  %41 = or i64 %40, 2
; # (consStr (cnt (i64 C)))
  %42 = call i64 @consStr(i64 %41)
  %43 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 456) to i64) to i64*
  store i64 %42, i64* %43
; # (if D (consStr (cnt (i64 @))) $Nil)
  %44 = icmp ne i32 %2, 0
  br i1 %44, label %$2, label %$3
$2:
; # (i64 @)
  %45 = sext i32 %2 to i64
; # (cnt (i64 @))
  %46 = shl i64 %45, 4
  %47 = or i64 %46, 2
; # (consStr (cnt (i64 @)))
  %48 = call i64 @consStr(i64 %47)
  br label %$4
$3:
  br label %$4
$4:
  %49 = phi i64 [%48, %$2], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$3] ; # ->
  %50 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 472) to i64) to i64*
  store i64 %49, i64* %50
; # (Iox: exe)
  %51 = getelementptr i8, i8* %0, i32 24
  %52 = ptrtoint i8* %51 to i64
  %53 = inttoptr i64 %52 to i64*
  %54 = load i64, i64* %53
; # (eval (Iox: exe))
  %55 = and i64 %54, 6
  %56 = icmp ne i64 %55, 0
  br i1 %56, label %$7, label %$6
$7:
  br label %$5
$6:
  %57 = and i64 %54, 8
  %58 = icmp ne i64 %57, 0
  br i1 %58, label %$9, label %$8
$9:
  %59 = inttoptr i64 %54 to i64*
  %60 = load i64, i64* %59
  br label %$5
$8:
  %61 = call i64 @evList(i64 %54)
  br label %$5
$5:
  %62 = phi i64 [%54, %$7], [%60, %$9], [%61, %$8] ; # ->
; # (set $OutFrames (Iox:) $Put (fun (void i8) putOut) $At3 At3 $At2 ...
; # (Iox:)
  store i8* %0, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 48) to i8**)
; # (fun (void i8) putOut)
  store void(i8)* @putOut, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  %63 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 472) to i64) to i64*
  store i64 %24, i64* %63
  %64 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 456) to i64) to i64*
  store i64 %14, i64* %64
  %65 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  store i64 %4, i64* %65
; # (drop *Safe)
  %66 = inttoptr i64 %8 to i64*
  %67 = getelementptr i64, i64* %66, i32 1
  %68 = load i64, i64* %67
  %69 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %68, i64* %69
  ret void
}

define void @putOut(i8) align 8 {
$1:
; # (nond ((& B (hex "80")) (set $IoChar (i64 B))) ((& B (hex "40")) ...
; # (& B (hex "80"))
  %1 = and i8 %0, 128
  %2 = icmp ne i8 %1, 0
  br i1 %2, label %$3, label %$4
$4:
; # (set $IoChar (i64 B))
; # (i64 B)
  %3 = zext i8 %0 to i64
  store i64 %3, i64* @$IoChar
  br label %$2
$3:
; # (& B (hex "40"))
  %4 = and i8 %0, 64
  %5 = icmp ne i8 %4, 0
  br i1 %5, label %$5, label %$6
$6:
; # (set $IoChar (| (val $IoChar) (shl (i64 B) (set $IoIx (+ (val $Io...
; # (val $IoChar)
  %6 = load i64, i64* @$IoChar
; # (i64 B)
  %7 = zext i8 %0 to i64
; # (set $IoIx (+ (val $IoIx) 8))
; # (val $IoIx)
  %8 = load i64, i64* @$IoIx
; # (+ (val $IoIx) 8)
  %9 = add i64 %8, 8
  store i64 %9, i64* @$IoIx
; # (shl (i64 B) (set $IoIx (+ (val $IoIx) 8)))
  %10 = shl i64 %7, %9
; # (| (val $IoChar) (shl (i64 B) (set $IoIx (+ (val $IoIx) 8))))
  %11 = or i64 %6, %10
  store i64 %11, i64* @$IoChar
; # (when (set $IoCnt (dec (val $IoCnt))) (ret))
; # (set $IoCnt (dec (val $IoCnt)))
; # (val $IoCnt)
  %12 = load i32, i32* @$IoCnt
; # (dec (val $IoCnt))
  %13 = sub i32 %12, 1
  store i32 %13, i32* @$IoCnt
  %14 = icmp ne i32 %13, 0
  br i1 %14, label %$7, label %$8
$7:
; # (ret)
  ret void
$8:
  br label %$2
$5:
; # (& B (hex "20"))
  %15 = and i8 %0, 32
  %16 = icmp ne i8 %15, 0
  br i1 %16, label %$9, label %$10
$10:
; # (set $IoCnt 1 $IoIx 0 $IoChar (i64 B))
  store i32 1, i32* @$IoCnt
  store i64 0, i64* @$IoIx
; # (i64 B)
  %17 = zext i8 %0 to i64
  store i64 %17, i64* @$IoChar
; # (ret)
  ret void
$9:
; # (& B (hex "10"))
  %18 = and i8 %0, 16
  %19 = icmp ne i8 %18, 0
  br i1 %19, label %$11, label %$12
$12:
; # (set $IoCnt 2 $IoIx 0 $IoChar (i64 B))
  store i32 2, i32* @$IoCnt
  store i64 0, i64* @$IoIx
; # (i64 B)
  %20 = zext i8 %0 to i64
  store i64 %20, i64* @$IoChar
; # (ret)
  ret void
$11:
; # (set $IoCnt 3 $IoIx 0 $IoChar (i64 B))
  store i32 3, i32* @$IoCnt
  store i64 0, i64* @$IoIx
; # (i64 B)
  %21 = zext i8 %0 to i64
  store i64 %21, i64* @$IoChar
; # (ret)
  ret void
$2:
; # (let (Iox: (ioxFrame (val $OutFrames)) C (i32 (val $IoChar))) (wh...
; # (val $OutFrames)
  %22 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 48) to i8**)
; # (val $IoChar)
  %23 = load i64, i64* @$IoChar
; # (i32 (val $IoChar))
  %24 = trunc i64 %23 to i32
; # (when (Iox: chr) (put1 (Iox:) @ C))
; # (Iox: chr)
  %25 = getelementptr i8, i8* %22, i32 32
  %26 = bitcast i8* %25 to i32*
  %27 = load i32, i32* %26
  %28 = icmp ne i32 %27, 0
  br i1 %28, label %$13, label %$14
$13:
; # (Iox:)
; # (put1 (Iox:) @ C)
  call void @put1(i8* %22, i32 %27, i32 %24)
  br label %$14
$14:
; # (Iox: chr C)
  %29 = getelementptr i8, i8* %22, i32 32
  %30 = bitcast i8* %29 to i32*
  store i32 %24, i32* %30
  ret void
}

define void @pushInFile(i8*, i8*, i32) align 8 {
$1:
; # (let Io: (ioFrame Io) (Io: link (val $InFrames)) (when (val $InFi...
; # (Io: link (val $InFrames))
  %3 = bitcast i8* %0 to i8**
  %4 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 40) to i8**)
  store i8* %4, i8** %3
; # (when (val $InFile) ((inFile @) chr (val $Chr)))
; # (val $InFile)
  %5 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 72) to i8**)
  %6 = icmp ne i8* %5, null
  br i1 %6, label %$2, label %$3
$2:
; # ((inFile @) chr (val $Chr))
  %7 = getelementptr i8, i8* %5, i32 12
  %8 = bitcast i8* %7 to i32*
  %9 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
  store i32 %9, i32* %8
  br label %$3
$3:
; # (set $Chr ((inFile (Io: file (set $InFile In))) chr))
; # (Io: file (set $InFile In))
  %10 = getelementptr i8, i8* %0, i32 8
  %11 = bitcast i8* %10 to i8**
  store i8* %1, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 72) to i8**)
  store i8* %1, i8** %11
; # ((inFile (Io: file (set $InFile In))) chr)
  %12 = getelementptr i8, i8* %1, i32 12
  %13 = bitcast i8* %12 to i32*
  %14 = load i32, i32* %13
  store i32 %14, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
; # (Io: fun (val (i8** $Get)))
  %15 = getelementptr i8, i8* %0, i32 16
  %16 = bitcast i8* %15 to i8**
  %17 = bitcast i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**) to i8**
  %18 = load i8*, i8** %17
  store i8* %18, i8** %16
; # (Io: pid Pid)
  %19 = getelementptr i8, i8* %0, i32 24
  %20 = bitcast i8* %19 to i32*
  store i32 %2, i32* %20
; # (set $InFrames (Io:) $Get (fun (i32) _getStdin))
; # (Io:)
  store i8* %0, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 40) to i8**)
; # (fun (i32) _getStdin)
  store i32()* @_getStdin, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  ret void
}

define void @pushOutFile(i8*, i8*, i32) align 8 {
$1:
; # (let Io: (ioFrame Io) (Io: link (val $OutFrames)) (Io: file (set ...
; # (Io: link (val $OutFrames))
  %3 = bitcast i8* %0 to i8**
  %4 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 48) to i8**)
  store i8* %4, i8** %3
; # (Io: file (set $OutFile Out))
  %5 = getelementptr i8, i8* %0, i32 8
  %6 = bitcast i8* %5 to i8**
  store i8* %1, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 80) to i8**)
  store i8* %1, i8** %6
; # (Io: fun (val (i8** $Put)))
  %7 = getelementptr i8, i8* %0, i32 16
  %8 = bitcast i8* %7 to i8**
  %9 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**) to i8**
  %10 = load i8*, i8** %9
  store i8* %10, i8** %8
; # (Io: pid Pid)
  %11 = getelementptr i8, i8* %0, i32 24
  %12 = bitcast i8* %11 to i32*
  store i32 %2, i32* %12
; # (set $OutFrames (Io:) $Put (fun (void i8) _putStdout))
; # (Io:)
  store i8* %0, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 48) to i8**)
; # (fun (void i8) _putStdout)
  store void(i8)* @_putStdout, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  ret void
}

define void @pushErrFile(i8*) align 8 {
$1:
; # ((ctFrame Ct) link (val $ErrFrames))
  %1 = bitcast i8* %0 to i8**
  %2 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 56) to i8**)
  store i8* %2, i8** %1
; # (set $ErrFrames Ct)
  store i8* %0, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 56) to i8**)
  ret void
}

define void @pushCtlFile(i8*) align 8 {
$1:
; # ((ctFrame Ct) link (val $CtlFrames))
  %1 = bitcast i8* %0 to i8**
  %2 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 64) to i8**)
  store i8* %2, i8** %1
; # (set $CtlFrames Ct)
  store i8* %0, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 64) to i8**)
  ret void
}

define void @popInFiles() align 8 {
$1:
; # (let Io: (ioFrame (val $InFrames)) (when (Io: file) (let In: (inF...
; # (val $InFrames)
  %0 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 40) to i8**)
; # (when (Io: file) (let In: (inFile @) (when (ge0 (In: fd)) (ifn (I...
; # (Io: file)
  %1 = getelementptr i8, i8* %0, i32 8
  %2 = bitcast i8* %1 to i8**
  %3 = load i8*, i8** %2
  %4 = icmp ne i8* %3, null
  br i1 %4, label %$2, label %$3
$2:
; # (let In: (inFile @) (when (ge0 (In: fd)) (ifn (Io: pid) (In: chr ...
; # (when (ge0 (In: fd)) (ifn (Io: pid) (In: chr (val $Chr)) (close (...
; # (In: fd)
  %5 = getelementptr i8, i8* %3, i32 8
  %6 = bitcast i8* %5 to i32*
  %7 = load i32, i32* %6
; # (ge0 (In: fd))
  %8 = icmp sge i32 %7, 0
  br i1 %8, label %$4, label %$5
$4:
; # (ifn (Io: pid) (In: chr (val $Chr)) (close (In: fd)) (closeInFile...
; # (Io: pid)
  %9 = getelementptr i8, i8* %0, i32 24
  %10 = bitcast i8* %9 to i32*
  %11 = load i32, i32* %10
  %12 = icmp ne i32 %11, 0
  br i1 %12, label %$7, label %$6
$6:
; # (In: chr (val $Chr))
  %13 = getelementptr i8, i8* %3, i32 12
  %14 = bitcast i8* %13 to i32*
  %15 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
  store i32 %15, i32* %14
  br label %$8
$7:
; # (In: fd)
  %16 = getelementptr i8, i8* %3, i32 8
  %17 = bitcast i8* %16 to i32*
  %18 = load i32, i32* %17
; # (close (In: fd))
  %19 = call i32 @close(i32 %18)
; # (In: fd)
  %20 = getelementptr i8, i8* %3, i32 8
  %21 = bitcast i8* %20 to i32*
  %22 = load i32, i32* %21
; # (closeInFile (In: fd))
  call void @closeInFile(i32 %22)
; # (when (> (Io: pid) 1) (waitFile @))
; # (Io: pid)
  %23 = getelementptr i8, i8* %0, i32 24
  %24 = bitcast i8* %23 to i32*
  %25 = load i32, i32* %24
; # (> (Io: pid) 1)
  %26 = icmp sgt i32 %25, 1
  br i1 %26, label %$9, label %$10
$9:
; # (waitFile @)
  call void @waitFile(i32 %25)
  br label %$10
$10:
  br label %$8
$8:
  br label %$5
$5:
  br label %$3
$3:
; # (set (i8** $Get) (Io: fun))
; # (i8** $Get)
  %27 = bitcast i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**) to i8**
; # (Io: fun)
  %28 = getelementptr i8, i8* %0, i32 16
  %29 = bitcast i8* %28 to i8**
  %30 = load i8*, i8** %29
  store i8* %30, i8** %27
; # (set $InFrames (Io: link))
; # (Io: link)
  %31 = bitcast i8* %0 to i8**
  %32 = load i8*, i8** %31
  store i8* %32, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 40) to i8**)
; # (set $Chr (if (Io: file) ((inFile (set $InFile @)) chr) ((ioxFram...
; # (if (Io: file) ((inFile (set $InFile @)) chr) ((ioxFrame (Io:)) c...
; # (Io: file)
  %33 = getelementptr i8, i8* %32, i32 8
  %34 = bitcast i8* %33 to i8**
  %35 = load i8*, i8** %34
  %36 = icmp ne i8* %35, null
  br i1 %36, label %$11, label %$12
$11:
; # (set $InFile @)
  store i8* %35, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 72) to i8**)
; # ((inFile (set $InFile @)) chr)
  %37 = getelementptr i8, i8* %35, i32 12
  %38 = bitcast i8* %37 to i32*
  %39 = load i32, i32* %38
  br label %$13
$12:
; # (Io:)
; # ((ioxFrame (Io:)) chr)
  %40 = getelementptr i8, i8* %32, i32 32
  %41 = bitcast i8* %40 to i32*
  %42 = load i32, i32* %41
  br label %$13
$13:
  %43 = phi i32 [%39, %$11], [%42, %$12] ; # ->
  store i32 %43, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
  ret void
}

define void @popOutFiles() align 8 {
$1:
; # (let Io: (ioFrame (val $OutFrames)) (cond ((Io: file) (let Out: (...
; # (val $OutFrames)
  %0 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 48) to i8**)
; # (cond ((Io: file) (let Out: (outFile @) (flush (val $OutFile)) (w...
; # (Io: file)
  %1 = getelementptr i8, i8* %0, i32 8
  %2 = bitcast i8* %1 to i8**
  %3 = load i8*, i8** %2
  %4 = icmp ne i8* %3, null
  br i1 %4, label %$4, label %$3
$4:
; # (let Out: (outFile @) (flush (val $OutFile)) (when (ge0 (Out: fd)...
; # (val $OutFile)
  %5 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 80) to i8**)
; # (flush (val $OutFile))
  %6 = call i1 @flush(i8* %5)
; # (when (ge0 (Out: fd)) (when (Io: pid) (close (Out: fd)) (closeOut...
; # (Out: fd)
  %7 = bitcast i8* %3 to i32*
  %8 = load i32, i32* %7
; # (ge0 (Out: fd))
  %9 = icmp sge i32 %8, 0
  br i1 %9, label %$5, label %$6
$5:
; # (when (Io: pid) (close (Out: fd)) (closeOutFile (Out: fd)) (when ...
; # (Io: pid)
  %10 = getelementptr i8, i8* %0, i32 24
  %11 = bitcast i8* %10 to i32*
  %12 = load i32, i32* %11
  %13 = icmp ne i32 %12, 0
  br i1 %13, label %$7, label %$8
$7:
; # (Out: fd)
  %14 = bitcast i8* %3 to i32*
  %15 = load i32, i32* %14
; # (close (Out: fd))
  %16 = call i32 @close(i32 %15)
; # (Out: fd)
  %17 = bitcast i8* %3 to i32*
  %18 = load i32, i32* %17
; # (closeOutFile (Out: fd))
  call void @closeOutFile(i32 %18)
; # (when (> (Io: pid) 1) (waitFile @))
; # (Io: pid)
  %19 = getelementptr i8, i8* %0, i32 24
  %20 = bitcast i8* %19 to i32*
  %21 = load i32, i32* %20
; # (> (Io: pid) 1)
  %22 = icmp sgt i32 %21, 1
  br i1 %22, label %$9, label %$10
$9:
; # (waitFile @)
  call void @waitFile(i32 %21)
  br label %$10
$10:
  br label %$8
$8:
  br label %$6
$6:
  br label %$2
$3:
; # (Io:)
; # ((ioxFrame (Io:)) chr)
  %23 = getelementptr i8, i8* %0, i32 32
  %24 = bitcast i8* %23 to i32*
  %25 = load i32, i32* %24
  %26 = icmp ne i32 %25, 0
  br i1 %26, label %$12, label %$11
$12:
; # (Io:)
; # (put1 (Io:) @ 0)
  call void @put1(i8* %0, i32 %25, i32 0)
  br label %$2
$11:
  br label %$2
$2:
; # (set (i8** $Put) (Io: fun))
; # (i8** $Put)
  %27 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**) to i8**
; # (Io: fun)
  %28 = getelementptr i8, i8* %0, i32 16
  %29 = bitcast i8* %28 to i8**
  %30 = load i8*, i8** %29
  store i8* %30, i8** %27
; # (set $OutFrames (Io: link))
; # (Io: link)
  %31 = bitcast i8* %0 to i8**
  %32 = load i8*, i8** %31
  store i8* %32, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 48) to i8**)
; # (when (Io: file) (set $OutFile @))
; # (Io: file)
  %33 = getelementptr i8, i8* %32, i32 8
  %34 = bitcast i8* %33 to i8**
  %35 = load i8*, i8** %34
  %36 = icmp ne i8* %35, null
  br i1 %36, label %$13, label %$14
$13:
; # (set $OutFile @)
  store i8* %35, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 80) to i8**)
  br label %$14
$14:
  ret void
}

define void @popErrFiles() align 8 {
$1:
; # (let Ct: (ctFrame (val $ErrFrames)) (dup2 (Ct: fd) 2) (close (Ct:...
; # (val $ErrFrames)
  %0 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 56) to i8**)
; # (Ct: fd)
  %1 = getelementptr i8, i8* %0, i32 8
  %2 = bitcast i8* %1 to i32*
  %3 = load i32, i32* %2
; # (dup2 (Ct: fd) 2)
  %4 = call i32 @dup2(i32 %3, i32 2)
; # (Ct: fd)
  %5 = getelementptr i8, i8* %0, i32 8
  %6 = bitcast i8* %5 to i32*
  %7 = load i32, i32* %6
; # (close (Ct: fd))
  %8 = call i32 @close(i32 %7)
; # (set $ErrFrames (Ct: link))
; # (Ct: link)
  %9 = bitcast i8* %0 to i8**
  %10 = load i8*, i8** %9
  store i8* %10, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 56) to i8**)
  ret void
}

define void @popCtlFiles() align 8 {
$1:
; # (let Ct: (ctFrame (val $CtlFrames)) (if (ge0 (Ct: fd)) (close @) ...
; # (val $CtlFrames)
  %0 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 64) to i8**)
; # (if (ge0 (Ct: fd)) (close @) (unLock (currFd 0) 0 0))
; # (Ct: fd)
  %1 = getelementptr i8, i8* %0, i32 8
  %2 = bitcast i8* %1 to i32*
  %3 = load i32, i32* %2
; # (ge0 (Ct: fd))
  %4 = icmp sge i32 %3, 0
  br i1 %4, label %$2, label %$3
$2:
; # (close @)
  %5 = call i32 @close(i32 %3)
  br label %$4
$3:
; # (currFd 0)
  %6 = call i32 @currFd(i64 0)
; # (unLock (currFd 0) 0 0)
  %7 = call i32 @unLock(i32 %6, i64 0, i64 0)
  br label %$4
$4:
  %8 = phi i32 [%5, %$2], [%7, %$3] ; # ->
; # (set $CtlFrames (Ct: link))
; # (Ct: link)
  %9 = bitcast i8* %0 to i8**
  %10 = load i8*, i8** %9
  store i8* %10, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 64) to i8**)
  ret void
}

define i64 @_Path(i64) align 8 {
$1:
; # (let Nm (xName (evSym (cdr Exe))) (mkStr (pathString Nm (b8 (path...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (evSym (cdr Exe))
  %4 = call i64 @evSym(i64 %3)
; # (xName (evSym (cdr Exe)))
  %5 = call i64 @xName(i64 %4)
; # (pathSize Nm)
  %6 = call i64 @pathSize(i64 %5)
; # (b8 (pathSize Nm))
  %7 = alloca i8, i64 %6
; # (pathString Nm (b8 (pathSize Nm)))
  %8 = call i8* @pathString(i64 %5, i8* %7)
; # (mkStr (pathString Nm (b8 (pathSize Nm))))
  %9 = call i64 @mkStr(i8* %8)
  ret i64 %9
}

define i64* @pollfd(i32) align 8 {
$1:
; # (let I (val $Nfds) (when (>= Fd I) (let P (set $Poll (i64* (alloc...
; # (val $Nfds)
  %1 = load i32, i32* @$Nfds
; # (when (>= Fd I) (let P (set $Poll (i64* (alloc (i8* (val $Poll)) ...
; # (>= Fd I)
  %2 = icmp sge i32 %0, %1
  br i1 %2, label %$2, label %$3
$2:
  %3 = phi i32 [%1, %$1] ; # I
; # (let P (set $Poll (i64* (alloc (i8* (val $Poll)) (* 8 (i64 (set $...
; # (set $Poll (i64* (alloc (i8* (val $Poll)) (* 8 (i64 (set $Nfds (+...
; # (val $Poll)
  %4 = load i64*, i64** @$Poll
; # (i8* (val $Poll))
  %5 = bitcast i64* %4 to i8*
; # (set $Nfds (+ Fd 1))
; # (+ Fd 1)
  %6 = add i32 %0, 1
  store i32 %6, i32* @$Nfds
; # (i64 (set $Nfds (+ Fd 1)))
  %7 = sext i32 %6 to i64
; # (* 8 (i64 (set $Nfds (+ Fd 1))))
  %8 = mul i64 8, %7
; # (alloc (i8* (val $Poll)) (* 8 (i64 (set $Nfds (+ Fd 1)))))
  %9 = call i8* @alloc(i8* %5, i64 %8)
; # (i64* (alloc (i8* (val $Poll)) (* 8 (i64 (set $Nfds (+ Fd 1))))))...
  %10 = bitcast i8* %9 to i64*
  store i64* %10, i64** @$Poll
; # (loop (pollIgn (ofs P I)) (? (== I Fd)) (inc 'I))
  br label %$4
$4:
  %11 = phi i32 [%3, %$2], [%15, %$5] ; # I
; # (ofs P I)
  %12 = getelementptr i64, i64* %10, i32 %11
; # (pollIgn (ofs P I))
  call void @pollIgn(i64* %12)
; # (? (== I Fd))
; # (== I Fd)
  %13 = icmp eq i32 %11, %0
  br i1 %13, label %$6, label %$5
$5:
  %14 = phi i32 [%11, %$4] ; # I
; # (inc 'I)
  %15 = add i32 %14, 1
  br label %$4
$6:
  %16 = phi i32 [%11, %$4] ; # I
  %17 = phi i64 [0, %$4] ; # ->
  br label %$3
$3:
  %18 = phi i32 [%1, %$1], [%16, %$6] ; # I
; # (val $Poll)
  %19 = load i64*, i64** @$Poll
; # (ofs (val $Poll) Fd)
  %20 = getelementptr i64, i64* %19, i32 %0
  ret i64* %20
}

define i1 @hasData(i32) align 8 {
$1:
; # (and (> (val $InFDs) Fd) (val (ofs (val $InFiles) Fd)) (let In: (...
; # (val $InFDs)
  %1 = load i32, i32* @$InFDs
; # (> (val $InFDs) Fd)
  %2 = icmp sgt i32 %1, %0
  br i1 %2, label %$3, label %$2
$3:
; # (val $InFiles)
  %3 = load i8**, i8*** @$InFiles
; # (ofs (val $InFiles) Fd)
  %4 = getelementptr i8*, i8** %3, i32 %0
; # (val (ofs (val $InFiles) Fd))
  %5 = load i8*, i8** %4
  %6 = icmp ne i8* %5, null
  br i1 %6, label %$4, label %$2
$4:
; # (let In: (inFile @) (and (ge0 (In: fd)) (> (In: cnt) (In: ix))))
; # (and (ge0 (In: fd)) (> (In: cnt) (In: ix)))
; # (In: fd)
  %7 = getelementptr i8, i8* %5, i32 8
  %8 = bitcast i8* %7 to i32*
  %9 = load i32, i32* %8
; # (ge0 (In: fd))
  %10 = icmp sge i32 %9, 0
  br i1 %10, label %$6, label %$5
$6:
; # (In: cnt)
  %11 = getelementptr i8, i8* %5, i32 28
  %12 = bitcast i8* %11 to i32*
  %13 = load i32, i32* %12
; # (In: ix)
  %14 = getelementptr i8, i8* %5, i32 24
  %15 = bitcast i8* %14 to i32*
  %16 = load i32, i32* %15
; # (> (In: cnt) (In: ix))
  %17 = icmp sgt i32 %13, %16
  br label %$5
$5:
  %18 = phi i1 [0, %$4], [%17, %$6] ; # ->
  br label %$2
$2:
  %19 = phi i1 [0, %$1], [0, %$3], [%18, %$5] ; # ->
  ret i1 %19
}

define i1 @inReady(i32, i1) align 8 {
$1:
; # (let P (pollfd Fd) (cond ((>= Fd (val $InFDs)) (readyIn P)) ((=0 ...
; # (pollfd Fd)
  %2 = call i64* @pollfd(i32 %0)
; # (cond ((>= Fd (val $InFDs)) (readyIn P)) ((=0 (val (ofs (val $InF...
; # (val $InFDs)
  %3 = load i32, i32* @$InFDs
; # (>= Fd (val $InFDs))
  %4 = icmp sge i32 %0, %3
  br i1 %4, label %$4, label %$3
$4:
; # (readyIn P)
  %5 = call i1 @readyIn(i64* %2)
  br label %$2
$3:
; # (val $InFiles)
  %6 = load i8**, i8*** @$InFiles
; # (ofs (val $InFiles) Fd)
  %7 = getelementptr i8*, i8** %6, i32 %0
; # (val (ofs (val $InFiles) Fd))
  %8 = load i8*, i8** %7
; # (=0 (val (ofs (val $InFiles) Fd)))
  %9 = icmp eq i8* %8, null
  br i1 %9, label %$6, label %$5
$6:
; # (readyIn P)
  %10 = call i1 @readyIn(i64* %2)
  br label %$2
$5:
; # (let In: (inFile @) (if (lt0 (In: fd)) (readyIn P) (or (> (In: cn...
; # (if (lt0 (In: fd)) (readyIn P) (or (> (In: cnt) (In: ix)) (and (r...
; # (In: fd)
  %11 = getelementptr i8, i8* %8, i32 8
  %12 = bitcast i8* %11 to i32*
  %13 = load i32, i32* %12
; # (lt0 (In: fd))
  %14 = icmp slt i32 %13, 0
  br i1 %14, label %$7, label %$8
$7:
; # (readyIn P)
  %15 = call i1 @readyIn(i64* %2)
  br label %$9
$8:
; # (or (> (In: cnt) (In: ix)) (and (readyIn P) (or Flg (ge0 (slowNb ...
; # (In: cnt)
  %16 = getelementptr i8, i8* %8, i32 28
  %17 = bitcast i8* %16 to i32*
  %18 = load i32, i32* %17
; # (In: ix)
  %19 = getelementptr i8, i8* %8, i32 24
  %20 = bitcast i8* %19 to i32*
  %21 = load i32, i32* %20
; # (> (In: cnt) (In: ix))
  %22 = icmp sgt i32 %18, %21
  br i1 %22, label %$10, label %$11
$11:
; # (and (readyIn P) (or Flg (ge0 (slowNb (In:)))))
; # (readyIn P)
  %23 = call i1 @readyIn(i64* %2)
  br i1 %23, label %$13, label %$12
$13:
; # (or Flg (ge0 (slowNb (In:))))
  br i1 %1, label %$14, label %$15
$15:
; # (In:)
; # (slowNb (In:))
  %24 = call i32 @slowNb(i8* %8)
; # (ge0 (slowNb (In:)))
  %25 = icmp sge i32 %24, 0
  br label %$14
$14:
  %26 = phi i1 [1, %$13], [%25, %$15] ; # ->
  br label %$12
$12:
  %27 = phi i1 [0, %$11], [%26, %$14] ; # ->
  br label %$10
$10:
  %28 = phi i1 [1, %$8], [%27, %$12] ; # ->
  br label %$9
$9:
  %29 = phi i1 [%15, %$7], [%28, %$10] ; # ->
  br label %$2
$2:
  %30 = phi i1 [%5, %$4], [%10, %$6], [%29, %$9] ; # ->
  ret i1 %30
}

define i32 @getBlk() align 8 {
$1:
; # (let P (val $BlkPtr) (set $BlkPtr (inc P)) (i32 (val P)))
; # (val $BlkPtr)
  %0 = load i8*, i8** @$BlkPtr
; # (set $BlkPtr (inc P))
; # (inc P)
  %1 = getelementptr i8, i8* %0, i32 1
  store i8* %1, i8** @$BlkPtr
; # (val P)
  %2 = load i8, i8* %0
; # (i32 (val P))
  %3 = zext i8 %2 to i32
  ret i32 %3
}

define i64 @waitFd(i64, i32, i64) align 8 {
$1:
; # (let (Run (save (val $Run)) At (save (val $At)) Buf (b8 (val Pipe...
; # (val $Run)
  %3 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 600) to i64) to i64*
  %4 = load i64, i64* %3
; # (save (val $Run))
  %5 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %6 = load i64, i64* %5
  %7 = alloca i64, i64 2, align 16
  %8 = ptrtoint i64* %7 to i64
  %9 = inttoptr i64 %8 to i64*
  store i64 %4, i64* %9
  %10 = add i64 %8, 8
  %11 = inttoptr i64 %10 to i64*
  store i64 %6, i64* %11
  %12 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %8, i64* %12
; # (val $At)
  %13 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  %14 = load i64, i64* %13
; # (save (val $At))
  %15 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %16 = load i64, i64* %15
  %17 = alloca i64, i64 2, align 16
  %18 = ptrtoint i64* %17 to i64
  %19 = inttoptr i64 %18 to i64*
  store i64 %14, i64* %19
  %20 = add i64 %18, 8
  %21 = inttoptr i64 %20 to i64*
  store i64 %16, i64* %21
  %22 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %18, i64* %22
; # (val PipeBufSize)
  %23 = load i32, i32* @PipeBufSize
; # (b8 (val PipeBufSize))
  %24 = alloca i8, i32 %23
; # (b32 2)
  %25 = alloca i32, i64 2
; # (getMsec)
  %26 = call i64 @getMsec()
; # (stkChk Exe)
  %27 = load i8*, i8** @$StkLimit
  %28 = call i8* @llvm.stacksave()
  %29 = icmp ugt i8* %27, %28
  br i1 %29, label %$2, label %$3
$2:
  call void @stkErr(i64 %0)
  unreachable
$3:
; # (loop (let Dly Ms (when (ge0 Fd) (if (hasData Fd) (setq Dly 0) (p...
  br label %$4
$4:
  %30 = phi i64 [%2, %$3], [%869, %$140] ; # Ms
  %31 = phi i64 [%4, %$3], [%873, %$140] ; # Run
  %32 = phi i64 [%26, %$3], [%871, %$140] ; # Tim
; # (let Dly Ms (when (ge0 Fd) (if (hasData Fd) (setq Dly 0) (pollIn ...
; # (when (ge0 Fd) (if (hasData Fd) (setq Dly 0) (pollIn Fd (pollfd F...
; # (ge0 Fd)
  %33 = icmp sge i32 %1, 0
  br i1 %33, label %$5, label %$6
$5:
  %34 = phi i64 [%30, %$4] ; # Ms
  %35 = phi i64 [%31, %$4] ; # Run
  %36 = phi i64 [%32, %$4] ; # Tim
  %37 = phi i64 [%30, %$4] ; # Dly
; # (if (hasData Fd) (setq Dly 0) (pollIn Fd (pollfd Fd)))
; # (hasData Fd)
  %38 = call i1 @hasData(i32 %1)
  br i1 %38, label %$7, label %$8
$7:
  %39 = phi i64 [%34, %$5] ; # Ms
  %40 = phi i64 [%35, %$5] ; # Run
  %41 = phi i64 [%36, %$5] ; # Tim
  %42 = phi i64 [%37, %$5] ; # Dly
  br label %$9
$8:
  %43 = phi i64 [%34, %$5] ; # Ms
  %44 = phi i64 [%35, %$5] ; # Run
  %45 = phi i64 [%36, %$5] ; # Tim
  %46 = phi i64 [%37, %$5] ; # Dly
; # (pollfd Fd)
  %47 = call i64* @pollfd(i32 %1)
; # (pollIn Fd (pollfd Fd))
  call void @pollIn(i32 %1, i64* %47)
  br label %$9
$9:
  %48 = phi i64 [%39, %$7], [%43, %$8] ; # Ms
  %49 = phi i64 [%40, %$7], [%44, %$8] ; # Run
  %50 = phi i64 [%41, %$7], [%45, %$8] ; # Tim
  %51 = phi i64 [0, %$7], [%46, %$8] ; # Dly
  br label %$6
$6:
  %52 = phi i64 [%30, %$4], [%48, %$9] ; # Ms
  %53 = phi i64 [%31, %$4], [%49, %$9] ; # Run
  %54 = phi i64 [%32, %$4], [%50, %$9] ; # Tim
  %55 = phi i64 [%30, %$4], [%51, %$9] ; # Dly
; # (let R Run (while (pair R) (let X (++ R) (cond ((sign? (car X)) (...
; # (while (pair R) (let X (++ R) (cond ((sign? (car X)) (let N (int ...
  br label %$10
$10:
  %56 = phi i64 [%52, %$6], [%133, %$13] ; # Ms
  %57 = phi i64 [%53, %$6], [%134, %$13] ; # Run
  %58 = phi i64 [%54, %$6], [%135, %$13] ; # Tim
  %59 = phi i64 [%55, %$6], [%136, %$13] ; # Dly
  %60 = phi i64 [%53, %$6], [%137, %$13] ; # R
; # (pair R)
  %61 = and i64 %60, 15
  %62 = icmp eq i64 %61, 0
  br i1 %62, label %$11, label %$12
$11:
  %63 = phi i64 [%56, %$10] ; # Ms
  %64 = phi i64 [%57, %$10] ; # Run
  %65 = phi i64 [%58, %$10] ; # Tim
  %66 = phi i64 [%59, %$10] ; # Dly
  %67 = phi i64 [%60, %$10] ; # R
; # (let X (++ R) (cond ((sign? (car X)) (let N (int (cadr X)) (when ...
; # (++ R)
  %68 = inttoptr i64 %67 to i64*
  %69 = load i64, i64* %68
  %70 = getelementptr i64, i64* %68, i32 1
  %71 = load i64, i64* %70
; # (cond ((sign? (car X)) (let N (int (cadr X)) (when (> Dly N) (set...
; # (car X)
  %72 = inttoptr i64 %69 to i64*
  %73 = load i64, i64* %72
; # (sign? (car X))
  %74 = and i64 %73, 8
  %75 = icmp ne i64 %74, 0
  br i1 %75, label %$15, label %$14
$15:
  %76 = phi i64 [%63, %$11] ; # Ms
  %77 = phi i64 [%64, %$11] ; # Run
  %78 = phi i64 [%65, %$11] ; # Tim
  %79 = phi i64 [%66, %$11] ; # Dly
  %80 = phi i64 [%71, %$11] ; # R
; # (let N (int (cadr X)) (when (> Dly N) (setq Dly N)))
; # (cadr X)
  %81 = inttoptr i64 %69 to i64*
  %82 = getelementptr i64, i64* %81, i32 1
  %83 = load i64, i64* %82
  %84 = inttoptr i64 %83 to i64*
  %85 = load i64, i64* %84
; # (int (cadr X))
  %86 = lshr i64 %85, 4
; # (when (> Dly N) (setq Dly N))
; # (> Dly N)
  %87 = icmp ugt i64 %79, %86
  br i1 %87, label %$16, label %$17
$16:
  %88 = phi i64 [%76, %$15] ; # Ms
  %89 = phi i64 [%77, %$15] ; # Run
  %90 = phi i64 [%78, %$15] ; # Tim
  %91 = phi i64 [%79, %$15] ; # Dly
  %92 = phi i64 [%80, %$15] ; # R
  br label %$17
$17:
  %93 = phi i64 [%76, %$15], [%88, %$16] ; # Ms
  %94 = phi i64 [%77, %$15], [%89, %$16] ; # Run
  %95 = phi i64 [%78, %$15], [%90, %$16] ; # Tim
  %96 = phi i64 [%79, %$15], [%86, %$16] ; # Dly
  %97 = phi i64 [%80, %$15], [%92, %$16] ; # R
  br label %$13
$14:
  %98 = phi i64 [%63, %$11] ; # Ms
  %99 = phi i64 [%64, %$11] ; # Run
  %100 = phi i64 [%65, %$11] ; # Tim
  %101 = phi i64 [%66, %$11] ; # Dly
  %102 = phi i64 [%71, %$11] ; # R
; # (int @)
  %103 = lshr i64 %73, 4
; # (i32 (int @))
  %104 = trunc i64 %103 to i32
; # (<> (i32 (int @)) Fd)
  %105 = icmp ne i32 %104, %1
  br i1 %105, label %$19, label %$18
$19:
  %106 = phi i64 [%98, %$14] ; # Ms
  %107 = phi i64 [%99, %$14] ; # Run
  %108 = phi i64 [%100, %$14] ; # Tim
  %109 = phi i64 [%101, %$14] ; # Dly
  %110 = phi i64 [%102, %$14] ; # R
; # (let N @ (if (hasData N) (setq Dly 0) (pollIn N (pollfd N))))
; # (if (hasData N) (setq Dly 0) (pollIn N (pollfd N)))
; # (hasData N)
  %111 = call i1 @hasData(i32 %104)
  br i1 %111, label %$20, label %$21
$20:
  %112 = phi i64 [%106, %$19] ; # Ms
  %113 = phi i64 [%107, %$19] ; # Run
  %114 = phi i64 [%108, %$19] ; # Tim
  %115 = phi i64 [%109, %$19] ; # Dly
  %116 = phi i64 [%110, %$19] ; # R
  br label %$22
$21:
  %117 = phi i64 [%106, %$19] ; # Ms
  %118 = phi i64 [%107, %$19] ; # Run
  %119 = phi i64 [%108, %$19] ; # Tim
  %120 = phi i64 [%109, %$19] ; # Dly
  %121 = phi i64 [%110, %$19] ; # R
; # (pollfd N)
  %122 = call i64* @pollfd(i32 %104)
; # (pollIn N (pollfd N))
  call void @pollIn(i32 %104, i64* %122)
  br label %$22
$22:
  %123 = phi i64 [%112, %$20], [%117, %$21] ; # Ms
  %124 = phi i64 [%113, %$20], [%118, %$21] ; # Run
  %125 = phi i64 [%114, %$20], [%119, %$21] ; # Tim
  %126 = phi i64 [0, %$20], [%120, %$21] ; # Dly
  %127 = phi i64 [%116, %$20], [%121, %$21] ; # R
  br label %$13
$18:
  %128 = phi i64 [%98, %$14] ; # Ms
  %129 = phi i64 [%99, %$14] ; # Run
  %130 = phi i64 [%100, %$14] ; # Tim
  %131 = phi i64 [%101, %$14] ; # Dly
  %132 = phi i64 [%102, %$14] ; # R
  br label %$13
$13:
  %133 = phi i64 [%93, %$17], [%123, %$22], [%128, %$18] ; # Ms
  %134 = phi i64 [%94, %$17], [%124, %$22], [%129, %$18] ; # Run
  %135 = phi i64 [%95, %$17], [%125, %$22], [%130, %$18] ; # Tim
  %136 = phi i64 [%96, %$17], [%126, %$22], [%131, %$18] ; # Dly
  %137 = phi i64 [%97, %$17], [%127, %$22], [%132, %$18] ; # R
  br label %$10
$12:
  %138 = phi i64 [%56, %$10] ; # Ms
  %139 = phi i64 [%57, %$10] ; # Run
  %140 = phi i64 [%58, %$10] ; # Tim
  %141 = phi i64 [%59, %$10] ; # Dly
  %142 = phi i64 [%60, %$10] ; # R
; # (when (and (val $Hear) (<> @ Fd)) (let N @ (if (hasData N) (setq ...
; # (and (val $Hear) (<> @ Fd))
; # (val $Hear)
  %143 = load i32, i32* @$Hear
  %144 = icmp ne i32 %143, 0
  br i1 %144, label %$24, label %$23
$24:
  %145 = phi i64 [%138, %$12] ; # Ms
  %146 = phi i64 [%139, %$12] ; # Run
  %147 = phi i64 [%140, %$12] ; # Tim
  %148 = phi i64 [%141, %$12] ; # Dly
; # (<> @ Fd)
  %149 = icmp ne i32 %143, %1
  br label %$23
$23:
  %150 = phi i64 [%138, %$12], [%145, %$24] ; # Ms
  %151 = phi i64 [%139, %$12], [%146, %$24] ; # Run
  %152 = phi i64 [%140, %$12], [%147, %$24] ; # Tim
  %153 = phi i64 [%141, %$12], [%148, %$24] ; # Dly
  %154 = phi i1 [0, %$12], [%149, %$24] ; # ->
  br i1 %154, label %$25, label %$26
$25:
  %155 = phi i64 [%150, %$23] ; # Ms
  %156 = phi i64 [%151, %$23] ; # Run
  %157 = phi i64 [%152, %$23] ; # Tim
  %158 = phi i64 [%153, %$23] ; # Dly
; # (let N @ (if (hasData N) (setq Dly 0) (pollIn N (pollfd N))))
; # (if (hasData N) (setq Dly 0) (pollIn N (pollfd N)))
; # (hasData N)
  %159 = call i1 @hasData(i32 %143)
  br i1 %159, label %$27, label %$28
$27:
  %160 = phi i64 [%155, %$25] ; # Ms
  %161 = phi i64 [%156, %$25] ; # Run
  %162 = phi i64 [%157, %$25] ; # Tim
  %163 = phi i64 [%158, %$25] ; # Dly
  br label %$29
$28:
  %164 = phi i64 [%155, %$25] ; # Ms
  %165 = phi i64 [%156, %$25] ; # Run
  %166 = phi i64 [%157, %$25] ; # Tim
  %167 = phi i64 [%158, %$25] ; # Dly
; # (pollfd N)
  %168 = call i64* @pollfd(i32 %143)
; # (pollIn N (pollfd N))
  call void @pollIn(i32 %143, i64* %168)
  br label %$29
$29:
  %169 = phi i64 [%160, %$27], [%164, %$28] ; # Ms
  %170 = phi i64 [%161, %$27], [%165, %$28] ; # Run
  %171 = phi i64 [%162, %$27], [%166, %$28] ; # Tim
  %172 = phi i64 [0, %$27], [%167, %$28] ; # Dly
  br label %$26
$26:
  %173 = phi i64 [%150, %$23], [%169, %$29] ; # Ms
  %174 = phi i64 [%151, %$23], [%170, %$29] ; # Run
  %175 = phi i64 [%152, %$23], [%171, %$29] ; # Tim
  %176 = phi i64 [%153, %$23], [%172, %$29] ; # Dly
; # (when (val $Spkr) (pollIn @ (pollfd @)) (let (Cld (val $Child)  (val 2 Pn) (val PipeBufSize))
  %365 = icmp sgt i32 %363, %364
  br i1 %365, label %$66, label %$65
$66:
  %366 = phi i64 [%358, %$61] ; # Ms
  %367 = phi i64 [%359, %$61] ; # Run
  %368 = phi i64 [%360, %$61] ; # Tim
  %369 = phi i8* [%361, %$61] ; # Cld
; # (sizeErr Exe)
  call void @sizeErr(i64 %0)
  unreachable
$65:
  %370 = phi i64 [%358, %$61] ; # Ms
  %371 = phi i64 [%359, %$61] ; # Run
  %372 = phi i64 [%360, %$61] ; # Tim
  %373 = phi i8* [%361, %$61] ; # Cld
; # (Cld: hear)
  %374 = getelementptr i8, i8* %301, i32 20
  %375 = bitcast i8* %374 to i32*
  %376 = load i32, i32* %375
; # (rdBytes (Cld: hear) Buf @)
  %377 = call i1 @rdBytes(i32 %376, i8* %24, i32 %363)
  br i1 %377, label %$68, label %$67
$68:
  %378 = phi i64 [%370, %$65] ; # Ms
  %379 = phi i64 [%371, %$65] ; # Run
  %380 = phi i64 [%372, %$65] ; # Tim
  %381 = phi i8* [%373, %$65] ; # Cld
; # (ifn (=0 (val Pn)) (let (Cld2 (val $Child)  Cld...
  br label %$72
$72:
  %392 = phi i64 [%384, %$69], [%448, %$81] ; # Ms
  %393 = phi i64 [%385, %$69], [%449, %$81] ; # Run
  %394 = phi i64 [%386, %$69], [%450, %$81] ; # Tim
  %395 = phi i8* [%387, %$69], [%451, %$81] ; # Cld
  %396 = phi i8* [%388, %$69], [%453, %$81] ; # Cld2
; # (== Cld2  Cld Cld2) (Cld2: pid) (or ...
; # (when (and (<> Cld Cld2) (Cld2: pid) (or (lt0 (val Pn)) (== @ (Cl...
; # (and (<> Cld Cld2) (Cld2: pid) (or (lt0 (val Pn)) (== @ (Cld2: pi...
; # (<> Cld Cld2)
  %403 = icmp ne i8* %401, %402
  br i1 %403, label %$76, label %$75
$76:
  %404 = phi i64 [%398, %$73] ; # Ms
  %405 = phi i64 [%399, %$73] ; # Run
  %406 = phi i64 [%400, %$73] ; # Tim
  %407 = phi i8* [%401, %$73] ; # Cld
  %408 = phi i8* [%402, %$73] ; # Cld2
; # (Cld2: pid)
  %409 = getelementptr i8, i8* %402, i32 16
  %410 = bitcast i8* %409 to i32*
  %411 = load i32, i32* %410
  %412 = icmp ne i32 %411, 0
  br i1 %412, label %$77, label %$75
$77:
  %413 = phi i64 [%404, %$76] ; # Ms
  %414 = phi i64 [%405, %$76] ; # Run
  %415 = phi i64 [%406, %$76] ; # Tim
  %416 = phi i8* [%407, %$76] ; # Cld
  %417 = phi i8* [%408, %$76] ; # Cld2
; # (or (lt0 (val Pn)) (== @ (Cld2: pid)))
; # (val Pn)
  %418 = load i32, i32* %25
; # (lt0 (val Pn))
  %419 = icmp slt i32 %418, 0
  br i1 %419, label %$78, label %$79
$79:
  %420 = phi i64 [%413, %$77] ; # Ms
  %421 = phi i64 [%414, %$77] ; # Run
  %422 = phi i64 [%415, %$77] ; # Tim
  %423 = phi i8* [%416, %$77] ; # Cld
  %424 = phi i8* [%417, %$77] ; # Cld2
; # (Cld2: pid)
  %425 = getelementptr i8, i8* %402, i32 16
  %426 = bitcast i8* %425 to i32*
  %427 = load i32, i32* %426
; # (== @ (Cld2: pid))
  %428 = icmp eq i32 %418, %427
  br label %$78
$78:
  %429 = phi i64 [%413, %$77], [%420, %$79] ; # Ms
  %430 = phi i64 [%414, %$77], [%421, %$79] ; # Run
  %431 = phi i64 [%415, %$77], [%422, %$79] ; # Tim
  %432 = phi i8* [%416, %$77], [%423, %$79] ; # Cld
  %433 = phi i8* [%417, %$77], [%424, %$79] ; # Cld2
  %434 = phi i1 [1, %$77], [%428, %$79] ; # ->
  br label %$75
$75:
  %435 = phi i64 [%398, %$73], [%404, %$76], [%429, %$78] ; # Ms
  %436 = phi i64 [%399, %$73], [%405, %$76], [%430, %$78] ; # Run
  %437 = phi i64 [%400, %$73], [%406, %$76], [%431, %$78] ; # Tim
  %438 = phi i8* [%401, %$73], [%407, %$76], [%432, %$78] ; # Cld
  %439 = phi i8* [%402, %$73], [%408, %$76], [%433, %$78] ; # Cld2
  %440 = phi i1 [0, %$73], [0, %$76], [%434, %$78] ; # ->
  br i1 %440, label %$80, label %$81
$80:
  %441 = phi i64 [%435, %$75] ; # Ms
  %442 = phi i64 [%436, %$75] ; # Run
  %443 = phi i64 [%437, %$75] ; # Tim
  %444 = phi i8* [%438, %$75] ; # Cld
  %445 = phi i8* [%439, %$75] ; # Cld2
; # (val 2 Pn)
  %446 = getelementptr i32, i32* %25, i32 1
  %447 = load i32, i32* %446
; # (wrChild Cld2 Buf (val 2 Pn))
  call void @wrChild(i8* %445, i8* %24, i32 %447)
  br label %$81
$81:
  %448 = phi i64 [%435, %$75], [%441, %$80] ; # Ms
  %449 = phi i64 [%436, %$75], [%442, %$80] ; # Run
  %450 = phi i64 [%437, %$75], [%443, %$80] ; # Tim
  %451 = phi i8* [%438, %$75], [%444, %$80] ; # Cld
  %452 = phi i8* [%439, %$75], [%445, %$80] ; # Cld2
; # (ofs Cld2 (child T))
  %453 = getelementptr i8, i8* %452, i32 32
  br label %$72
$74:
  %454 = phi i64 [%392, %$72] ; # Ms
  %455 = phi i64 [%393, %$72] ; # Run
  %456 = phi i64 [%394, %$72] ; # Tim
  %457 = phi i8* [%395, %$72] ; # Cld
  %458 = phi i8* [%396, %$72] ; # Cld2
  br label %$71
$70:
  %459 = phi i64 [%378, %$68] ; # Ms
  %460 = phi i64 [%379, %$68] ; # Run
  %461 = phi i64 [%380, %$68] ; # Tim
  %462 = phi i8* [%381, %$68] ; # Cld
; # (set $BlkPtr Buf $GetBin (fun (i32) getBlk) $Extn 0)
  store i8* %24, i8** @$BlkPtr
; # (fun (i32) getBlk)
  store i32()* @getBlk, i32()** @$GetBin
  store i32 0, i32* @$Extn
; # (let E (binRead) (save E (evList E)))
; # (binRead)
  %463 = call i64 @binRead()
; # (save E (evList E))
  %464 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %465 = load i64, i64* %464
  %466 = alloca i64, i64 2, align 16
  %467 = ptrtoint i64* %466 to i64
  %468 = inttoptr i64 %467 to i64*
  store i64 %463, i64* %468
  %469 = add i64 %467, 8
  %470 = inttoptr i64 %469 to i64*
  store i64 %465, i64* %470
  %471 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %467, i64* %471
; # (evList E)
  %472 = call i64 @evList(i64 %463)
; # drop
  %473 = inttoptr i64 %467 to i64*
  %474 = getelementptr i64, i64* %473, i32 1
  %475 = load i64, i64* %474
  %476 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %475, i64* %476
  br label %$71
$71:
  %477 = phi i64 [%454, %$74], [%459, %$70] ; # Ms
  %478 = phi i64 [%455, %$74], [%460, %$70] ; # Run
  %479 = phi i64 [%456, %$74], [%461, %$70] ; # Tim
  %480 = phi i8* [%457, %$74], [%462, %$70] ; # Cld
  br label %$60
$67:
  %481 = phi i64 [%370, %$65] ; # Ms
  %482 = phi i64 [%371, %$65] ; # Run
  %483 = phi i64 [%372, %$65] ; # Tim
  %484 = phi i8* [%373, %$65] ; # Cld
; # (clsChild Cld)
  call void @clsChild(i8* %484)
; # (goto 1)
  br label %$-1
$60:
  %485 = phi i64 [%354, %$64], [%477, %$71] ; # Ms
  %486 = phi i64 [%355, %$64], [%478, %$71] ; # Run
  %487 = phi i64 [%356, %$64], [%479, %$71] ; # Tim
  %488 = phi i8* [%357, %$64], [%480, %$71] ; # Cld
  br label %$55
$58:
  %489 = phi i64 [%329, %$56] ; # Ms
  %490 = phi i64 [%330, %$56] ; # Run
  %491 = phi i64 [%331, %$56] ; # Tim
  %492 = phi i8* [%332, %$56] ; # Cld
  br label %$55
$55:
  %493 = phi i64 [%485, %$60], [%489, %$58] ; # Ms
  %494 = phi i64 [%486, %$60], [%490, %$58] ; # Run
  %495 = phi i64 [%487, %$60], [%491, %$58] ; # Tim
  %496 = phi i8* [%488, %$60], [%492, %$58] ; # Cld
  br label %$54
$54:
  %497 = phi i64 [%306, %$51], [%493, %$55] ; # Ms
  %498 = phi i64 [%307, %$51], [%494, %$55] ; # Run
  %499 = phi i64 [%308, %$51], [%495, %$55] ; # Tim
  %500 = phi i8* [%309, %$51], [%496, %$55] ; # Cld
; # (when (readyOut (pollfd (Cld: tell))) (let (P (ofs (Cld: buf) (Cl...
; # (Cld: tell)
  %501 = getelementptr i8, i8* %301, i32 24
  %502 = bitcast i8* %501 to i32*
  %503 = load i32, i32* %502
; # (pollfd (Cld: tell))
  %504 = call i64* @pollfd(i32 %503)
; # (readyOut (pollfd (Cld: tell)))
  %505 = call i1 @readyOut(i64* %504)
  br i1 %505, label %$82, label %$83
$82:
  %506 = phi i64 [%497, %$54] ; # Ms
  %507 = phi i64 [%498, %$54] ; # Run
  %508 = phi i64 [%499, %$54] ; # Tim
  %509 = phi i8* [%500, %$54] ; # Cld
; # (let (P (ofs (Cld: buf) (Cld: ofs)) N (val (i32* P))) (ifn (wrByt...
; # (Cld: buf)
  %510 = bitcast i8* %301 to i8**
  %511 = load i8*, i8** %510
; # (Cld: ofs)
  %512 = getelementptr i8, i8* %301, i32 8
  %513 = bitcast i8* %512 to i32*
  %514 = load i32, i32* %513
; # (ofs (Cld: buf) (Cld: ofs))
  %515 = getelementptr i8, i8* %511, i32 %514
; # (i32* P)
  %516 = bitcast i8* %515 to i32*
; # (val (i32* P))
  %517 = load i32, i32* %516
; # (ifn (wrBytes (Cld: tell) (ofs P 4) N) (clsChild Cld) (setq N (Cl...
; # (Cld: tell)
  %518 = getelementptr i8, i8* %301, i32 24
  %519 = bitcast i8* %518 to i32*
  %520 = load i32, i32* %519
; # (ofs P 4)
  %521 = getelementptr i8, i8* %515, i32 4
; # (wrBytes (Cld: tell) (ofs P 4) N)
  %522 = call i1 @wrBytes(i32 %520, i8* %521, i32 %517)
  br i1 %522, label %$85, label %$84
$84:
  %523 = phi i64 [%506, %$82] ; # Ms
  %524 = phi i64 [%507, %$82] ; # Run
  %525 = phi i64 [%508, %$82] ; # Tim
  %526 = phi i8* [%509, %$82] ; # Cld
  %527 = phi i32 [%517, %$82] ; # N
; # (clsChild Cld)
  call void @clsChild(i8* %526)
  br label %$86
$85:
  %528 = phi i64 [%506, %$82] ; # Ms
  %529 = phi i64 [%507, %$82] ; # Run
  %530 = phi i64 [%508, %$82] ; # Tim
  %531 = phi i8* [%509, %$82] ; # Cld
  %532 = phi i32 [%517, %$82] ; # N
; # (Cld: ofs (+ (Cld: ofs) N 4))
  %533 = getelementptr i8, i8* %301, i32 8
  %534 = bitcast i8* %533 to i32*
  %535 = getelementptr i8, i8* %301, i32 8
  %536 = bitcast i8* %535 to i32*
  %537 = load i32, i32* %536
  %538 = add i32 %537, %532
  %539 = add i32 %538, 4
  store i32 %539, i32* %534
; # (when (>= (* 2 N) (Cld: cnt)) (when (Cld: cnt (- (Cld: cnt) N)) (...
; # (* 2 N)
  %540 = mul i32 2, %539
; # (Cld: cnt)
  %541 = getelementptr i8, i8* %301, i32 12
  %542 = bitcast i8* %541 to i32*
  %543 = load i32, i32* %542
; # (>= (* 2 N) (Cld: cnt))
  %544 = icmp sge i32 %540, %543
  br i1 %544, label %$87, label %$88
$87:
  %545 = phi i64 [%528, %$85] ; # Ms
  %546 = phi i64 [%529, %$85] ; # Run
  %547 = phi i64 [%530, %$85] ; # Tim
  %548 = phi i8* [%531, %$85] ; # Cld
  %549 = phi i32 [%539, %$85] ; # N
; # (when (Cld: cnt (- (Cld: cnt) N)) (memcpy (Cld: buf) (ofs (Cld: b...
; # (Cld: cnt (- (Cld: cnt) N))
  %550 = getelementptr i8, i8* %301, i32 12
  %551 = bitcast i8* %550 to i32*
  %552 = getelementptr i8, i8* %301, i32 12
  %553 = bitcast i8* %552 to i32*
  %554 = load i32, i32* %553
  %555 = sub i32 %554, %549
  store i32 %555, i32* %551
  %556 = icmp ne i32 %555, 0
  br i1 %556, label %$89, label %$90
$89:
  %557 = phi i64 [%545, %$87] ; # Ms
  %558 = phi i64 [%546, %$87] ; # Run
  %559 = phi i64 [%547, %$87] ; # Tim
  %560 = phi i8* [%548, %$87] ; # Cld
  %561 = phi i32 [%549, %$87] ; # N
; # (Cld: buf)
  %562 = bitcast i8* %301 to i8**
  %563 = load i8*, i8** %562
; # (Cld: buf)
  %564 = bitcast i8* %301 to i8**
  %565 = load i8*, i8** %564
; # (ofs (Cld: buf) N)
  %566 = getelementptr i8, i8* %565, i32 %561
; # (Cld: cnt)
  %567 = getelementptr i8, i8* %301, i32 12
  %568 = bitcast i8* %567 to i32*
  %569 = load i32, i32* %568
; # (i64 (Cld: cnt))
  %570 = sext i32 %569 to i64
; # (memcpy (Cld: buf) (ofs (Cld: buf) N) (i64 (Cld: cnt)))
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* %563, i8* %566, i64 %570, i1 0)
; # (Cld: buf (alloc (Cld: buf) (i64 (Cld: cnt))))
  %571 = bitcast i8* %301 to i8**
  %572 = bitcast i8* %301 to i8**
  %573 = load i8*, i8** %572
  %574 = getelementptr i8, i8* %301, i32 12
  %575 = bitcast i8* %574 to i32*
  %576 = load i32, i32* %575
  %577 = sext i32 %576 to i64
  %578 = call i8* @alloc(i8* %573, i64 %577)
  store i8* %578, i8** %571
  br label %$90
$90:
  %579 = phi i64 [%545, %$87], [%557, %$89] ; # Ms
  %580 = phi i64 [%546, %$87], [%558, %$89] ; # Run
  %581 = phi i64 [%547, %$87], [%559, %$89] ; # Tim
  %582 = phi i8* [%548, %$87], [%560, %$89] ; # Cld
  %583 = phi i32 [%549, %$87], [%561, %$89] ; # N
; # (Cld: ofs 0)
  %584 = getelementptr i8, i8* %301, i32 8
  %585 = bitcast i8* %584 to i32*
  store i32 0, i32* %585
  br label %$88
$88:
  %586 = phi i64 [%528, %$85], [%579, %$90] ; # Ms
  %587 = phi i64 [%529, %$85], [%580, %$90] ; # Run
  %588 = phi i64 [%530, %$85], [%581, %$90] ; # Tim
  %589 = phi i8* [%531, %$85], [%582, %$90] ; # Cld
  %590 = phi i32 [%539, %$85], [%583, %$90] ; # N
  br label %$86
$86:
  %591 = phi i64 [%523, %$84], [%586, %$88] ; # Ms
  %592 = phi i64 [%524, %$84], [%587, %$88] ; # Run
  %593 = phi i64 [%525, %$84], [%588, %$88] ; # Tim
  %594 = phi i8* [%526, %$84], [%589, %$88] ; # Cld
  %595 = phi i32 [%527, %$84], [%590, %$88] ; # N
  br label %$83
$83:
  %596 = phi i64 [%497, %$54], [%591, %$86] ; # Ms
  %597 = phi i64 [%498, %$54], [%592, %$86] ; # Run
  %598 = phi i64 [%499, %$54], [%593, %$86] ; # Tim
  %599 = phi i8* [%500, %$54], [%594, %$86] ; # Cld
  br label %$52
$52:
  %600 = phi i64 [%298, %$49], [%596, %$83] ; # Ms
  %601 = phi i64 [%299, %$49], [%597, %$83] ; # Run
  %602 = phi i64 [%300, %$49], [%598, %$83] ; # Tim
  %603 = phi i8* [%301, %$49], [%599, %$83] ; # Cld
; # (: 1 (setq Cld (ofs Cld (child T))))
  br label %$-1
$-1:
  %604 = phi i64 [%325, %$57], [%481, %$67], [%600, %$52] ; # Ms
  %605 = phi i64 [%326, %$57], [%482, %$67], [%601, %$52] ; # Run
  %606 = phi i64 [%327, %$57], [%483, %$67], [%602, %$52] ; # Tim
  %607 = phi i8* [%328, %$57], [%484, %$67], [%603, %$52] ; # Cld
; # (ofs Cld (child T))
  %608 = getelementptr i8, i8* %607, i32 32
  br label %$48
$50:
  %609 = phi i64 [%293, %$48] ; # Ms
  %610 = phi i64 [%294, %$48] ; # Run
  %611 = phi i64 [%295, %$48] ; # Tim
  %612 = phi i8* [%296, %$48] ; # Cld
; # (when (and (=0 (val $Talking)) (readyIn (pollfd (val $Spkr))) (gt...
; # (and (=0 (val $Talking)) (readyIn (pollfd (val $Spkr))) (gt0 (rdB...
; # (val $Talking)
  %613 = load i32, i32* @$Talking
; # (=0 (val $Talking))
  %614 = icmp eq i32 %613, 0
  br i1 %614, label %$92, label %$91
$92:
  %615 = phi i64 [%609, %$50] ; # Ms
  %616 = phi i64 [%610, %$50] ; # Run
  %617 = phi i64 [%611, %$50] ; # Tim
; # (val $Spkr)
  %618 = load i32, i32* @$Spkr
; # (pollfd (val $Spkr))
  %619 = call i64* @pollfd(i32 %618)
; # (readyIn (pollfd (val $Spkr)))
  %620 = call i1 @readyIn(i64* %619)
  br i1 %620, label %$93, label %$91
$93:
  %621 = phi i64 [%615, %$92] ; # Ms
  %622 = phi i64 [%616, %$92] ; # Run
  %623 = phi i64 [%617, %$92] ; # Tim
; # (val $Spkr)
  %624 = load i32, i32* @$Spkr
; # (i8* Pn)
  %625 = bitcast i32* %25 to i8*
; # (rdBytesNb (val $Spkr) (i8* Pn) 4)
  %626 = call i64 @rdBytesNb(i32 %624, i8* %625, i32 4)
; # (gt0 (rdBytesNb (val $Spkr) (i8* Pn) 4))
  %627 = icmp sgt i64 %626, 0
  br label %$91
$91:
  %628 = phi i64 [%609, %$50], [%615, %$92], [%621, %$93] ; # Ms
  %629 = phi i64 [%610, %$50], [%616, %$92], [%622, %$93] ; # Run
  %630 = phi i64 [%611, %$50], [%617, %$92], [%623, %$93] ; # Tim
  %631 = phi i1 [0, %$50], [0, %$92], [%627, %$93] ; # ->
  br i1 %631, label %$94, label %$95
$94:
  %632 = phi i64 [%628, %$91] ; # Ms
  %633 = phi i64 [%629, %$91] ; # Run
  %634 = phi i64 [%630, %$91] ; # Tim
; # (let Cld (ofs (val $Child) (* (val Pn) (child T))) (when ((child ...
; # (val $Child)
  %635 = load i8*, i8** @$Child
; # (val Pn)
  %636 = load i32, i32* %25
; # (* (val Pn) (child T))
  %637 = mul i32 %636, 32
; # (ofs (val $Child) (* (val Pn) (child T)))
  %638 = getelementptr i8, i8* %635, i32 %637
; # (when ((child Cld) pid) (set $Talking @) (wrChild Cld $TBuf 2))
; # ((child Cld) pid)
  %639 = getelementptr i8, i8* %638, i32 16
  %640 = bitcast i8* %639 to i32*
  %641 = load i32, i32* %640
  %642 = icmp ne i32 %641, 0
  br i1 %642, label %$96, label %$97
$96:
  %643 = phi i64 [%632, %$94] ; # Ms
  %644 = phi i64 [%633, %$94] ; # Run
  %645 = phi i64 [%634, %$94] ; # Tim
; # (set $Talking @)
  store i32 %641, i32* @$Talking
; # (wrChild Cld $TBuf 2)
  call void @wrChild(i8* %638, i8* bitcast ([2 x i8]* @$TBuf to i8*), i32 2)
  br label %$97
$97:
  %646 = phi i64 [%632, %$94], [%643, %$96] ; # Ms
  %647 = phi i64 [%633, %$94], [%644, %$96] ; # Run
  %648 = phi i64 [%634, %$94], [%645, %$96] ; # Tim
  br label %$95
$95:
  %649 = phi i64 [%628, %$91], [%646, %$97] ; # Ms
  %650 = phi i64 [%629, %$91], [%647, %$97] ; # Run
  %651 = phi i64 [%630, %$91], [%648, %$97] ; # Tim
; # (set $Protect (dec (val $Protect)))
; # (val $Protect)
  %652 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 176) to i32*)
; # (dec (val $Protect))
  %653 = sub i32 %652, 1
  store i32 %653, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 176) to i32*)
  br label %$47
$47:
  %654 = phi i64 [%276, %$41], [%649, %$95] ; # Ms
  %655 = phi i64 [%277, %$41], [%650, %$95] ; # Run
  %656 = phi i64 [%278, %$41], [%651, %$95] ; # Tim
; # (let N (val $Hear) (when (and N (<> N Fd) (inReady N NO)) (let In...
; # (val $Hear)
  %657 = load i32, i32* @$Hear
; # (when (and N (<> N Fd) (inReady N NO)) (let In (val $InFile) (set...
; # (and N (<> N Fd) (inReady N NO))
  %658 = icmp ne i32 %657, 0
  br i1 %658, label %$99, label %$98
$99:
  %659 = phi i64 [%654, %$47] ; # Ms
  %660 = phi i64 [%655, %$47] ; # Run
  %661 = phi i64 [%656, %$47] ; # Tim
; # (<> N Fd)
  %662 = icmp ne i32 %657, %1
  br i1 %662, label %$100, label %$98
$100:
  %663 = phi i64 [%659, %$99] ; # Ms
  %664 = phi i64 [%660, %$99] ; # Run
  %665 = phi i64 [%661, %$99] ; # Tim
; # (inReady N NO)
  %666 = call i1 @inReady(i32 %657, i1 0)
  br label %$98
$98:
  %667 = phi i64 [%654, %$47], [%659, %$99], [%663, %$100] ; # Ms
  %668 = phi i64 [%655, %$47], [%660, %$99], [%664, %$100] ; # Run
  %669 = phi i64 [%656, %$47], [%661, %$99], [%665, %$100] ; # Tim
  %670 = phi i1 [0, %$47], [0, %$99], [%666, %$100] ; # ->
  br i1 %670, label %$101, label %$102
$101:
  %671 = phi i64 [%667, %$98] ; # Ms
  %672 = phi i64 [%668, %$98] ; # Run
  %673 = phi i64 [%669, %$98] ; # Tim
; # (let In (val $InFile) (set $InFile (val (ofs (val $InFiles) (val ...
; # (val $InFile)
  %674 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 72) to i8**)
; # (set $InFile (val (ofs (val $InFiles) (val $Hear))) $GetBin (fun ...
; # (val $InFiles)
  %675 = load i8**, i8*** @$InFiles
; # (val $Hear)
  %676 = load i32, i32* @$Hear
; # (ofs (val $InFiles) (val $Hear))
  %677 = getelementptr i8*, i8** %675, i32 %676
; # (val (ofs (val $InFiles) (val $Hear)))
  %678 = load i8*, i8** %677
  store i8* %678, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 72) to i8**)
; # (fun (i32) getBinary)
  store i32()* @getBinary, i32()** @$GetBin
  store i32 0, i32* @$Extn
; # (let E (binRead) (cond ((=0 E) (close N) (closeInFile N) (closeOu...
; # (binRead)
  %679 = call i64 @binRead()
; # (cond ((=0 E) (close N) (closeInFile N) (closeOutFile N) (set $He...
; # (=0 E)
  %680 = icmp eq i64 %679, 0
  br i1 %680, label %$105, label %$104
$105:
  %681 = phi i64 [%671, %$101] ; # Ms
  %682 = phi i64 [%672, %$101] ; # Run
  %683 = phi i64 [%673, %$101] ; # Tim
; # (close N)
  %684 = call i32 @close(i32 %657)
; # (closeInFile N)
  call void @closeInFile(i32 %657)
; # (closeOutFile N)
  call void @closeOutFile(i32 %657)
; # (set $Hear 0)
  store i32 0, i32* @$Hear
  br label %$103
$104:
  %685 = phi i64 [%671, %$101] ; # Ms
  %686 = phi i64 [%672, %$101] ; # Run
  %687 = phi i64 [%673, %$101] ; # Tim
; # (t? E)
  %688 = icmp eq i64 %679, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %688, label %$107, label %$106
$107:
  %689 = phi i64 [%685, %$104] ; # Ms
  %690 = phi i64 [%686, %$104] ; # Run
  %691 = phi i64 [%687, %$104] ; # Tim
; # (set $Sync YES)
  store i1 1, i1* @$Sync
  br label %$103
$106:
  %692 = phi i64 [%685, %$104] ; # Ms
  %693 = phi i64 [%686, %$104] ; # Run
  %694 = phi i64 [%687, %$104] ; # Tim
; # (save E (evList E))
  %695 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %696 = load i64, i64* %695
  %697 = alloca i64, i64 2, align 16
  %698 = ptrtoint i64* %697 to i64
  %699 = inttoptr i64 %698 to i64*
  store i64 %679, i64* %699
  %700 = add i64 %698, 8
  %701 = inttoptr i64 %700 to i64*
  store i64 %696, i64* %701
  %702 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %698, i64* %702
; # (evList E)
  %703 = call i64 @evList(i64 %679)
; # drop
  %704 = inttoptr i64 %698 to i64*
  %705 = getelementptr i64, i64* %704, i32 1
  %706 = load i64, i64* %705
  %707 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %706, i64* %707
  br label %$103
$103:
  %708 = phi i64 [%681, %$105], [%689, %$107], [%692, %$106] ; # Ms
  %709 = phi i64 [%682, %$105], [%690, %$107], [%693, %$106] ; # Run
  %710 = phi i64 [%683, %$105], [%691, %$107], [%694, %$106] ; # Tim
; # (set $InFile In)
  store i8* %674, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 72) to i8**)
  br label %$102
$102:
  %711 = phi i64 [%667, %$98], [%708, %$103] ; # Ms
  %712 = phi i64 [%668, %$98], [%709, %$103] ; # Run
  %713 = phi i64 [%669, %$98], [%710, %$103] ; # Tim
; # (let R Run (while (pair R) (let X (++ R) (cond ((sign? (car X)) (...
; # (while (pair R) (let X (++ R) (cond ((sign? (car X)) (let Y (cdr ...
  br label %$108
$108:
  %714 = phi i64 [%711, %$102], [%829, %$111] ; # Ms
  %715 = phi i64 [%712, %$102], [%830, %$111] ; # Run
  %716 = phi i64 [%713, %$102], [%831, %$111] ; # Tim
  %717 = phi i64 [%712, %$102], [%832, %$111] ; # R
; # (pair R)
  %718 = and i64 %717, 15
  %719 = icmp eq i64 %718, 0
  br i1 %719, label %$109, label %$110
$109:
  %720 = phi i64 [%714, %$108] ; # Ms
  %721 = phi i64 [%715, %$108] ; # Run
  %722 = phi i64 [%716, %$108] ; # Tim
  %723 = phi i64 [%717, %$108] ; # R
; # (let X (++ R) (cond ((sign? (car X)) (let Y (cdr X) (if (gt0 (- (...
; # (++ R)
  %724 = inttoptr i64 %723 to i64*
  %725 = load i64, i64* %724
  %726 = getelementptr i64, i64* %724, i32 1
  %727 = load i64, i64* %726
; # (cond ((sign? (car X)) (let Y (cdr X) (if (gt0 (- (int (car Y)) D...
; # (car X)
  %728 = inttoptr i64 %725 to i64*
  %729 = load i64, i64* %728
; # (sign? (car X))
  %730 = and i64 %729, 8
  %731 = icmp ne i64 %730, 0
  br i1 %731, label %$113, label %$112
$113:
  %732 = phi i64 [%720, %$109] ; # Ms
  %733 = phi i64 [%721, %$109] ; # Run
  %734 = phi i64 [%722, %$109] ; # Tim
  %735 = phi i64 [%727, %$109] ; # R
; # (let Y (cdr X) (if (gt0 (- (int (car Y)) Dif)) (set Y (sign (cnt ...
; # (cdr X)
  %736 = inttoptr i64 %725 to i64*
  %737 = getelementptr i64, i64* %736, i32 1
  %738 = load i64, i64* %737
; # (if (gt0 (- (int (car Y)) Dif)) (set Y (sign (cnt @))) (let V (ca...
; # (car Y)
  %739 = inttoptr i64 %738 to i64*
  %740 = load i64, i64* %739
; # (int (car Y))
  %741 = lshr i64 %740, 4
; # (- (int (car Y)) Dif)
  %742 = sub i64 %741, %281
; # (gt0 (- (int (car Y)) Dif))
  %743 = icmp sgt i64 %742, 0
  br i1 %743, label %$114, label %$115
$114:
  %744 = phi i64 [%732, %$113] ; # Ms
  %745 = phi i64 [%733, %$113] ; # Run
  %746 = phi i64 [%734, %$113] ; # Tim
  %747 = phi i64 [%735, %$113] ; # R
; # (set Y (sign (cnt @)))
; # (cnt @)
  %748 = shl i64 %742, 4
  %749 = or i64 %748, 2
; # (sign (cnt @))
  %750 = or i64 %749, 8
  %751 = inttoptr i64 %738 to i64*
  store i64 %750, i64* %751
  br label %$116
$115:
  %752 = phi i64 [%732, %$113] ; # Ms
  %753 = phi i64 [%733, %$113] ; # Run
  %754 = phi i64 [%734, %$113] ; # Tim
  %755 = phi i64 [%735, %$113] ; # R
; # (let V (car X) (set Y (pos V) $At V) (exec (cdr Y)))
; # (car X)
  %756 = inttoptr i64 %725 to i64*
  %757 = load i64, i64* %756
; # (set Y (pos V) $At V)
; # (pos V)
  %758 = and i64 %757, -9
  %759 = inttoptr i64 %738 to i64*
  store i64 %758, i64* %759
  %760 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  store i64 %757, i64* %760
; # (cdr Y)
  %761 = inttoptr i64 %738 to i64*
  %762 = getelementptr i64, i64* %761, i32 1
  %763 = load i64, i64* %762
; # (exec (cdr Y))
  br label %$117
$117:
  %764 = phi i64 [%763, %$115], [%776, %$120] ; # Prg
  %765 = inttoptr i64 %764 to i64*
  %766 = load i64, i64* %765
  %767 = getelementptr i64, i64* %765, i32 1
  %768 = load i64, i64* %767
  %769 = and i64 %766, 15
  %770 = icmp eq i64 %769, 0
  br i1 %770, label %$118, label %$119
$118:
  %771 = phi i64 [%768, %$117] ; # Prg
  %772 = call i64 @evList(i64 %766)
  br label %$119
$119:
  %773 = phi i64 [%768, %$117], [%771, %$118] ; # Prg
  %774 = and i64 %773, 15
  %775 = icmp ne i64 %774, 0
  br i1 %775, label %$121, label %$120
$120:
  %776 = phi i64 [%773, %$119] ; # Prg
  br label %$117
$121:
  %777 = phi i64 [%773, %$119] ; # Prg
  %778 = phi i64 [0, %$119] ; # ->
  br label %$116
$116:
  %779 = phi i64 [%744, %$114], [%752, %$121] ; # Ms
  %780 = phi i64 [%745, %$114], [%753, %$121] ; # Run
  %781 = phi i64 [%746, %$114], [%754, %$121] ; # Tim
  %782 = phi i64 [%747, %$114], [%755, %$121] ; # R
  %783 = phi i64 [%750, %$114], [%778, %$121] ; # ->
  br label %$111
$112:
  %784 = phi i64 [%720, %$109] ; # Ms
  %785 = phi i64 [%721, %$109] ; # Run
  %786 = phi i64 [%722, %$109] ; # Tim
  %787 = phi i64 [%727, %$109] ; # R
; # (int @)
  %788 = lshr i64 %729, 4
; # (i32 (int @))
  %789 = trunc i64 %788 to i32
; # (<> (i32 (int @)) Fd)
  %790 = icmp ne i32 %789, %1
  br i1 %790, label %$123, label %$122
$123:
  %791 = phi i64 [%784, %$112] ; # Ms
  %792 = phi i64 [%785, %$112] ; # Run
  %793 = phi i64 [%786, %$112] ; # Tim
  %794 = phi i64 [%787, %$112] ; # R
; # (when (inReady @ NO) (set $At (car X)) (exec (cdr X)))
; # (inReady @ NO)
  %795 = call i1 @inReady(i32 %789, i1 0)
  br i1 %795, label %$124, label %$125
$124:
  %796 = phi i64 [%791, %$123] ; # Ms
  %797 = phi i64 [%792, %$123] ; # Run
  %798 = phi i64 [%793, %$123] ; # Tim
  %799 = phi i64 [%794, %$123] ; # R
; # (set $At (car X))
; # (car X)
  %800 = inttoptr i64 %725 to i64*
  %801 = load i64, i64* %800
  %802 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  store i64 %801, i64* %802
; # (cdr X)
  %803 = inttoptr i64 %725 to i64*
  %804 = getelementptr i64, i64* %803, i32 1
  %805 = load i64, i64* %804
; # (exec (cdr X))
  br label %$126
$126:
  %806 = phi i64 [%805, %$124], [%818, %$129] ; # Prg
  %807 = inttoptr i64 %806 to i64*
  %808 = load i64, i64* %807
  %809 = getelementptr i64, i64* %807, i32 1
  %810 = load i64, i64* %809
  %811 = and i64 %808, 15
  %812 = icmp eq i64 %811, 0
  br i1 %812, label %$127, label %$128
$127:
  %813 = phi i64 [%810, %$126] ; # Prg
  %814 = call i64 @evList(i64 %808)
  br label %$128
$128:
  %815 = phi i64 [%810, %$126], [%813, %$127] ; # Prg
  %816 = and i64 %815, 15
  %817 = icmp ne i64 %816, 0
  br i1 %817, label %$130, label %$129
$129:
  %818 = phi i64 [%815, %$128] ; # Prg
  br label %$126
$130:
  %819 = phi i64 [%815, %$128] ; # Prg
  %820 = phi i64 [0, %$128] ; # ->
  br label %$125
$125:
  %821 = phi i64 [%791, %$123], [%796, %$130] ; # Ms
  %822 = phi i64 [%792, %$123], [%797, %$130] ; # Run
  %823 = phi i64 [%793, %$123], [%798, %$130] ; # Tim
  %824 = phi i64 [%794, %$123], [%799, %$130] ; # R
  br label %$111
$122:
  %825 = phi i64 [%784, %$112] ; # Ms
  %826 = phi i64 [%785, %$112] ; # Run
  %827 = phi i64 [%786, %$112] ; # Tim
  %828 = phi i64 [%787, %$112] ; # R
  br label %$111
$111:
  %829 = phi i64 [%779, %$116], [%821, %$125], [%825, %$122] ; # Ms
  %830 = phi i64 [%780, %$116], [%822, %$125], [%826, %$122] ; # Run
  %831 = phi i64 [%781, %$116], [%823, %$125], [%827, %$122] ; # Tim
  %832 = phi i64 [%782, %$116], [%824, %$125], [%828, %$122] ; # R
  br label %$108
$110:
  %833 = phi i64 [%714, %$108] ; # Ms
  %834 = phi i64 [%715, %$108] ; # Run
  %835 = phi i64 [%716, %$108] ; # Tim
  %836 = phi i64 [%717, %$108] ; # R
; # (and (gt0 Ms) (<> Ms 292MY) (lt0 (dec 'Ms Dif)) (setq Ms 0))
; # (gt0 Ms)
  %837 = icmp sgt i64 %833, 0
  br i1 %837, label %$132, label %$131
$132:
  %838 = phi i64 [%833, %$110] ; # Ms
  %839 = phi i64 [%834, %$110] ; # Run
  %840 = phi i64 [%835, %$110] ; # Tim
; # (<> Ms 292MY)
  %841 = icmp ne i64 %838, 9223372036854775807
  br i1 %841, label %$133, label %$131
$133:
  %842 = phi i64 [%838, %$132] ; # Ms
  %843 = phi i64 [%839, %$132] ; # Run
  %844 = phi i64 [%840, %$132] ; # Tim
; # (dec 'Ms Dif)
  %845 = sub i64 %842, %281
; # (lt0 (dec 'Ms Dif))
  %846 = icmp slt i64 %845, 0
  br i1 %846, label %$134, label %$131
$134:
  %847 = phi i64 [%845, %$133] ; # Ms
  %848 = phi i64 [%843, %$133] ; # Run
  %849 = phi i64 [%844, %$133] ; # Tim
  br label %$131
$131:
  %850 = phi i64 [%833, %$110], [%838, %$132], [%845, %$133], [0, %$134] ; # Ms
  %851 = phi i64 [%834, %$110], [%839, %$132], [%843, %$133], [%848, %$134] ; # Run
  %852 = phi i64 [%835, %$110], [%840, %$132], [%844, %$133], [%849, %$134] ; # Tim
  %853 = phi i1 [0, %$110], [0, %$132], [0, %$133], [0, %$134] ; # ->
; # (sigChk Exe)
  %854 = load volatile i32, i32* bitcast ([16 x i32]* @$Signal to i32*)
  %855 = icmp ne i32 %854, 0
  br i1 %855, label %$135, label %$136
$135:
  call void @sighandler(i64 %0)
  br label %$136
$136:
; # (? (or (=0 Ms) (lt0 Fd) (inReady Fd YES)))
; # (or (=0 Ms) (lt0 Fd) (inReady Fd YES))
; # (=0 Ms)
  %856 = icmp eq i64 %850, 0
  br i1 %856, label %$137, label %$138
$138:
  %857 = phi i64 [%850, %$136] ; # Ms
  %858 = phi i64 [%851, %$136] ; # Run
  %859 = phi i64 [%280, %$136] ; # Tim
; # (lt0 Fd)
  %860 = icmp slt i32 %1, 0
  br i1 %860, label %$137, label %$139
$139:
  %861 = phi i64 [%857, %$138] ; # Ms
  %862 = phi i64 [%858, %$138] ; # Run
  %863 = phi i64 [%859, %$138] ; # Tim
; # (inReady Fd YES)
  %864 = call i1 @inReady(i32 %1, i1 1)
  br label %$137
$137:
  %865 = phi i64 [%850, %$136], [%857, %$138], [%861, %$139] ; # Ms
  %866 = phi i64 [%851, %$136], [%858, %$138], [%862, %$139] ; # Run
  %867 = phi i64 [%280, %$136], [%859, %$138], [%863, %$139] ; # Tim
  %868 = phi i1 [1, %$136], [1, %$138], [%864, %$139] ; # ->
  br i1 %868, label %$141, label %$140
$140:
  %869 = phi i64 [%865, %$137] ; # Ms
  %870 = phi i64 [%866, %$137] ; # Run
  %871 = phi i64 [%867, %$137] ; # Tim
; # (val $Run)
  %872 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 600) to i64) to i64*
  %873 = load i64, i64* %872
; # (safe (val $Run))
  %874 = inttoptr i64 %8 to i64*
  store i64 %873, i64* %874
  br label %$4
$141:
  %875 = phi i64 [%865, %$137] ; # Ms
  %876 = phi i64 [%866, %$137] ; # Run
  %877 = phi i64 [%867, %$137] ; # Tim
  %878 = phi i64 [0, %$137] ; # ->
; # (set $At At)
  %879 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  store i64 %14, i64* %879
; # (drop *Safe)
  %880 = inttoptr i64 %8 to i64*
  %881 = getelementptr i64, i64* %880, i32 1
  %882 = load i64, i64* %881
  %883 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %882, i64* %883
  ret i64 %875
}

define i64 @_Wait(i64) align 8 {
$1:
; # (let (X (cdr Exe) N (if (nil? (eval (++ X))) 292MY (xCnt Exe @)))...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (if (nil? (eval (++ X))) 292MY (xCnt Exe @))
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (nil? (eval (++ X)))
  %16 = icmp eq i64 %15, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %16, label %$7, label %$8
$7:
  br label %$9
$8:
; # (xCnt Exe @)
  %17 = call i64 @xCnt(i64 %0, i64 %15)
  br label %$9
$9:
  %18 = phi i64 [9223372036854775807, %$7], [%17, %$8] ; # ->
; # (if (t? (car X)) (let Fd (evCnt Exe (cdr X)) (if (waitFd Exe (i32...
; # (car X)
  %19 = inttoptr i64 %7 to i64*
  %20 = load i64, i64* %19
; # (t? (car X))
  %21 = icmp eq i64 %20, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %21, label %$10, label %$11
$10:
  %22 = phi i64 [%18, %$9] ; # N
; # (let Fd (evCnt Exe (cdr X)) (if (waitFd Exe (i32 Fd) N) (cnt Fd) ...
; # (cdr X)
  %23 = inttoptr i64 %7 to i64*
  %24 = getelementptr i64, i64* %23, i32 1
  %25 = load i64, i64* %24
; # (evCnt Exe (cdr X))
  %26 = call i64 @evCnt(i64 %0, i64 %25)
; # (if (waitFd Exe (i32 Fd) N) (cnt Fd) $Nil)
; # (i32 Fd)
  %27 = trunc i64 %26 to i32
; # (waitFd Exe (i32 Fd) N)
  %28 = call i64 @waitFd(i64 %0, i32 %27, i64 %22)
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %$13, label %$14
$13:
  %30 = phi i64 [%22, %$10] ; # N
; # (cnt Fd)
  %31 = shl i64 %26, 4
  %32 = or i64 %31, 2
  br label %$15
$14:
  %33 = phi i64 [%22, %$10] ; # N
  br label %$15
$15:
  %34 = phi i64 [%30, %$13], [%33, %$14] ; # N
  %35 = phi i64 [%32, %$13], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$14] ; # ->
  br label %$12
$11:
  %36 = phi i64 [%18, %$9] ; # N
; # (loop (? (not (nil? (run X))) @) (? (=0 (waitFd Exe -1 N)) (run X...
  br label %$16
$16:
  %37 = phi i64 [%36, %$11], [%68, %$31] ; # N
; # (? (not (nil? (run X))) @)
; # (run X)
  br label %$17
$17:
  %38 = phi i64 [%7, %$16], [%60, %$26] ; # Prg
  %39 = inttoptr i64 %38 to i64*
  %40 = load i64, i64* %39
  %41 = getelementptr i64, i64* %39, i32 1
  %42 = load i64, i64* %41
  %43 = and i64 %42, 15
  %44 = icmp ne i64 %43, 0
  br i1 %44, label %$20, label %$18
$20:
  %45 = phi i64 [%42, %$17] ; # Prg
  %46 = and i64 %40, 6
  %47 = icmp ne i64 %46, 0
  br i1 %47, label %$23, label %$22
$23:
  br label %$21
$22:
  %48 = and i64 %40, 8
  %49 = icmp ne i64 %48, 0
  br i1 %49, label %$25, label %$24
$25:
  %50 = inttoptr i64 %40 to i64*
  %51 = load i64, i64* %50
  br label %$21
$24:
  %52 = call i64 @evList(i64 %40)
  br label %$21
$21:
  %53 = phi i64 [%40, %$23], [%51, %$25], [%52, %$24] ; # ->
  br label %$19
$18:
  %54 = phi i64 [%42, %$17] ; # Prg
  %55 = and i64 %40, 15
  %56 = icmp eq i64 %55, 0
  br i1 %56, label %$27, label %$26
$27:
  %57 = phi i64 [%54, %$18] ; # Prg
  %58 = call i64 @evList(i64 %40)
  %59 = icmp ne i64 %58, 0
  br label %$26
$26:
  %60 = phi i64 [%54, %$18], [%57, %$27] ; # Prg
  %61 = phi i1 [0, %$18], [%59, %$27] ; # ->
  br label %$17
$19:
  %62 = phi i64 [%45, %$21] ; # Prg
  %63 = phi i64 [%53, %$21] ; # ->
; # (nil? (run X))
  %64 = icmp eq i64 %63, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
; # (not (nil? (run X)))
  %65 = icmp eq i1 %64, 0
  br i1 %65, label %$30, label %$28
$30:
  %66 = phi i64 [%37, %$19] ; # N
  br label %$29
$28:
  %67 = phi i64 [%37, %$19] ; # N
; # (? (=0 (waitFd Exe -1 N)) (run X))
; # (waitFd Exe -1 N)
  %68 = call i64 @waitFd(i64 %0, i32 -1, i64 %67)
; # (=0 (waitFd Exe -1 N))
  %69 = icmp eq i64 %68, 0
  br i1 %69, label %$32, label %$31
$32:
  %70 = phi i64 [%67, %$28] ; # N
; # (run X)
  br label %$33
$33:
  %71 = phi i64 [%7, %$32], [%93, %$42] ; # Prg
  %72 = inttoptr i64 %71 to i64*
  %73 = load i64, i64* %72
  %74 = getelementptr i64, i64* %72, i32 1
  %75 = load i64, i64* %74
  %76 = and i64 %75, 15
  %77 = icmp ne i64 %76, 0
  br i1 %77, label %$36, label %$34
$36:
  %78 = phi i64 [%75, %$33] ; # Prg
  %79 = and i64 %73, 6
  %80 = icmp ne i64 %79, 0
  br i1 %80, label %$39, label %$38
$39:
  br label %$37
$38:
  %81 = and i64 %73, 8
  %82 = icmp ne i64 %81, 0
  br i1 %82, label %$41, label %$40
$41:
  %83 = inttoptr i64 %73 to i64*
  %84 = load i64, i64* %83
  br label %$37
$40:
  %85 = call i64 @evList(i64 %73)
  br label %$37
$37:
  %86 = phi i64 [%73, %$39], [%84, %$41], [%85, %$40] ; # ->
  br label %$35
$34:
  %87 = phi i64 [%75, %$33] ; # Prg
  %88 = and i64 %73, 15
  %89 = icmp eq i64 %88, 0
  br i1 %89, label %$43, label %$42
$43:
  %90 = phi i64 [%87, %$34] ; # Prg
  %91 = call i64 @evList(i64 %73)
  %92 = icmp ne i64 %91, 0
  br label %$42
$42:
  %93 = phi i64 [%87, %$34], [%90, %$43] ; # Prg
  %94 = phi i1 [0, %$34], [%92, %$43] ; # ->
  br label %$33
$35:
  %95 = phi i64 [%78, %$37] ; # Prg
  %96 = phi i64 [%86, %$37] ; # ->
  br label %$29
$31:
  %97 = phi i64 [%67, %$28] ; # N
  br label %$16
$29:
  %98 = phi i64 [%66, %$30], [%70, %$35] ; # N
  %99 = phi i64 [%63, %$30], [%96, %$35] ; # ->
  br label %$12
$12:
  %100 = phi i64 [%34, %$15], [%98, %$29] ; # N
  %101 = phi i64 [%35, %$15], [%99, %$29] ; # ->
  ret i64 %101
}

define i64 @_Sync(i64) align 8 {
$1:
; # (cond ((or (=0 (val $Mic)) (=0 (val $Hear))) $Nil) ((val $Sync) $...
; # (or (=0 (val $Mic)) (=0 (val $Hear)))
; # (val $Mic)
  %1 = load i32, i32* @$Mic
; # (=0 (val $Mic))
  %2 = icmp eq i32 %1, 0
  br i1 %2, label %$3, label %$4
$4:
; # (val $Hear)
  %3 = load i32, i32* @$Hear
; # (=0 (val $Hear))
  %4 = icmp eq i32 %3, 0
  br label %$3
$3:
  %5 = phi i1 [1, %$1], [%4, %$4] ; # ->
  br i1 %5, label %$6, label %$5
$6:
  br label %$2
$5:
; # (val $Sync)
  %6 = load i1, i1* @$Sync
  br i1 %6, label %$8, label %$7
$8:
  br label %$2
$7:
; # (let (Mic (val $Mic) P (i8* $Slot) Cnt 4) (loop (let N (write Mic...
; # (val $Mic)
  %7 = load i32, i32* @$Mic
; # (i8* $Slot)
  %8 = bitcast i32* @$Slot to i8*
; # (loop (let N (write Mic P Cnt) (cond ((ge0 N) (? (=0 (dec 'Cnt N)...
  br label %$9
$9:
  %9 = phi i8* [%8, %$7], [%30, %$10] ; # P
  %10 = phi i64 [4, %$7], [%31, %$10] ; # Cnt
; # (let N (write Mic P Cnt) (cond ((ge0 N) (? (=0 (dec 'Cnt N))) (se...
; # (write Mic P Cnt)
  %11 = call i64 @write(i32 %7, i8* %9, i64 %10)
; # (cond ((ge0 N) (? (=0 (dec 'Cnt N))) (setq P (ofs P N))) ((== (gE...
; # (ge0 N)
  %12 = icmp sge i64 %11, 0
  br i1 %12, label %$12, label %$11
$12:
  %13 = phi i8* [%9, %$9] ; # P
  %14 = phi i64 [%10, %$9] ; # Cnt
; # (? (=0 (dec 'Cnt N)))
; # (dec 'Cnt N)
  %15 = sub i64 %14, %11
; # (=0 (dec 'Cnt N))
  %16 = icmp eq i64 %15, 0
  br i1 %16, label %$14, label %$13
$13:
  %17 = phi i8* [%13, %$12] ; # P
  %18 = phi i64 [%15, %$12] ; # Cnt
; # (ofs P N)
  %19 = getelementptr i8, i8* %17, i64 %11
  br label %$10
$11:
  %20 = phi i8* [%9, %$9] ; # P
  %21 = phi i64 [%10, %$9] ; # Cnt
; # (gErrno)
  %22 = call i32 @gErrno()
; # (== (gErrno) EINTR)
  %23 = icmp eq i32 %22, 2
  br i1 %23, label %$16, label %$15
$16:
  %24 = phi i8* [%20, %$11] ; # P
  %25 = phi i64 [%21, %$11] ; # Cnt
; # (sigChk Exe)
  %26 = load volatile i32, i32* bitcast ([16 x i32]* @$Signal to i32*)
  %27 = icmp ne i32 %26, 0
  br i1 %27, label %$17, label %$18
$17:
  call void @sighandler(i64 %0)
  br label %$18
$18:
  br label %$10
$15:
  %28 = phi i8* [%20, %$11] ; # P
  %29 = phi i64 [%21, %$11] ; # Cnt
; # (writeErr ($ "sync write: %s"))
  call void @writeErr(i8* bitcast ([15 x i8]* @$43 to i8*))
  unreachable
$10:
  %30 = phi i8* [%19, %$13], [%24, %$18] ; # P
  %31 = phi i64 [%18, %$13], [%25, %$18] ; # Cnt
  br label %$9
$14:
  %32 = phi i8* [%13, %$12] ; # P
  %33 = phi i64 [%15, %$12] ; # Cnt
  %34 = phi i64 [0, %$12] ; # ->
; # (set $Sync NO)
  store i1 0, i1* @$Sync
; # (loop (waitFd Exe -1 292MY) (? (val $Sync)))
  br label %$19
$19:
; # (waitFd Exe -1 292MY)
  %35 = call i64 @waitFd(i64 %0, i32 -1, i64 9223372036854775807)
; # (? (val $Sync))
; # (val $Sync)
  %36 = load i1, i1* @$Sync
  br i1 %36, label %$21, label %$20
$20:
  br label %$19
$21:
  %37 = phi i64 [0, %$19] ; # ->
  br label %$2
$2:
  %38 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$6], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$8], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$21] ; # ->
  ret i64 %38
}

define i64 @_Hear(i64) align 8 {
$1:
; # (let (X (eval (cadr Exe)) Fd (i32 (xCnt Exe X))) (when (or (lt0 F...
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (xCnt Exe X)
  %14 = call i64 @xCnt(i64 %0, i64 %13)
; # (i32 (xCnt Exe X))
  %15 = trunc i64 %14 to i32
; # (when (or (lt0 Fd) (>= Fd (val $InFDs)) (=0 (val (ofs (val $InFil...
; # (or (lt0 Fd) (>= Fd (val $InFDs)) (=0 (val (ofs (val $InFiles) Fd...
; # (lt0 Fd)
  %16 = icmp slt i32 %15, 0
  br i1 %16, label %$7, label %$8
$8:
; # (val $InFDs)
  %17 = load i32, i32* @$InFDs
; # (>= Fd (val $InFDs))
  %18 = icmp sge i32 %15, %17
  br i1 %18, label %$7, label %$9
$9:
; # (val $InFiles)
  %19 = load i8**, i8*** @$InFiles
; # (ofs (val $InFiles) Fd)
  %20 = getelementptr i8*, i8** %19, i32 %15
; # (val (ofs (val $InFiles) Fd))
  %21 = load i8*, i8** %20
; # (=0 (val (ofs (val $InFiles) Fd)))
  %22 = icmp eq i8* %21, null
  br i1 %22, label %$7, label %$10
$10:
; # ((inFile @) fd)
  %23 = getelementptr i8, i8* %21, i32 8
  %24 = bitcast i8* %23 to i32*
  %25 = load i32, i32* %24
; # (lt0 ((inFile @) fd))
  %26 = icmp slt i32 %25, 0
  br label %$7
$7:
  %27 = phi i1 [1, %$2], [1, %$8], [1, %$9], [%26, %$10] ; # ->
  br i1 %27, label %$11, label %$12
$11:
; # (badFd Exe X)
  call void @badFd(i64 %0, i64 %13)
  unreachable
$12:
; # (when (val $Hear) (close @) (closeInFile @) (closeOutFile @))
; # (val $Hear)
  %28 = load i32, i32* @$Hear
  %29 = icmp ne i32 %28, 0
  br i1 %29, label %$13, label %$14
$13:
; # (close @)
  %30 = call i32 @close(i32 %28)
; # (closeInFile @)
  call void @closeInFile(i32 %28)
; # (closeOutFile @)
  call void @closeOutFile(i32 %28)
  br label %$14
$14:
; # (set $Hear Fd)
  store i32 %15, i32* @$Hear
  ret i64 %13
}

define i64 @_Tell(i64) align 8 {
$1:
; # (cond ((and (=0 (val $Tell)) (=0 (val $Children))) $Nil) ((atom (...
; # (and (=0 (val $Tell)) (=0 (val $Children)))
; # (val $Tell)
  %1 = load i32, i32* @$Tell
; # (=0 (val $Tell))
  %2 = icmp eq i32 %1, 0
  br i1 %2, label %$4, label %$3
$4:
; # (val $Children)
  %3 = load i32, i32* @$Children
; # (=0 (val $Children))
  %4 = icmp eq i32 %3, 0
  br label %$3
$3:
  %5 = phi i1 [0, %$1], [%4, %$4] ; # ->
  br i1 %5, label %$6, label %$5
$6:
  br label %$2
$5:
; # (cdr Exe)
  %6 = inttoptr i64 %0 to i64*
  %7 = getelementptr i64, i64* %6, i32 1
  %8 = load i64, i64* %7
; # (atom (cdr Exe))
  %9 = and i64 %8, 15
  %10 = icmp ne i64 %9, 0
  br i1 %10, label %$8, label %$7
$8:
; # (unsync)
  call void @unsync()
  br label %$2
$7:
; # (let (X @ Y (eval (car X)) Pid (i32 -1)) (when (cnt? Y) (setq Pid...
; # (car X)
  %11 = inttoptr i64 %8 to i64*
  %12 = load i64, i64* %11
; # (eval (car X))
  %13 = and i64 %12, 6
  %14 = icmp ne i64 %13, 0
  br i1 %14, label %$11, label %$10
$11:
  br label %$9
$10:
  %15 = and i64 %12, 8
  %16 = icmp ne i64 %15, 0
  br i1 %16, label %$13, label %$12
$13:
  %17 = inttoptr i64 %12 to i64*
  %18 = load i64, i64* %17
  br label %$9
$12:
  %19 = call i64 @evList(i64 %12)
  br label %$9
$9:
  %20 = phi i64 [%12, %$11], [%18, %$13], [%19, %$12] ; # ->
; # (i32 -1)
; # (when (cnt? Y) (setq Pid (i32 (int @)) Y (eval (car (shift X)))))...
; # (cnt? Y)
  %21 = and i64 %20, 2
  %22 = icmp ne i64 %21, 0
  br i1 %22, label %$14, label %$15
$14:
  %23 = phi i64 [%8, %$9] ; # X
  %24 = phi i64 [%20, %$9] ; # Y
  %25 = phi i32 [-1, %$9] ; # Pid
; # (int @)
  %26 = lshr i64 %20, 4
; # (i32 (int @))
  %27 = trunc i64 %26 to i32
; # (shift X)
  %28 = inttoptr i64 %23 to i64*
  %29 = getelementptr i64, i64* %28, i32 1
  %30 = load i64, i64* %29
; # (car (shift X))
  %31 = inttoptr i64 %30 to i64*
  %32 = load i64, i64* %31
; # (eval (car (shift X)))
  %33 = and i64 %32, 6
  %34 = icmp ne i64 %33, 0
  br i1 %34, label %$18, label %$17
$18:
  br label %$16
$17:
  %35 = and i64 %32, 8
  %36 = icmp ne i64 %35, 0
  br i1 %36, label %$20, label %$19
$20:
  %37 = inttoptr i64 %32 to i64*
  %38 = load i64, i64* %37
  br label %$16
$19:
  %39 = call i64 @evList(i64 %32)
  br label %$16
$16:
  %40 = phi i64 [%32, %$18], [%38, %$20], [%39, %$19] ; # ->
  br label %$15
$15:
  %41 = phi i64 [%8, %$9], [%30, %$16] ; # X
  %42 = phi i64 [%20, %$9], [%40, %$16] ; # Y
  %43 = phi i32 [-1, %$9], [%27, %$16] ; # Pid
; # (let (TellBuf (val $TellBuf) Ptr (val $Ptr) End (val $End)) (tell...
; # (val $TellBuf)
  %44 = load i8*, i8** @$TellBuf
; # (val $Ptr)
  %45 = load i8*, i8** @$Ptr
; # (val $End)
  %46 = load i8*, i8** @$End
; # (val PipeBufSize)
  %47 = load i32, i32* @PipeBufSize
; # (b8 (val PipeBufSize))
  %48 = alloca i8, i32 %47
; # (tellBeg (b8 (val PipeBufSize)))
  call void @tellBeg(i8* %48)
; # (stkChk Exe)
  %49 = load i8*, i8** @$StkLimit
  %50 = call i8* @llvm.stacksave()
  %51 = icmp ugt i8* %49, %50
  br i1 %51, label %$21, label %$22
$21:
  call void @stkErr(i64 %0)
  unreachable
$22:
; # (loop (prTell Y) (? (atom (shift X))) (setq Y (eval (car X))))
  br label %$23
$23:
  %52 = phi i64 [%41, %$22], [%60, %$26] ; # X
  %53 = phi i64 [%42, %$22], [%72, %$26] ; # Y
  %54 = phi i32 [%43, %$22], [%62, %$26] ; # Pid
; # (prTell Y)
  call void @prTell(i64 %53)
; # (? (atom (shift X)))
; # (shift X)
  %55 = inttoptr i64 %52 to i64*
  %56 = getelementptr i64, i64* %55, i32 1
  %57 = load i64, i64* %56
; # (atom (shift X))
  %58 = and i64 %57, 15
  %59 = icmp ne i64 %58, 0
  br i1 %59, label %$25, label %$24
$24:
  %60 = phi i64 [%57, %$23] ; # X
  %61 = phi i64 [%53, %$23] ; # Y
  %62 = phi i32 [%54, %$23] ; # Pid
; # (car X)
  %63 = inttoptr i64 %60 to i64*
  %64 = load i64, i64* %63
; # (eval (car X))
  %65 = and i64 %64, 6
  %66 = icmp ne i64 %65, 0
  br i1 %66, label %$28, label %$27
$28:
  br label %$26
$27:
  %67 = and i64 %64, 8
  %68 = icmp ne i64 %67, 0
  br i1 %68, label %$30, label %$29
$30:
  %69 = inttoptr i64 %64 to i64*
  %70 = load i64, i64* %69
  br label %$26
$29:
  %71 = call i64 @evList(i64 %64)
  br label %$26
$26:
  %72 = phi i64 [%64, %$28], [%70, %$30], [%71, %$29] ; # ->
  br label %$23
$25:
  %73 = phi i64 [%57, %$23] ; # X
  %74 = phi i64 [%53, %$23] ; # Y
  %75 = phi i32 [%54, %$23] ; # Pid
  %76 = phi i64 [0, %$23] ; # ->
; # (tellEnd Pid)
  call void @tellEnd(i32 %75)
; # (set $TellBuf TellBuf $Ptr Ptr $End End)
  store i8* %44, i8** @$TellBuf
  store i8* %45, i8** @$Ptr
  store i8* %46, i8** @$End
  br label %$2
$2:
  %77 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$6], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$8], [%74, %$25] ; # ->
  ret i64 %77
}

define i64 @_Poll(i64) align 8 {
$1:
; # (let (C (eval (cadr Exe)) Fd (i32 (xCnt Exe C))) (when (or (lt0 F...
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (xCnt Exe C)
  %14 = call i64 @xCnt(i64 %0, i64 %13)
; # (i32 (xCnt Exe C))
  %15 = trunc i64 %14 to i32
; # (when (or (lt0 Fd) (>= Fd (val $InFDs))) (badFd Exe C))
; # (or (lt0 Fd) (>= Fd (val $InFDs)))
; # (lt0 Fd)
  %16 = icmp slt i32 %15, 0
  br i1 %16, label %$7, label %$8
$8:
; # (val $InFDs)
  %17 = load i32, i32* @$InFDs
; # (>= Fd (val $InFDs))
  %18 = icmp sge i32 %15, %17
  br label %$7
$7:
  %19 = phi i1 [1, %$2], [%18, %$8] ; # ->
  br i1 %19, label %$9, label %$10
$9:
; # (badFd Exe C)
  call void @badFd(i64 %0, i64 %13)
  unreachable
$10:
; # (let In: (inFile (val (ofs (val $InFiles) Fd))) (ifn (and (In:) (...
; # (val $InFiles)
  %20 = load i8**, i8*** @$InFiles
; # (ofs (val $InFiles) Fd)
  %21 = getelementptr i8*, i8** %20, i32 %15
; # (val (ofs (val $InFiles) Fd))
  %22 = load i8*, i8** %21
; # (ifn (and (In:) (ge0 (In: fd))) $Nil (let Poll (b64 1) (pollIn Fd...
; # (and (In:) (ge0 (In: fd)))
; # (In:)
  %23 = icmp ne i8* %22, null
  br i1 %23, label %$12, label %$11
$12:
; # (In: fd)
  %24 = getelementptr i8, i8* %22, i32 8
  %25 = bitcast i8* %24 to i32*
  %26 = load i32, i32* %25
; # (ge0 (In: fd))
  %27 = icmp sge i32 %26, 0
  br label %$11
$11:
  %28 = phi i1 [0, %$10], [%27, %$12] ; # ->
  br i1 %28, label %$14, label %$13
$13:
  br label %$15
$14:
; # (let Poll (b64 1) (pollIn Fd Poll) (loop (? (> (In: cnt) (In: ix)...
; # (b64 1)
  %29 = alloca i64, i64 1
; # (pollIn Fd Poll)
  call void @pollIn(i32 %15, i64* %29)
; # (loop (? (> (In: cnt) (In: ix)) C) (while (lt0 (gPoll Poll 1 0)) ...
  br label %$16
$16:
; # (? (> (In: cnt) (In: ix)) C)
; # (In: cnt)
  %30 = getelementptr i8, i8* %22, i32 28
  %31 = bitcast i8* %30 to i32*
  %32 = load i32, i32* %31
; # (In: ix)
  %33 = getelementptr i8, i8* %22, i32 24
  %34 = bitcast i8* %33 to i32*
  %35 = load i32, i32* %34
; # (> (In: cnt) (In: ix))
  %36 = icmp sgt i32 %32, %35
  br i1 %36, label %$19, label %$17
$19:
  br label %$18
$17:
; # (while (lt0 (gPoll Poll 1 0)) (unless (== (gErrno) EINTR) (select...
  br label %$20
$20:
; # (gPoll Poll 1 0)
  %37 = call i32 @gPoll(i64* %29, i32 1, i64 0)
; # (lt0 (gPoll Poll 1 0))
  %38 = icmp slt i32 %37, 0
  br i1 %38, label %$21, label %$22
$21:
; # (unless (== (gErrno) EINTR) (selectErr Exe))
; # (gErrno)
  %39 = call i32 @gErrno()
; # (== (gErrno) EINTR)
  %40 = icmp eq i32 %39, 2
  br i1 %40, label %$24, label %$23
$23:
; # (selectErr Exe)
  call void @selectErr(i64 %0)
  unreachable
$24:
  br label %$20
$22:
; # (? (not (readyIn Poll)) $Nil)
; # (readyIn Poll)
  %41 = call i1 @readyIn(i64* %29)
; # (not (readyIn Poll))
  %42 = icmp eq i1 %41, 0
  br i1 %42, label %$26, label %$25
$26:
  br label %$18
$25:
; # (? (ge0 (slowNb (In:))) C)
; # (In:)
; # (slowNb (In:))
  %43 = call i32 @slowNb(i8* %22)
; # (ge0 (slowNb (In:)))
  %44 = icmp sge i32 %43, 0
  br i1 %44, label %$28, label %$27
$28:
  br label %$18
$27:
  br label %$16
$18:
  %45 = phi i64 [%13, %$19], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$26], [%13, %$28] ; # ->
  br label %$15
$15:
  %46 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$13], [%45, %$18] ; # ->
  ret i64 %46
}

define void @rdOpen(i64, i64, i8*) align 8 {
$1:
; # (cond ((nil? X) (pushInFile Io (val (val $InFiles)) 0)) ((num? X)...
; # (nil? X)
  %3 = icmp eq i64 %1, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %3, label %$4, label %$3
$4:
  %4 = phi i64 [%1, %$1] ; # X
; # (val $InFiles)
  %5 = load i8**, i8*** @$InFiles
; # (val (val $InFiles))
  %6 = load i8*, i8** %5
; # (pushInFile Io (val (val $InFiles)) 0)
  call void @pushInFile(i8* %2, i8* %6, i32 0)
  br label %$2
$3:
  %7 = phi i64 [%1, %$1] ; # X
; # (num? X)
  %8 = and i64 %7, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = phi i64 [%7, %$3] ; # X
; # (let N (i32 (int X)) (pushInFile Io (cond ((sign? X) (let In (val...
; # (int X)
  %11 = lshr i64 %10, 4
; # (i32 (int X))
  %12 = trunc i64 %11 to i32
; # (cond ((sign? X) (let In (val $InFrames) (loop (unless (setq In (...
; # (sign? X)
  %13 = and i64 %10, 8
  %14 = icmp ne i64 %13, 0
  br i1 %14, label %$9, label %$8
$9:
  %15 = phi i64 [%10, %$6] ; # X
  %16 = phi i32 [%12, %$6] ; # N
; # (let In (val $InFrames) (loop (unless (setq In ((ioFrame In) link...
; # (val $InFrames)
  %17 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 40) to i8**)
; # (loop (unless (setq In ((ioFrame In) link)) (badFd Exe X)) (? (=0...
  br label %$10
$10:
  %18 = phi i64 [%15, %$9], [%32, %$13] ; # X
  %19 = phi i32 [%16, %$9], [%33, %$13] ; # N
  %20 = phi i8* [%17, %$9], [%34, %$13] ; # In
; # (unless (setq In ((ioFrame In) link)) (badFd Exe X))
; # ((ioFrame In) link)
  %21 = bitcast i8* %20 to i8**
  %22 = load i8*, i8** %21
  %23 = icmp ne i8* %22, null
  br i1 %23, label %$12, label %$11
$11:
  %24 = phi i64 [%18, %$10] ; # X
  %25 = phi i32 [%19, %$10] ; # N
  %26 = phi i8* [%22, %$10] ; # In
; # (badFd Exe X)
  call void @badFd(i64 %0, i64 %24)
  unreachable
$12:
  %27 = phi i64 [%18, %$10] ; # X
  %28 = phi i32 [%19, %$10] ; # N
  %29 = phi i8* [%22, %$10] ; # In
; # (? (=0 (dec 'N)))
; # (dec 'N)
  %30 = sub i32 %28, 1
; # (=0 (dec 'N))
  %31 = icmp eq i32 %30, 0
  br i1 %31, label %$14, label %$13
$13:
  %32 = phi i64 [%27, %$12] ; # X
  %33 = phi i32 [%30, %$12] ; # N
  %34 = phi i8* [%29, %$12] ; # In
  br label %$10
$14:
  %35 = phi i64 [%27, %$12] ; # X
  %36 = phi i32 [%30, %$12] ; # N
  %37 = phi i8* [%29, %$12] ; # In
  %38 = phi i64 [0, %$12] ; # ->
; # ((ioFrame In) file)
  %39 = getelementptr i8, i8* %37, i32 8
  %40 = bitcast i8* %39 to i8**
  %41 = load i8*, i8** %40
  br label %$7
$8:
  %42 = phi i64 [%10, %$6] ; # X
  %43 = phi i32 [%12, %$6] ; # N
; # (val $InFDs)
  %44 = load i32, i32* @$InFDs
; # (>= N (val $InFDs))
  %45 = icmp sge i32 %43, %44
  br i1 %45, label %$16, label %$15
$16:
  %46 = phi i64 [%42, %$8] ; # X
  %47 = phi i32 [%43, %$8] ; # N
; # (badFd Exe X)
  call void @badFd(i64 %0, i64 %46)
  unreachable
$15:
  %48 = phi i64 [%42, %$8] ; # X
  %49 = phi i32 [%43, %$8] ; # N
; # (val $InFiles)
  %50 = load i8**, i8*** @$InFiles
; # (ofs (val $InFiles) N)
  %51 = getelementptr i8*, i8** %50, i32 %49
; # (val (ofs (val $InFiles) N))
  %52 = load i8*, i8** %51
; # (=0 (val (ofs (val $InFiles) N)))
  %53 = icmp eq i8* %52, null
  br i1 %53, label %$18, label %$17
$18:
  %54 = phi i64 [%48, %$15] ; # X
  %55 = phi i32 [%49, %$15] ; # N
; # (badFd Exe X)
  call void @badFd(i64 %0, i64 %54)
  unreachable
$17:
  %56 = phi i64 [%48, %$15] ; # X
  %57 = phi i32 [%49, %$15] ; # N
  br label %$7
$7:
  %58 = phi i64 [%35, %$14], [%56, %$17] ; # X
  %59 = phi i32 [%36, %$14], [%57, %$17] ; # N
  %60 = phi i8* [%41, %$14], [%52, %$17] ; # ->
; # (pushInFile Io (cond ((sign? X) (let In (val $InFrames) (loop (un...
  call void @pushInFile(i8* %2, i8* %60, i32 0)
  br label %$2
$5:
  %61 = phi i64 [%7, %$3] ; # X
; # (sym? X)
  %62 = and i64 %61, 8
  %63 = icmp ne i64 %62, 0
  br i1 %63, label %$20, label %$19
$20:
  %64 = phi i64 [%61, %$5] ; # X
; # (let (Nm (xName X) S (pathString Nm (b8 (pathSize Nm))) Fd T) (wh...
; # (xName X)
  %65 = call i64 @xName(i64 %64)
; # (pathSize Nm)
  %66 = call i64 @pathSize(i64 %65)
; # (b8 (pathSize Nm))
  %67 = alloca i8, i64 %66
; # (pathString Nm (b8 (pathSize Nm)))
  %68 = call i8* @pathString(i64 %65, i8* %67)
; # (while (lt0 (setq Fd (openRd S))) (unless (== (gErrno) EINTR) (op...
  br label %$21
$21:
  %69 = phi i64 [%64, %$20], [%78, %$27] ; # X
; # (openRd S)
  %70 = call i32 @openRd(i8* %68)
; # (lt0 (setq Fd (openRd S)))
  %71 = icmp slt i32 %70, 0
  br i1 %71, label %$22, label %$23
$22:
  %72 = phi i64 [%69, %$21] ; # X
  %73 = phi i32 [%70, %$21] ; # Fd
; # (unless (== (gErrno) EINTR) (openErr Exe X))
; # (gErrno)
  %74 = call i32 @gErrno()
; # (== (gErrno) EINTR)
  %75 = icmp eq i32 %74, 2
  br i1 %75, label %$25, label %$24
$24:
  %76 = phi i64 [%72, %$22] ; # X
  %77 = phi i32 [%73, %$22] ; # Fd
; # (openErr Exe X)
  call void @openErr(i64 %0, i64 %76)
  unreachable
$25:
  %78 = phi i64 [%72, %$22] ; # X
  %79 = phi i32 [%73, %$22] ; # Fd
; # (sigChk Exe)
  %80 = load volatile i32, i32* bitcast ([16 x i32]* @$Signal to i32*)
  %81 = icmp ne i32 %80, 0
  br i1 %81, label %$26, label %$27
$26:
  call void @sighandler(i64 %0)
  br label %$27
$27:
  br label %$21
$23:
  %82 = phi i64 [%69, %$21] ; # X
  %83 = phi i32 [%70, %$21] ; # Fd
; # (closeOnExec Exe Fd)
  call void @closeOnExec(i64 %0, i32 %83)
; # (strdup S)
  %84 = call i8* @strdup(i8* %68)
; # (initInFile Fd (strdup S))
  %85 = call i8* @initInFile(i32 %83, i8* %84)
; # (pushInFile Io (initInFile Fd (strdup S)) 1)
  call void @pushInFile(i8* %2, i8* %85, i32 1)
  br label %$2
$19:
  %86 = phi i64 [%61, %$5] ; # X
; # (let (Pfd (b32 2) Av (b8* (inc (length X))) Cmd (xName (xSym (car...
; # (b32 2)
  %87 = alloca i32, i64 2
; # (length X)
  br label %$28
$28:
  %88 = phi i64 [%86, %$19], [%97, %$29] ; # X
  %89 = phi i64 [0, %$19], [%94, %$29] ; # N
  %90 = and i64 %88, 15
  %91 = icmp eq i64 %90, 0
  br i1 %91, label %$29, label %$30
$29:
  %92 = phi i64 [%88, %$28] ; # X
  %93 = phi i64 [%89, %$28] ; # N
  %94 = add i64 %93, 1
  %95 = inttoptr i64 %92 to i64*
  %96 = getelementptr i64, i64* %95, i32 1
  %97 = load i64, i64* %96
  br label %$28
$30:
  %98 = phi i64 [%88, %$28] ; # X
  %99 = phi i64 [%89, %$28] ; # N
; # (inc (length X))
  %100 = add i64 %99, 1
; # (b8* (inc (length X)))
  %101 = alloca i8*, i64 %100
; # (car X)
  %102 = inttoptr i64 %86 to i64*
  %103 = load i64, i64* %102
; # (xSym (car X))
  %104 = call i64 @xSym(i64 %103)
; # (xName (xSym (car X)))
  %105 = call i64 @xName(i64 %104)
; # (when (lt0 (pipe Pfd)) (pipeErr Exe))
; # (pipe Pfd)
  %106 = call i32 @pipe(i32* %87)
; # (lt0 (pipe Pfd))
  %107 = icmp slt i32 %106, 0
  br i1 %107, label %$31, label %$32
$31:
  %108 = phi i64 [%86, %$30] ; # X
; # (pipeErr Exe)
  call void @pipeErr(i64 %0)
  unreachable
$32:
  %109 = phi i64 [%86, %$30] ; # X
; # (set Av (pathString Cmd (b8 (pathSize Cmd))))
; # (pathSize Cmd)
  %110 = call i64 @pathSize(i64 %105)
; # (b8 (pathSize Cmd))
  %111 = alloca i8, i64 %110
; # (pathString Cmd (b8 (pathSize Cmd)))
  %112 = call i8* @pathString(i64 %105, i8* %111)
  store i8* %112, i8** %101
; # (let A Av (while (pair (shift X)) (let Nm (xName (xSym (car X))) ...
; # (while (pair (shift X)) (let Nm (xName (xSym (car X))) (set (inc ...
  br label %$33
$33:
  %113 = phi i64 [%109, %$32], [%120, %$34] ; # X
  %114 = phi i8** [%101, %$32], [%126, %$34] ; # A
; # (shift X)
  %115 = inttoptr i64 %113 to i64*
  %116 = getelementptr i64, i64* %115, i32 1
  %117 = load i64, i64* %116
; # (pair (shift X))
  %118 = and i64 %117, 15
  %119 = icmp eq i64 %118, 0
  br i1 %119, label %$34, label %$35
$34:
  %120 = phi i64 [%117, %$33] ; # X
  %121 = phi i8** [%114, %$33] ; # A
; # (let Nm (xName (xSym (car X))) (set (inc 'A) (bufString Nm (b8 (b...
; # (car X)
  %122 = inttoptr i64 %120 to i64*
  %123 = load i64, i64* %122
; # (xSym (car X))
  %124 = call i64 @xSym(i64 %123)
; # (xName (xSym (car X)))
  %125 = call i64 @xName(i64 %124)
; # (set (inc 'A) (bufString Nm (b8 (bufSize Nm))))
; # (inc 'A)
  %126 = getelementptr i8*, i8** %121, i32 1
; # (bufSize Nm)
  %127 = call i64 @bufSize(i64 %125)
; # (b8 (bufSize Nm))
  %128 = alloca i8, i64 %127
; # (bufString Nm (b8 (bufSize Nm)))
  %129 = call i8* @bufString(i64 %125, i8* %128)
  store i8* %129, i8** %126
  br label %$33
$35:
  %130 = phi i64 [%117, %$33] ; # X
  %131 = phi i8** [%114, %$33] ; # A
; # (set (inc 'A) null)
; # (inc 'A)
  %132 = getelementptr i8*, i8** %131, i32 1
  store i8* null, i8** %132
; # (cond ((lt0 (fork)) (forkErr Exe)) ((=0 @) (setpgid 0 0) (close (...
; # (fork)
  %133 = call i32 @fork()
; # (lt0 (fork))
  %134 = icmp slt i32 %133, 0
  br i1 %134, label %$38, label %$37
$38:
  %135 = phi i64 [%130, %$35] ; # X
; # (forkErr Exe)
  call void @forkErr(i64 %0)
  unreachable
$37:
  %136 = phi i64 [%130, %$35] ; # X
; # (=0 @)
  %137 = icmp eq i32 %133, 0
  br i1 %137, label %$40, label %$39
$40:
  %138 = phi i64 [%136, %$37] ; # X
; # (setpgid 0 0)
  %139 = call i32 @setpgid(i32 0, i32 0)
; # (val Pfd)
  %140 = load i32, i32* %87
; # (close (val Pfd))
  %141 = call i32 @close(i32 %140)
; # (unless (== (val 2 Pfd) 1) (dup2 @ 1) (close @))
; # (val 2 Pfd)
  %142 = getelementptr i32, i32* %87, i32 1
  %143 = load i32, i32* %142
; # (== (val 2 Pfd) 1)
  %144 = icmp eq i32 %143, 1
  br i1 %144, label %$42, label %$41
$41:
  %145 = phi i64 [%138, %$40] ; # X
; # (dup2 @ 1)
  %146 = call i32 @dup2(i32 %143, i32 1)
; # (close @)
  %147 = call i32 @close(i32 %143)
  br label %$42
$42:
  %148 = phi i64 [%138, %$40], [%145, %$41] ; # X
; # (val SIGPIPE Sig)
  %149 = getelementptr i32, i32* @Sig, i32 4
  %150 = load i32, i32* %149
; # (val SigDfl)
  %151 = load i8*, i8** @SigDfl
; # (signal (val SIGPIPE Sig) (val SigDfl))
  %152 = call i8* @signal(i32 %150, i8* %151)
; # (val Av)
  %153 = load i8*, i8** %101
; # (execvp (val Av) Av)
  %154 = call i32 @execvp(i8* %153, i8** %101)
; # (val Av)
  %155 = load i8*, i8** %101
; # (execErr (val Av))
  call void @execErr(i8* %155)
  unreachable
$39:
  %156 = phi i64 [%136, %$37] ; # X
  br label %$36
$36:
  %157 = phi i64 [%156, %$39] ; # X
  %158 = phi i64 [0, %$39] ; # ->
; # (let (Pid @ Fd (val Pfd)) (setpgid Pid 0) (close (val 2 Pfd)) (cl...
; # (val Pfd)
  %159 = load i32, i32* %87
; # (setpgid Pid 0)
  %160 = call i32 @setpgid(i32 %133, i32 0)
; # (val 2 Pfd)
  %161 = getelementptr i32, i32* %87, i32 1
  %162 = load i32, i32* %161
; # (close (val 2 Pfd))
  %163 = call i32 @close(i32 %162)
; # (closeOnExec Exe Fd)
  call void @closeOnExec(i64 %0, i32 %159)
; # (initInFile Fd null)
  %164 = call i8* @initInFile(i32 %159, i8* null)
; # (pushInFile Io (initInFile Fd null) Pid)
  call void @pushInFile(i8* %2, i8* %164, i32 %133)
  br label %$2
$2:
  %165 = phi i64 [%4, %$4], [%58, %$7], [%82, %$23], [%157, %$36] ; # X
  ret void
}

define void @wrOpen(i64, i64, i8*) align 8 {
$1:
; # (cond ((nil? X) (pushOutFile Io (val 2 (val $OutFiles)) 0)) ((num...
; # (nil? X)
  %3 = icmp eq i64 %1, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %3, label %$4, label %$3
$4:
  %4 = phi i64 [%1, %$1] ; # X
; # (val $OutFiles)
  %5 = load i8**, i8*** @$OutFiles
; # (val 2 (val $OutFiles))
  %6 = getelementptr i8*, i8** %5, i32 1
  %7 = load i8*, i8** %6
; # (pushOutFile Io (val 2 (val $OutFiles)) 0)
  call void @pushOutFile(i8* %2, i8* %7, i32 0)
  br label %$2
$3:
  %8 = phi i64 [%1, %$1] ; # X
; # (num? X)
  %9 = and i64 %8, 6
  %10 = icmp ne i64 %9, 0
  br i1 %10, label %$6, label %$5
$6:
  %11 = phi i64 [%8, %$3] ; # X
; # (let N (i32 (int X)) (pushOutFile Io (cond ((sign? X) (let Out (v...
; # (int X)
  %12 = lshr i64 %11, 4
; # (i32 (int X))
  %13 = trunc i64 %12 to i32
; # (cond ((sign? X) (let Out (val $OutFrames) (loop (unless (setq Ou...
; # (sign? X)
  %14 = and i64 %11, 8
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$9, label %$8
$9:
  %16 = phi i64 [%11, %$6] ; # X
  %17 = phi i32 [%13, %$6] ; # N
; # (let Out (val $OutFrames) (loop (unless (setq Out ((ioFrame Out) ...
; # (val $OutFrames)
  %18 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 48) to i8**)
; # (loop (unless (setq Out ((ioFrame Out) link)) (badFd Exe X)) (? (...
  br label %$10
$10:
  %19 = phi i64 [%16, %$9], [%33, %$13] ; # X
  %20 = phi i32 [%17, %$9], [%34, %$13] ; # N
  %21 = phi i8* [%18, %$9], [%35, %$13] ; # Out
; # (unless (setq Out ((ioFrame Out) link)) (badFd Exe X))
; # ((ioFrame Out) link)
  %22 = bitcast i8* %21 to i8**
  %23 = load i8*, i8** %22
  %24 = icmp ne i8* %23, null
  br i1 %24, label %$12, label %$11
$11:
  %25 = phi i64 [%19, %$10] ; # X
  %26 = phi i32 [%20, %$10] ; # N
  %27 = phi i8* [%23, %$10] ; # Out
; # (badFd Exe X)
  call void @badFd(i64 %0, i64 %25)
  unreachable
$12:
  %28 = phi i64 [%19, %$10] ; # X
  %29 = phi i32 [%20, %$10] ; # N
  %30 = phi i8* [%23, %$10] ; # Out
; # (? (=0 (dec 'N)))
; # (dec 'N)
  %31 = sub i32 %29, 1
; # (=0 (dec 'N))
  %32 = icmp eq i32 %31, 0
  br i1 %32, label %$14, label %$13
$13:
  %33 = phi i64 [%28, %$12] ; # X
  %34 = phi i32 [%31, %$12] ; # N
  %35 = phi i8* [%30, %$12] ; # Out
  br label %$10
$14:
  %36 = phi i64 [%28, %$12] ; # X
  %37 = phi i32 [%31, %$12] ; # N
  %38 = phi i8* [%30, %$12] ; # Out
  %39 = phi i64 [0, %$12] ; # ->
; # ((ioFrame Out) file)
  %40 = getelementptr i8, i8* %38, i32 8
  %41 = bitcast i8* %40 to i8**
  %42 = load i8*, i8** %41
  br label %$7
$8:
  %43 = phi i64 [%11, %$6] ; # X
  %44 = phi i32 [%13, %$6] ; # N
; # (val $OutFDs)
  %45 = load i32, i32* @$OutFDs
; # (>= N (val $OutFDs))
  %46 = icmp sge i32 %44, %45
  br i1 %46, label %$16, label %$15
$16:
  %47 = phi i64 [%43, %$8] ; # X
  %48 = phi i32 [%44, %$8] ; # N
; # (badFd Exe X)
  call void @badFd(i64 %0, i64 %47)
  unreachable
$15:
  %49 = phi i64 [%43, %$8] ; # X
  %50 = phi i32 [%44, %$8] ; # N
; # (val $OutFiles)
  %51 = load i8**, i8*** @$OutFiles
; # (ofs (val $OutFiles) N)
  %52 = getelementptr i8*, i8** %51, i32 %50
; # (val (ofs (val $OutFiles) N))
  %53 = load i8*, i8** %52
; # (=0 (val (ofs (val $OutFiles) N)))
  %54 = icmp eq i8* %53, null
  br i1 %54, label %$18, label %$17
$18:
  %55 = phi i64 [%49, %$15] ; # X
  %56 = phi i32 [%50, %$15] ; # N
; # (badFd Exe X)
  call void @badFd(i64 %0, i64 %55)
  unreachable
$17:
  %57 = phi i64 [%49, %$15] ; # X
  %58 = phi i32 [%50, %$15] ; # N
  br label %$7
$7:
  %59 = phi i64 [%36, %$14], [%57, %$17] ; # X
  %60 = phi i32 [%37, %$14], [%58, %$17] ; # N
  %61 = phi i8* [%42, %$14], [%53, %$17] ; # ->
; # (pushOutFile Io (cond ((sign? X) (let Out (val $OutFrames) (loop ...
  call void @pushOutFile(i8* %2, i8* %61, i32 0)
  br label %$2
$5:
  %62 = phi i64 [%8, %$3] ; # X
; # (sym? X)
  %63 = and i64 %62, 8
  %64 = icmp ne i64 %63, 0
  br i1 %64, label %$20, label %$19
$20:
  %65 = phi i64 [%62, %$5] ; # X
; # (let (Nm (xName X) S (pathString Nm (b8 (pathSize Nm))) Flg (== (...
; # (xName X)
  %66 = call i64 @xName(i64 %65)
; # (pathSize Nm)
  %67 = call i64 @pathSize(i64 %66)
; # (b8 (pathSize Nm))
  %68 = alloca i8, i64 %67
; # (pathString Nm (b8 (pathSize Nm)))
  %69 = call i8* @pathString(i64 %66, i8* %68)
; # (val S)
  %70 = load i8, i8* %69
; # (== (val S) (char "+"))
  %71 = icmp eq i8 %70, 43
; # (when Flg (setq S (ofs S 1)))
  br i1 %71, label %$21, label %$22
$21:
  %72 = phi i64 [%65, %$20] ; # X
  %73 = phi i8* [%69, %$20] ; # S
; # (ofs S 1)
  %74 = getelementptr i8, i8* %73, i32 1
  br label %$22
$22:
  %75 = phi i64 [%65, %$20], [%72, %$21] ; # X
  %76 = phi i8* [%69, %$20], [%74, %$21] ; # S
; # (while (lt0 (setq Fd (if Flg (openRdWrAppend S) (openWr S)))) (un...
  br label %$23
$23:
  %77 = phi i64 [%75, %$22], [%97, %$32] ; # X
  %78 = phi i8* [%76, %$22], [%98, %$32] ; # S
; # (if Flg (openRdWrAppend S) (openWr S))
  br i1 %71, label %$24, label %$25
$24:
  %79 = phi i64 [%77, %$23] ; # X
  %80 = phi i8* [%78, %$23] ; # S
; # (openRdWrAppend S)
  %81 = call i32 @openRdWrAppend(i8* %80)
  br label %$26
$25:
  %82 = phi i64 [%77, %$23] ; # X
  %83 = phi i8* [%78, %$23] ; # S
; # (openWr S)
  %84 = call i32 @openWr(i8* %83)
  br label %$26
$26:
  %85 = phi i64 [%79, %$24], [%82, %$25] ; # X
  %86 = phi i8* [%80, %$24], [%83, %$25] ; # S
  %87 = phi i32 [%81, %$24], [%84, %$25] ; # ->
; # (lt0 (setq Fd (if Flg (openRdWrAppend S) (openWr S))))
  %88 = icmp slt i32 %87, 0
  br i1 %88, label %$27, label %$28
$27:
  %89 = phi i64 [%85, %$26] ; # X
  %90 = phi i8* [%86, %$26] ; # S
  %91 = phi i32 [%87, %$26] ; # Fd
; # (unless (== (gErrno) EINTR) (openErr Exe X))
; # (gErrno)
  %92 = call i32 @gErrno()
; # (== (gErrno) EINTR)
  %93 = icmp eq i32 %92, 2
  br i1 %93, label %$30, label %$29
$29:
  %94 = phi i64 [%89, %$27] ; # X
  %95 = phi i8* [%90, %$27] ; # S
  %96 = phi i32 [%91, %$27] ; # Fd
; # (openErr Exe X)
  call void @openErr(i64 %0, i64 %94)
  unreachable
$30:
  %97 = phi i64 [%89, %$27] ; # X
  %98 = phi i8* [%90, %$27] ; # S
  %99 = phi i32 [%91, %$27] ; # Fd
; # (sigChk Exe)
  %100 = load volatile i32, i32* bitcast ([16 x i32]* @$Signal to i32*)
  %101 = icmp ne i32 %100, 0
  br i1 %101, label %$31, label %$32
$31:
  call void @sighandler(i64 %0)
  br label %$32
$32:
  br label %$23
$28:
  %102 = phi i64 [%85, %$26] ; # X
  %103 = phi i8* [%86, %$26] ; # S
  %104 = phi i32 [%87, %$26] ; # Fd
; # (closeOnExec Exe Fd)
  call void @closeOnExec(i64 %0, i32 %104)
; # (initOutFile Fd)
  %105 = call i8* @initOutFile(i32 %104)
; # (pushOutFile Io (initOutFile Fd) 1)
  call void @pushOutFile(i8* %2, i8* %105, i32 1)
  br label %$2
$19:
  %106 = phi i64 [%62, %$5] ; # X
; # (let (Pfd (b32 2) Av (b8* (inc (length X))) Cmd (xName (xSym (car...
; # (b32 2)
  %107 = alloca i32, i64 2
; # (length X)
  br label %$33
$33:
  %108 = phi i64 [%106, %$19], [%117, %$34] ; # X
  %109 = phi i64 [0, %$19], [%114, %$34] ; # N
  %110 = and i64 %108, 15
  %111 = icmp eq i64 %110, 0
  br i1 %111, label %$34, label %$35
$34:
  %112 = phi i64 [%108, %$33] ; # X
  %113 = phi i64 [%109, %$33] ; # N
  %114 = add i64 %113, 1
  %115 = inttoptr i64 %112 to i64*
  %116 = getelementptr i64, i64* %115, i32 1
  %117 = load i64, i64* %116
  br label %$33
$35:
  %118 = phi i64 [%108, %$33] ; # X
  %119 = phi i64 [%109, %$33] ; # N
; # (inc (length X))
  %120 = add i64 %119, 1
; # (b8* (inc (length X)))
  %121 = alloca i8*, i64 %120
; # (car X)
  %122 = inttoptr i64 %106 to i64*
  %123 = load i64, i64* %122
; # (xSym (car X))
  %124 = call i64 @xSym(i64 %123)
; # (xName (xSym (car X)))
  %125 = call i64 @xName(i64 %124)
; # (when (lt0 (pipe Pfd)) (pipeErr Exe))
; # (pipe Pfd)
  %126 = call i32 @pipe(i32* %107)
; # (lt0 (pipe Pfd))
  %127 = icmp slt i32 %126, 0
  br i1 %127, label %$36, label %$37
$36:
  %128 = phi i64 [%106, %$35] ; # X
; # (pipeErr Exe)
  call void @pipeErr(i64 %0)
  unreachable
$37:
  %129 = phi i64 [%106, %$35] ; # X
; # (set Av (pathString Cmd (b8 (pathSize Cmd))))
; # (pathSize Cmd)
  %130 = call i64 @pathSize(i64 %125)
; # (b8 (pathSize Cmd))
  %131 = alloca i8, i64 %130
; # (pathString Cmd (b8 (pathSize Cmd)))
  %132 = call i8* @pathString(i64 %125, i8* %131)
  store i8* %132, i8** %121
; # (let A Av (while (pair (shift X)) (let Nm (xName (xSym (car X))) ...
; # (while (pair (shift X)) (let Nm (xName (xSym (car X))) (set (inc ...
  br label %$38
$38:
  %133 = phi i64 [%129, %$37], [%140, %$39] ; # X
  %134 = phi i8** [%121, %$37], [%146, %$39] ; # A
; # (shift X)
  %135 = inttoptr i64 %133 to i64*
  %136 = getelementptr i64, i64* %135, i32 1
  %137 = load i64, i64* %136
; # (pair (shift X))
  %138 = and i64 %137, 15
  %139 = icmp eq i64 %138, 0
  br i1 %139, label %$39, label %$40
$39:
  %140 = phi i64 [%137, %$38] ; # X
  %141 = phi i8** [%134, %$38] ; # A
; # (let Nm (xName (xSym (car X))) (set (inc 'A) (bufString Nm (b8 (b...
; # (car X)
  %142 = inttoptr i64 %140 to i64*
  %143 = load i64, i64* %142
; # (xSym (car X))
  %144 = call i64 @xSym(i64 %143)
; # (xName (xSym (car X)))
  %145 = call i64 @xName(i64 %144)
; # (set (inc 'A) (bufString Nm (b8 (bufSize Nm))))
; # (inc 'A)
  %146 = getelementptr i8*, i8** %141, i32 1
; # (bufSize Nm)
  %147 = call i64 @bufSize(i64 %145)
; # (b8 (bufSize Nm))
  %148 = alloca i8, i64 %147
; # (bufString Nm (b8 (bufSize Nm)))
  %149 = call i8* @bufString(i64 %145, i8* %148)
  store i8* %149, i8** %146
  br label %$38
$40:
  %150 = phi i64 [%137, %$38] ; # X
  %151 = phi i8** [%134, %$38] ; # A
; # (set (inc 'A) null)
; # (inc 'A)
  %152 = getelementptr i8*, i8** %151, i32 1
  store i8* null, i8** %152
; # (cond ((lt0 (fork)) (forkErr Exe)) ((=0 @) (setpgid 0 0) (close (...
; # (fork)
  %153 = call i32 @fork()
; # (lt0 (fork))
  %154 = icmp slt i32 %153, 0
  br i1 %154, label %$43, label %$42
$43:
  %155 = phi i64 [%150, %$40] ; # X
; # (forkErr Exe)
  call void @forkErr(i64 %0)
  unreachable
$42:
  %156 = phi i64 [%150, %$40] ; # X
; # (=0 @)
  %157 = icmp eq i32 %153, 0
  br i1 %157, label %$45, label %$44
$45:
  %158 = phi i64 [%156, %$42] ; # X
; # (setpgid 0 0)
  %159 = call i32 @setpgid(i32 0, i32 0)
; # (val 2 Pfd)
  %160 = getelementptr i32, i32* %107, i32 1
  %161 = load i32, i32* %160
; # (close (val 2 Pfd))
  %162 = call i32 @close(i32 %161)
; # (when (val Pfd) (dup2 @ 0) (close @))
; # (val Pfd)
  %163 = load i32, i32* %107
  %164 = icmp ne i32 %163, 0
  br i1 %164, label %$46, label %$47
$46:
  %165 = phi i64 [%158, %$45] ; # X
; # (dup2 @ 0)
  %166 = call i32 @dup2(i32 %163, i32 0)
; # (close @)
  %167 = call i32 @close(i32 %163)
  br label %$47
$47:
  %168 = phi i64 [%158, %$45], [%165, %$46] ; # X
; # (val Av)
  %169 = load i8*, i8** %121
; # (execvp (val Av) Av)
  %170 = call i32 @execvp(i8* %169, i8** %121)
; # (val Av)
  %171 = load i8*, i8** %121
; # (execErr (val Av))
  call void @execErr(i8* %171)
  unreachable
$44:
  %172 = phi i64 [%156, %$42] ; # X
  br label %$41
$41:
  %173 = phi i64 [%172, %$44] ; # X
  %174 = phi i64 [0, %$44] ; # ->
; # (let (Pid @ Fd (val 2 Pfd)) (setpgid Pid 0) (close (val Pfd)) (cl...
; # (val 2 Pfd)
  %175 = getelementptr i32, i32* %107, i32 1
  %176 = load i32, i32* %175
; # (setpgid Pid 0)
  %177 = call i32 @setpgid(i32 %153, i32 0)
; # (val Pfd)
  %178 = load i32, i32* %107
; # (close (val Pfd))
  %179 = call i32 @close(i32 %178)
; # (closeOnExec Exe Fd)
  call void @closeOnExec(i64 %0, i32 %176)
; # (initOutFile Fd)
  %180 = call i8* @initOutFile(i32 %176)
; # (pushOutFile Io (initOutFile Fd) Pid)
  call void @pushOutFile(i8* %2, i8* %180, i32 %153)
  br label %$2
$2:
  %181 = phi i64 [%4, %$4], [%59, %$7], [%102, %$28], [%173, %$41] ; # X
  ret void
}

define void @erOpen(i64, i64, i8*) align 8 {
$1:
; # (let Ct: (ctFrame Ct) (Ct: fd (dup 2)) (let Fd (if (nil? (needSym...
; # (Ct: fd (dup 2))
  %3 = getelementptr i8, i8* %2, i32 8
  %4 = bitcast i8* %3 to i32*
  %5 = call i32 @dup(i32 2)
  store i32 %5, i32* %4
; # (let Fd (if (nil? (needSymb Exe X)) (dup ((outFile (val $OutFile)...
; # (if (nil? (needSymb Exe X)) (dup ((outFile (val $OutFile)) fd)) (...
; # (needSymb Exe X)
  %6 = xor i64 %1, 8
  %7 = and i64 %6, 14
  %8 = icmp eq i64 %7, 0
  br i1 %8, label %$3, label %$2
$2:
  call void @symErr(i64 %0, i64 %1)
  unreachable
$3:
; # (nil? (needSymb Exe X))
  %9 = icmp eq i64 %1, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %9, label %$4, label %$5
$4:
; # (val $OutFile)
  %10 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 80) to i8**)
; # ((outFile (val $OutFile)) fd)
  %11 = bitcast i8* %10 to i32*
  %12 = load i32, i32* %11
; # (dup ((outFile (val $OutFile)) fd))
  %13 = call i32 @dup(i32 %12)
  br label %$6
$5:
; # (let (Nm (xName X) S (pathString Nm (b8 (pathSize Nm))) Flg (== (...
; # (xName X)
  %14 = call i64 @xName(i64 %1)
; # (pathSize Nm)
  %15 = call i64 @pathSize(i64 %14)
; # (b8 (pathSize Nm))
  %16 = alloca i8, i64 %15
; # (pathString Nm (b8 (pathSize Nm)))
  %17 = call i8* @pathString(i64 %14, i8* %16)
; # (val S)
  %18 = load i8, i8* %17
; # (== (val S) (char "+"))
  %19 = icmp eq i8 %18, 43
; # (when Flg (setq S (ofs S 1)))
  br i1 %19, label %$7, label %$8
$7:
  %20 = phi i8* [%17, %$5] ; # S
; # (ofs S 1)
  %21 = getelementptr i8, i8* %20, i32 1
  br label %$8
$8:
  %22 = phi i8* [%17, %$5], [%21, %$7] ; # S
; # (while (lt0 (if Flg (openWrAppend S) (openWr S))) (unless (== (gE...
  br label %$9
$9:
  %23 = phi i8* [%22, %$8], [%35, %$18] ; # S
; # (if Flg (openWrAppend S) (openWr S))
  br i1 %19, label %$10, label %$11
$10:
  %24 = phi i8* [%23, %$9] ; # S
; # (openWrAppend S)
  %25 = call i32 @openWrAppend(i8* %24)
  br label %$12
$11:
  %26 = phi i8* [%23, %$9] ; # S
; # (openWr S)
  %27 = call i32 @openWr(i8* %26)
  br label %$12
$12:
  %28 = phi i8* [%24, %$10], [%26, %$11] ; # S
  %29 = phi i32 [%25, %$10], [%27, %$11] ; # ->
; # (lt0 (if Flg (openWrAppend S) (openWr S)))
  %30 = icmp slt i32 %29, 0
  br i1 %30, label %$13, label %$14
$13:
  %31 = phi i8* [%28, %$12] ; # S
; # (unless (== (gErrno) EINTR) (openErr Exe X))
; # (gErrno)
  %32 = call i32 @gErrno()
; # (== (gErrno) EINTR)
  %33 = icmp eq i32 %32, 2
  br i1 %33, label %$16, label %$15
$15:
  %34 = phi i8* [%31, %$13] ; # S
; # (openErr Exe X)
  call void @openErr(i64 %0, i64 %1)
  unreachable
$16:
  %35 = phi i8* [%31, %$13] ; # S
; # (sigChk Exe)
  %36 = load volatile i32, i32* bitcast ([16 x i32]* @$Signal to i32*)
  %37 = icmp ne i32 %36, 0
  br i1 %37, label %$17, label %$18
$17:
  call void @sighandler(i64 %0)
  br label %$18
$18:
  br label %$9
$14:
  %38 = phi i8* [%28, %$12] ; # S
; # (closeOnExec Exe @)
  call void @closeOnExec(i64 %0, i32 %29)
  br label %$6
$6:
  %39 = phi i32 [%13, %$4], [%29, %$14] ; # ->
; # (dup2 Fd 2)
  %40 = call i32 @dup2(i32 %39, i32 2)
; # (close Fd)
  %41 = call i32 @close(i32 %39)
; # (pushErrFile Ct)
  call void @pushErrFile(i8* %2)
  ret void
}

define void @ctOpen(i64, i64, i8*) align 8 {
$1:
; # (let Ct: (ctFrame Ct) (cond ((nil? (needSymb Exe X)) (Ct: fd -1) ...
; # (cond ((nil? (needSymb Exe X)) (Ct: fd -1) (rdLockWait (currFd Ex...
; # (needSymb Exe X)
  %3 = xor i64 %1, 8
  %4 = and i64 %3, 14
  %5 = icmp eq i64 %4, 0
  br i1 %5, label %$4, label %$3
$3:
  call void @symErr(i64 %0, i64 %1)
  unreachable
$4:
; # (nil? (needSymb Exe X))
  %6 = icmp eq i64 %1, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %6, label %$6, label %$5
$6:
; # (Ct: fd -1)
  %7 = getelementptr i8, i8* %2, i32 8
  %8 = bitcast i8* %7 to i32*
  store i32 -1, i32* %8
; # (currFd Exe)
  %9 = call i32 @currFd(i64 %0)
; # (rdLockWait (currFd Exe) 0)
  call void @rdLockWait(i32 %9, i64 0)
  br label %$2
$5:
; # (t? X)
  %10 = icmp eq i64 %1, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %10, label %$8, label %$7
$8:
; # (Ct: fd -1)
  %11 = getelementptr i8, i8* %2, i32 8
  %12 = bitcast i8* %11 to i32*
  store i32 -1, i32* %12
; # (currFd Exe)
  %13 = call i32 @currFd(i64 %0)
; # (wrLockWait (currFd Exe) 0)
  call void @wrLockWait(i32 %13, i64 0)
  br label %$2
$7:
; # (let (Nm (xName X) S (pathString Nm (b8 (pathSize Nm))) Flg (== (...
; # (xName X)
  %14 = call i64 @xName(i64 %1)
; # (pathSize Nm)
  %15 = call i64 @pathSize(i64 %14)
; # (b8 (pathSize Nm))
  %16 = alloca i8, i64 %15
; # (pathString Nm (b8 (pathSize Nm)))
  %17 = call i8* @pathString(i64 %14, i8* %16)
; # (val S)
  %18 = load i8, i8* %17
; # (== (val S) (char "+"))
  %19 = icmp eq i8 %18, 43
; # (when Flg (setq S (ofs S 1)))
  br i1 %19, label %$9, label %$10
$9:
  %20 = phi i8* [%17, %$7] ; # S
; # (ofs S 1)
  %21 = getelementptr i8, i8* %20, i32 1
  br label %$10
$10:
  %22 = phi i8* [%17, %$7], [%21, %$9] ; # S
; # (while (lt0 (openRdWrCreate S)) (unless (== (gErrno) EINTR) (open...
  br label %$11
$11:
  %23 = phi i8* [%22, %$10], [%30, %$17] ; # S
; # (openRdWrCreate S)
  %24 = call i32 @openRdWrCreate(i8* %23)
; # (lt0 (openRdWrCreate S))
  %25 = icmp slt i32 %24, 0
  br i1 %25, label %$12, label %$13
$12:
  %26 = phi i8* [%23, %$11] ; # S
; # (unless (== (gErrno) EINTR) (openErr Exe X))
; # (gErrno)
  %27 = call i32 @gErrno()
; # (== (gErrno) EINTR)
  %28 = icmp eq i32 %27, 2
  br i1 %28, label %$15, label %$14
$14:
  %29 = phi i8* [%26, %$12] ; # S
; # (openErr Exe X)
  call void @openErr(i64 %0, i64 %1)
  unreachable
$15:
  %30 = phi i8* [%26, %$12] ; # S
; # (sigChk Exe)
  %31 = load volatile i32, i32* bitcast ([16 x i32]* @$Signal to i32*)
  %32 = icmp ne i32 %31, 0
  br i1 %32, label %$16, label %$17
$16:
  call void @sighandler(i64 %0)
  br label %$17
$17:
  br label %$11
$13:
  %33 = phi i8* [%23, %$11] ; # S
; # (let Fd (Ct: fd @) (if Flg (rdLockWait Fd 0) (wrLockWait Fd 0)) (...
; # (Ct: fd @)
  %34 = getelementptr i8, i8* %2, i32 8
  %35 = bitcast i8* %34 to i32*
  store i32 %24, i32* %35
; # (if Flg (rdLockWait Fd 0) (wrLockWait Fd 0))
  br i1 %19, label %$18, label %$19
$18:
  %36 = phi i8* [%33, %$13] ; # S
; # (rdLockWait Fd 0)
  call void @rdLockWait(i32 %24, i64 0)
  br label %$20
$19:
  %37 = phi i8* [%33, %$13] ; # S
; # (wrLockWait Fd 0)
  call void @wrLockWait(i32 %24, i64 0)
  br label %$20
$20:
  %38 = phi i8* [%36, %$18], [%37, %$19] ; # S
; # (closeOnExec Exe Fd)
  call void @closeOnExec(i64 %0, i32 %24)
  br label %$2
$2:
; # (pushCtlFile Ct)
  call void @pushCtlFile(i8* %2)
  ret void
}

define i32 @rlGetc(i8*) align 8 {
$1:
; # (if (waitFd 0 0 292MY) (stdinByte) -1)
; # (waitFd 0 0 292MY)
  %1 = call i64 @waitFd(i64 0, i32 0, i64 9223372036854775807)
  %2 = icmp ne i64 %1, 0
  br i1 %2, label %$2, label %$3
$2:
; # (stdinByte)
  %3 = call i32 @stdinByte()
  br label %$4
$3:
  br label %$4
$4:
  %4 = phi i32 [%3, %$2], [-1, %$3] ; # ->
  ret i32 %4
}

define i32 @rlAvail() align 8 {
$1:
; # (waitFd 0 0 60)
  %0 = call i64 @waitFd(i64 0, i32 0, i64 60)
; # (i32 (waitFd 0 0 60))
  %1 = trunc i64 %0 to i32
  ret i32 %1
}

define i32 @_getStdin() align 8 {
$1:
; # (let In: (inFile (val $InFile)) (set $Chr (cond ((lt0 (In: fd)) -...
; # (val $InFile)
  %0 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 72) to i8**)
; # (set $Chr (cond ((lt0 (In: fd)) -1) ((or (In: fd) (not (In: tty))...
; # (cond ((lt0 (In: fd)) -1) ((or (In: fd) (not (In: tty))) (if (and...
; # (In: fd)
  %1 = getelementptr i8, i8* %0, i32 8
  %2 = bitcast i8* %1 to i32*
  %3 = load i32, i32* %2
; # (lt0 (In: fd))
  %4 = icmp slt i32 %3, 0
  br i1 %4, label %$4, label %$3
$4:
  br label %$2
$3:
; # (or (In: fd) (not (In: tty)))
; # (In: fd)
  %5 = getelementptr i8, i8* %0, i32 8
  %6 = bitcast i8* %5 to i32*
  %7 = load i32, i32* %6
  %8 = icmp ne i32 %7, 0
  br i1 %8, label %$5, label %$6
$6:
; # (In: tty)
  %9 = getelementptr i8, i8* %0, i32 4128
  %10 = bitcast i8* %9 to i1*
  %11 = load i1, i1* %10
; # (not (In: tty))
  %12 = icmp eq i1 %11, 0
  br label %$5
$5:
  %13 = phi i1 [1, %$3], [%12, %$6] ; # ->
  br i1 %13, label %$8, label %$7
$8:
; # (if (and (== (In: ix) (In: cnt)) (or (lt0 (In: ix)) (=0 (slow (In...
; # (and (== (In: ix) (In: cnt)) (or (lt0 (In: ix)) (=0 (slow (In:)))...
; # (In: ix)
  %14 = getelementptr i8, i8* %0, i32 24
  %15 = bitcast i8* %14 to i32*
  %16 = load i32, i32* %15
; # (In: cnt)
  %17 = getelementptr i8, i8* %0, i32 28
  %18 = bitcast i8* %17 to i32*
  %19 = load i32, i32* %18
; # (== (In: ix) (In: cnt))
  %20 = icmp eq i32 %16, %19
  br i1 %20, label %$10, label %$9
$10:
; # (or (lt0 (In: ix)) (=0 (slow (In:))))
; # (In: ix)
  %21 = getelementptr i8, i8* %0, i32 24
  %22 = bitcast i8* %21 to i32*
  %23 = load i32, i32* %22
; # (lt0 (In: ix))
  %24 = icmp slt i32 %23, 0
  br i1 %24, label %$11, label %$12
$12:
; # (In:)
; # (slow (In:))
  %25 = call i32 @slow(i8* %0)
; # (=0 (slow (In:)))
  %26 = icmp eq i32 %25, 0
  br label %$11
$11:
  %27 = phi i1 [1, %$10], [%26, %$12] ; # ->
  br label %$9
$9:
  %28 = phi i1 [0, %$8], [%27, %$11] ; # ->
  br i1 %28, label %$13, label %$14
$13:
  br label %$15
$14:
; # (let I (In: ix) (prog1 (i32 (val (ofs (In: (buf)) I))) (when (== ...
; # (In: ix)
  %29 = getelementptr i8, i8* %0, i32 24
  %30 = bitcast i8* %29 to i32*
  %31 = load i32, i32* %30
; # (prog1 (i32 (val (ofs (In: (buf)) I))) (when (== @ (char "^J")) (...
; # (In: (buf))
  %32 = getelementptr i8, i8* %0, i32 32
; # (ofs (In: (buf)) I)
  %33 = getelementptr i8, i8* %32, i32 %31
; # (val (ofs (In: (buf)) I))
  %34 = load i8, i8* %33
; # (i32 (val (ofs (In: (buf)) I)))
  %35 = zext i8 %34 to i32
; # (when (== @ (char "^J")) (In: line (+ (In: line) 1)))
; # (== @ (char "^J"))
  %36 = icmp eq i32 %35, 10
  br i1 %36, label %$16, label %$17
$16:
; # (In: line (+ (In: line) 1))
  %37 = getelementptr i8, i8* %0, i32 16
  %38 = bitcast i8* %37 to i32*
  %39 = getelementptr i8, i8* %0, i32 16
  %40 = bitcast i8* %39 to i32*
  %41 = load i32, i32* %40
  %42 = add i32 %41, 1
  store i32 %42, i32* %38
  br label %$17
$17:
; # (In: ix (+ I 1))
  %43 = getelementptr i8, i8* %0, i32 24
  %44 = bitcast i8* %43 to i32*
  %45 = add i32 %31, 1
  store i32 %45, i32* %44
  br label %$15
$15:
  %46 = phi i32 [-1, %$13], [%35, %$17] ; # ->
  br label %$2
$7:
; # (let P (val $LinePtr) (unless P (when (val $LineBuf) (free @) (se...
; # (val $LinePtr)
  %47 = load i8*, i8** @$LinePtr
; # (unless P (when (val $LineBuf) (free @) (set $LineBuf null)) (flu...
  %48 = icmp ne i8* %47, null
  br i1 %48, label %$19, label %$18
$18:
  %49 = phi i8* [%47, %$7] ; # P
; # (when (val $LineBuf) (free @) (set $LineBuf null))
; # (val $LineBuf)
  %50 = load i8*, i8** @$LineBuf
  %51 = icmp ne i8* %50, null
  br i1 %51, label %$20, label %$21
$20:
  %52 = phi i8* [%49, %$18] ; # P
; # (free @)
  call void @free(i8* %50)
; # (set $LineBuf null)
  store i8* null, i8** @$LineBuf
  br label %$21
$21:
  %53 = phi i8* [%49, %$18], [%52, %$20] ; # P
; # (flushAll)
  call void @flushAll()
; # (unless (setq P (set $LineBuf (gReadline (val $LinePrmt)))) (wrnl...
; # (set $LineBuf (gReadline (val $LinePrmt)))
; # (val $LinePrmt)
  %54 = load i8*, i8** @$LinePrmt
; # (gReadline (val $LinePrmt))
  %55 = call i8* @gReadline(i8* %54)
  store i8* %55, i8** @$LineBuf
  %56 = icmp ne i8* %55, null
  br i1 %56, label %$23, label %$22
$22:
  %57 = phi i8* [%55, %$21] ; # P
; # (wrnl)
  %58 = call i64 @wrnl()
; # (when (or (val $Bind) (== (val $LinePrmt) (val $ContPrmt))) (err ...
; # (or (val $Bind) (== (val $LinePrmt) (val $ContPrmt)))
; # (val $Bind)
  %59 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  %60 = load i64, i64* %59
  %61 = icmp ne i64 %60, 0
  br i1 %61, label %$24, label %$25
$25:
  %62 = phi i8* [%57, %$22] ; # P
; # (val $LinePrmt)
  %63 = load i8*, i8** @$LinePrmt
; # (val $ContPrmt)
  %64 = load i8*, i8** @$ContPrmt
; # (== (val $LinePrmt) (val $ContPrmt))
  %65 = icmp eq i8* %63, %64
  br label %$24
$24:
  %66 = phi i8* [%57, %$22], [%62, %$25] ; # P
  %67 = phi i1 [1, %$22], [%65, %$25] ; # ->
  br i1 %67, label %$26, label %$27
$26:
  %68 = phi i8* [%66, %$24] ; # P
; # (err 0 0 $Empty null)
  call void @err(i64 0, i64 0, i8* bitcast ([1 x i8]* @$Empty to i8*), i8* null)
  unreachable
$27:
  %69 = phi i8* [%66, %$24] ; # P
; # (bye 0)
  call void @bye(i32 0)
  unreachable
$23:
  %70 = phi i8* [%55, %$21] ; # P
; # (set $LinePrmt (val $ContPrmt))
; # (val $ContPrmt)
  %71 = load i8*, i8** @$ContPrmt
  store i8* %71, i8** @$LinePrmt
; # (unless (or (=0 (val P)) (== @ 32) (and (== @ (char ".")) (=0 (va...
; # (or (=0 (val P)) (== @ 32) (and (== @ (char ".")) (=0 (val (inc P...
; # (val P)
  %72 = load i8, i8* %70
; # (=0 (val P))
  %73 = icmp eq i8 %72, 0
  br i1 %73, label %$28, label %$29
$29:
  %74 = phi i8* [%70, %$23] ; # P
; # (== @ 32)
  %75 = icmp eq i8 %72, 32
  br i1 %75, label %$28, label %$30
$30:
  %76 = phi i8* [%74, %$29] ; # P
; # (and (== @ (char ".")) (=0 (val (inc P))))
; # (== @ (char "."))
  %77 = icmp eq i8 %72, 46
  br i1 %77, label %$32, label %$31
$32:
  %78 = phi i8* [%76, %$30] ; # P
; # (inc P)
  %79 = getelementptr i8, i8* %78, i32 1
; # (val (inc P))
  %80 = load i8, i8* %79
; # (=0 (val (inc P)))
  %81 = icmp eq i8 %80, 0
  br label %$31
$31:
  %82 = phi i8* [%76, %$30], [%78, %$32] ; # P
  %83 = phi i1 [0, %$30], [%81, %$32] ; # ->
  br i1 %83, label %$28, label %$33
$33:
  %84 = phi i8* [%82, %$31] ; # P
; # (and (currentLine) (=0 (strcmp @ P)))
; # (currentLine)
  %85 = call i8* @currentLine()
  %86 = icmp ne i8* %85, null
  br i1 %86, label %$35, label %$34
$35:
  %87 = phi i8* [%84, %$33] ; # P
; # (strcmp @ P)
  %88 = call i32 @strcmp(i8* %85, i8* %87)
; # (=0 (strcmp @ P))
  %89 = icmp eq i32 %88, 0
  br label %$34
$34:
  %90 = phi i8* [%84, %$33], [%87, %$35] ; # P
  %91 = phi i1 [0, %$33], [%89, %$35] ; # ->
  br label %$28
$28:
  %92 = phi i8* [%70, %$23], [%74, %$29], [%82, %$31], [%90, %$34] ; # P
  %93 = phi i1 [1, %$23], [1, %$29], [1, %$31], [%91, %$34] ; # ->
  br i1 %93, label %$37, label %$36
$36:
  %94 = phi i8* [%92, %$28] ; # P
; # (add_history P)
  call void @add_history(i8* %94)
  br label %$37
$37:
  %95 = phi i8* [%92, %$28], [%94, %$36] ; # P
  br label %$19
$19:
  %96 = phi i8* [%47, %$7], [%95, %$37] ; # P
; # (nond ((val P) (set $LinePtr null) (char "^J")) (NIL (set $LinePt...
; # (val P)
  %97 = load i8, i8* %96
  %98 = icmp ne i8 %97, 0
  br i1 %98, label %$39, label %$40
$40:
  %99 = phi i8* [%96, %$19] ; # P
; # (set $LinePtr null)
  store i8* null, i8** @$LinePtr
  br label %$38
$39:
  %100 = phi i8* [%96, %$19] ; # P
; # (set $LinePtr (inc P))
; # (inc P)
  %101 = getelementptr i8, i8* %100, i32 1
  store i8* %101, i8** @$LinePtr
; # (i32 @)
  %102 = zext i8 %97 to i32
  br label %$38
$38:
  %103 = phi i8* [%99, %$40], [%100, %$39] ; # P
  %104 = phi i32 [10, %$40], [%102, %$39] ; # ->
  br label %$2
$2:
  %105 = phi i32 [-1, %$4], [%46, %$15], [%104, %$38] ; # ->
  store i32 %105, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
  ret i32 %105
}

define i32 @getChar(i32) align 8 {
$1:
; # (cond ((>= 127 C) C) ((== C (hex "FF")) (i32 TOP)) (T (let B (ifn...
; # (>= 127 C)
  %1 = icmp sge i32 127, %0
  br i1 %1, label %$4, label %$3
$4:
  br label %$2
$3:
; # (== C (hex "FF"))
  %2 = icmp eq i32 %0, 255
  br i1 %2, label %$6, label %$5
$6:
; # (i32 TOP)
  br label %$2
$5:
; # (let B (ifn (& C (hex "20")) (& C (hex "1F")) (let A (ifn (& C (h...
; # (ifn (& C (hex "20")) (& C (hex "1F")) (let A (ifn (& C (hex "10"...
; # (& C (hex "20"))
  %3 = and i32 %0, 32
  %4 = icmp ne i32 %3, 0
  br i1 %4, label %$8, label %$7
$7:
; # (& C (hex "1F"))
  %5 = and i32 %0, 31
  br label %$9
$8:
; # (let A (ifn (& C (hex "10")) (& C (hex "0F")) (| (shl (& C 7) 6) ...
; # (ifn (& C (hex "10")) (& C (hex "0F")) (| (shl (& C 7) 6) (& (cal...
; # (& C (hex "10"))
  %6 = and i32 %0, 16
  %7 = icmp ne i32 %6, 0
  br i1 %7, label %$11, label %$10
$10:
; # (& C (hex "0F"))
  %8 = and i32 %0, 15
  br label %$12
$11:
; # (& C 7)
  %9 = and i32 %0, 7
; # (shl (& C 7) 6)
  %10 = shl i32 %9, 6
; # (call $Get)
  %11 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %12 = call i32 %11()
; # (& (call $Get) (hex "3F"))
  %13 = and i32 %12, 63
; # (| (shl (& C 7) 6) (& (call $Get) (hex "3F")))
  %14 = or i32 %10, %13
  br label %$12
$12:
  %15 = phi i32 [%8, %$10], [%14, %$11] ; # ->
; # (shl A 6)
  %16 = shl i32 %15, 6
; # (call $Get)
  %17 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %18 = call i32 %17()
; # (& (call $Get) (hex "3F"))
  %19 = and i32 %18, 63
; # (| (shl A 6) (& (call $Get) (hex "3F")))
  %20 = or i32 %16, %19
  br label %$9
$9:
  %21 = phi i32 [%5, %$7], [%20, %$12] ; # ->
; # (shl B 6)
  %22 = shl i32 %21, 6
; # (call $Get)
  %23 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %24 = call i32 %23()
; # (& (call $Get) (hex "3F"))
  %25 = and i32 %24, 63
; # (| (shl B 6) (& (call $Get) (hex "3F")))
  %26 = or i32 %22, %25
  br label %$2
$2:
  %27 = phi i32 [%0, %$4], [1114112, %$6], [%26, %$9] ; # ->
  ret i32 %27
}

define i32 @skipc(i32) align 8 {
$1:
; # (let Chr (val $Chr) (loop (while (>= 32 Chr) (when (lt0 (setq Chr...
; # (val $Chr)
  %1 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
; # (loop (while (>= 32 Chr) (when (lt0 (setq Chr (call $Get))) (ret ...
  br label %$2
$2:
  %2 = phi i32 [%1, %$1], [%25, %$12] ; # Chr
; # (while (>= 32 Chr) (when (lt0 (setq Chr (call $Get))) (ret Chr)))...
  br label %$3
$3:
  %3 = phi i32 [%2, %$2], [%10, %$7] ; # Chr
; # (>= 32 Chr)
  %4 = icmp sge i32 32, %3
  br i1 %4, label %$4, label %$5
$4:
  %5 = phi i32 [%3, %$3] ; # Chr
; # (when (lt0 (setq Chr (call $Get))) (ret Chr))
; # (call $Get)
  %6 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %7 = call i32 %6()
; # (lt0 (setq Chr (call $Get)))
  %8 = icmp slt i32 %7, 0
  br i1 %8, label %$6, label %$7
$6:
  %9 = phi i32 [%7, %$4] ; # Chr
; # (ret Chr)
  ret i32 %9
$7:
  %10 = phi i32 [%7, %$4] ; # Chr
  br label %$3
$5:
  %11 = phi i32 [%3, %$3] ; # Chr
; # (unless (== Chr C) (ret Chr))
; # (== Chr C)
  %12 = icmp eq i32 %11, %0
  br i1 %12, label %$9, label %$8
$8:
  %13 = phi i32 [%11, %$5] ; # Chr
; # (ret Chr)
  ret i32 %13
$9:
  %14 = phi i32 [%11, %$5] ; # Chr
; # (until (== (setq Chr (call $Get)) (char "^J")) (when (lt0 Chr) (r...
  br label %$10
$10:
  %15 = phi i32 [%14, %$9], [%22, %$14] ; # Chr
; # (call $Get)
  %16 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %17 = call i32 %16()
; # (== (setq Chr (call $Get)) (char "^J"))
  %18 = icmp eq i32 %17, 10
  br i1 %18, label %$12, label %$11
$11:
  %19 = phi i32 [%17, %$10] ; # Chr
; # (when (lt0 Chr) (ret Chr))
; # (lt0 Chr)
  %20 = icmp slt i32 %19, 0
  br i1 %20, label %$13, label %$14
$13:
  %21 = phi i32 [%19, %$11] ; # Chr
; # (ret Chr)
  ret i32 %21
$14:
  %22 = phi i32 [%19, %$11] ; # Chr
  br label %$10
$12:
  %23 = phi i32 [%17, %$10] ; # Chr
; # (call $Get)
  %24 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %25 = call i32 %24()
  br label %$2
}

define void @comment() align 8 {
$1:
; # (let Chr (call $Get) (if (== Chr (char "{")) (let N 0 (loop (? (l...
; # (call $Get)
  %0 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %1 = call i32 %0()
; # (if (== Chr (char "{")) (let N 0 (loop (? (lt0 (setq Chr (call $G...
; # (== Chr (char "{"))
  %2 = icmp eq i32 %1, 123
  br i1 %2, label %$2, label %$3
$2:
  %3 = phi i32 [%1, %$1] ; # Chr
; # (let N 0 (loop (? (lt0 (setq Chr (call $Get)))) (if (and (== Chr ...
; # (loop (? (lt0 (setq Chr (call $Get)))) (if (and (== Chr (char "#"...
  br label %$5
$5:
  %4 = phi i32 [%3, %$2], [%40, %$12] ; # Chr
  %5 = phi i64 [0, %$2], [%41, %$12] ; # N
; # (? (lt0 (setq Chr (call $Get))))
; # (call $Get)
  %6 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %7 = call i32 %6()
; # (lt0 (setq Chr (call $Get)))
  %8 = icmp slt i32 %7, 0
  br i1 %8, label %$7, label %$6
$6:
  %9 = phi i32 [%7, %$5] ; # Chr
  %10 = phi i64 [%5, %$5] ; # N
; # (if (and (== Chr (char "#")) (== (setq Chr (call $Get)) (char "{"...
; # (and (== Chr (char "#")) (== (setq Chr (call $Get)) (char "{")))
; # (== Chr (char "#"))
  %11 = icmp eq i32 %9, 35
  br i1 %11, label %$9, label %$8
$9:
  %12 = phi i32 [%9, %$6] ; # Chr
  %13 = phi i64 [%10, %$6] ; # N
; # (call $Get)
  %14 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %15 = call i32 %14()
; # (== (setq Chr (call $Get)) (char "{"))
  %16 = icmp eq i32 %15, 123
  br label %$8
$8:
  %17 = phi i32 [%9, %$6], [%15, %$9] ; # Chr
  %18 = phi i64 [%10, %$6], [%13, %$9] ; # N
  %19 = phi i1 [0, %$6], [%16, %$9] ; # ->
  br i1 %19, label %$10, label %$11
$10:
  %20 = phi i32 [%17, %$8] ; # Chr
  %21 = phi i64 [%18, %$8] ; # N
; # (inc 'N)
  %22 = add i64 %21, 1
  br label %$12
$11:
  %23 = phi i32 [%17, %$8] ; # Chr
  %24 = phi i64 [%18, %$8] ; # N
; # (? (and (== Chr (char "}")) (== (setq Chr (call $Get)) (char "#")...
; # (and (== Chr (char "}")) (== (setq Chr (call $Get)) (char "#")) (...
; # (== Chr (char "}"))
  %25 = icmp eq i32 %23, 125
  br i1 %25, label %$14, label %$13
$14:
  %26 = phi i32 [%23, %$11] ; # Chr
  %27 = phi i64 [%24, %$11] ; # N
; # (call $Get)
  %28 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %29 = call i32 %28()
; # (== (setq Chr (call $Get)) (char "#"))
  %30 = icmp eq i32 %29, 35
  br i1 %30, label %$15, label %$13
$15:
  %31 = phi i32 [%29, %$14] ; # Chr
  %32 = phi i64 [%27, %$14] ; # N
; # (dec 'N)
  %33 = sub i64 %32, 1
; # (lt0 (dec 'N))
  %34 = icmp slt i64 %33, 0
  br label %$13
$13:
  %35 = phi i32 [%23, %$11], [%29, %$14], [%31, %$15] ; # Chr
  %36 = phi i64 [%24, %$11], [%27, %$14], [%33, %$15] ; # N
  %37 = phi i1 [0, %$11], [0, %$14], [%34, %$15] ; # ->
  br i1 %37, label %$7, label %$16
$16:
  %38 = phi i32 [%35, %$13] ; # Chr
  %39 = phi i64 [%36, %$13] ; # N
  br label %$12
$12:
  %40 = phi i32 [%20, %$10], [%38, %$16] ; # Chr
  %41 = phi i64 [%22, %$10], [%39, %$16] ; # N
  br label %$5
$7:
  %42 = phi i32 [%7, %$5], [%35, %$13] ; # Chr
  %43 = phi i64 [%5, %$5], [%36, %$13] ; # N
  %44 = phi i64 [0, %$5], [0, %$13] ; # ->
  br label %$4
$3:
  %45 = phi i32 [%1, %$1] ; # Chr
; # (until (== Chr (char "^J")) (? (lt0 Chr)) (setq Chr (call $Get)))...
  br label %$17
$17:
  %46 = phi i32 [%45, %$3], [%52, %$20] ; # Chr
; # (== Chr (char "^J"))
  %47 = icmp eq i32 %46, 10
  br i1 %47, label %$19, label %$18
$18:
  %48 = phi i32 [%46, %$17] ; # Chr
; # (? (lt0 Chr))
; # (lt0 Chr)
  %49 = icmp slt i32 %48, 0
  br i1 %49, label %$19, label %$20
$20:
  %50 = phi i32 [%48, %$18] ; # Chr
; # (call $Get)
  %51 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %52 = call i32 %51()
  br label %$17
$19:
  %53 = phi i32 [%46, %$17], [%48, %$18] ; # Chr
  br label %$4
$4:
  %54 = phi i32 [%42, %$7], [%53, %$19] ; # Chr
; # (call $Get)
  %55 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %56 = call i32 %55()
  ret void
}

define i32 @skip() align 8 {
$1:
; # (loop (let Chr (val $Chr) (when (lt0 Chr) (ret Chr)) (while (>= (...
  br label %$2
$2:
; # (let Chr (val $Chr) (when (lt0 Chr) (ret Chr)) (while (>= (char "...
; # (val $Chr)
  %0 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
; # (when (lt0 Chr) (ret Chr))
; # (lt0 Chr)
  %1 = icmp slt i32 %0, 0
  br i1 %1, label %$3, label %$4
$3:
  %2 = phi i32 [%0, %$2] ; # Chr
; # (ret Chr)
  ret i32 %2
$4:
  %3 = phi i32 [%0, %$2] ; # Chr
; # (while (>= (char " ") Chr) (when (lt0 (setq Chr (call $Get))) (re...
  br label %$5
$5:
  %4 = phi i32 [%3, %$4], [%11, %$9] ; # Chr
; # (>= (char " ") Chr)
  %5 = icmp sge i32 32, %4
  br i1 %5, label %$6, label %$7
$6:
  %6 = phi i32 [%4, %$5] ; # Chr
; # (when (lt0 (setq Chr (call $Get))) (ret Chr))
; # (call $Get)
  %7 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %8 = call i32 %7()
; # (lt0 (setq Chr (call $Get)))
  %9 = icmp slt i32 %8, 0
  br i1 %9, label %$8, label %$9
$8:
  %10 = phi i32 [%8, %$6] ; # Chr
; # (ret Chr)
  ret i32 %10
$9:
  %11 = phi i32 [%8, %$6] ; # Chr
  br label %$5
$7:
  %12 = phi i32 [%4, %$5] ; # Chr
; # (unless (== Chr (char "#")) (ret Chr))
; # (== Chr (char "#"))
  %13 = icmp eq i32 %12, 35
  br i1 %13, label %$11, label %$10
$10:
  %14 = phi i32 [%12, %$7] ; # Chr
; # (ret Chr)
  ret i32 %14
$11:
  %15 = phi i32 [%12, %$7] ; # Chr
; # (comment)
  call void @comment()
  br label %$2
}

define i32 @uniChr(i32) align 8 {
$1:
; # (when (and (>= Chr (char "0")) (>= (char "9") Chr)) (dec 'Chr (ch...
; # (and (>= Chr (char "0")) (>= (char "9") Chr))
; # (>= Chr (char "0"))
  %1 = icmp sge i32 %0, 48
  br i1 %1, label %$3, label %$2
$3:
  %2 = phi i32 [%0, %$1] ; # Chr
; # (>= (char "9") Chr)
  %3 = icmp sge i32 57, %2
  br label %$2
$2:
  %4 = phi i32 [%0, %$1], [%2, %$3] ; # Chr
  %5 = phi i1 [0, %$1], [%3, %$3] ; # ->
  br i1 %5, label %$4, label %$5
$4:
  %6 = phi i32 [%4, %$2] ; # Chr
; # (dec 'Chr (char "0"))
  %7 = sub i32 %6, 48
; # (until (== (call $Get) (char "\\")) (unless (and (>= (val $Chr) (...
  br label %$6
$6:
  %8 = phi i32 [%7, %$4], [%25, %$12] ; # Chr
; # (call $Get)
  %9 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %10 = call i32 %9()
; # (== (call $Get) (char "\\"))
  %11 = icmp eq i32 %10, 92
  br i1 %11, label %$8, label %$7
$7:
  %12 = phi i32 [%8, %$6] ; # Chr
; # (unless (and (>= (val $Chr) (char "0")) (>= (char "9") (val $Chr)...
; # (and (>= (val $Chr) (char "0")) (>= (char "9") (val $Chr)))
; # (val $Chr)
  %13 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
; # (>= (val $Chr) (char "0"))
  %14 = icmp sge i32 %13, 48
  br i1 %14, label %$10, label %$9
$10:
  %15 = phi i32 [%12, %$7] ; # Chr
; # (val $Chr)
  %16 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
; # (>= (char "9") (val $Chr))
  %17 = icmp sge i32 57, %16
  br label %$9
$9:
  %18 = phi i32 [%12, %$7], [%15, %$10] ; # Chr
  %19 = phi i1 [0, %$7], [%17, %$10] ; # ->
  br i1 %19, label %$12, label %$11
$11:
  %20 = phi i32 [%18, %$9] ; # Chr
; # (badInput)
  call void @badInput()
  unreachable
$12:
  %21 = phi i32 [%18, %$9] ; # Chr
; # (* Chr 10)
  %22 = mul i32 %21, 10
; # (val $Chr)
  %23 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
; # (- (val $Chr) (char "0"))
  %24 = sub i32 %23, 48
; # (+ (* Chr 10) (- (val $Chr) (char "0")))
  %25 = add i32 %22, %24
  br label %$6
$8:
  %26 = phi i32 [%8, %$6] ; # Chr
  br label %$5
$5:
  %27 = phi i32 [%4, %$2], [%26, %$8] ; # Chr
  ret i32 %27
}

define i1 @testEsc(i32) align 8 {
$1:
; # (loop (? (lt0 Chr) NO) (? (== Chr (char "\^")) (when (== (setq Ch...
  br label %$2
$2:
  %1 = phi i32 [%0, %$1], [%46, %$28] ; # Chr
; # (? (lt0 Chr) NO)
; # (lt0 Chr)
  %2 = icmp slt i32 %1, 0
  br i1 %2, label %$5, label %$3
$5:
  %3 = phi i32 [%1, %$2] ; # Chr
  br label %$4
$3:
  %4 = phi i32 [%1, %$2] ; # Chr
; # (? (== Chr (char "\^")) (when (== (setq Chr (call $Get)) (char "@...
; # (== Chr (char "\^"))
  %5 = icmp eq i32 %4, 94
  br i1 %5, label %$7, label %$6
$7:
  %6 = phi i32 [%4, %$3] ; # Chr
; # (when (== (setq Chr (call $Get)) (char "@")) (badInput))
; # (call $Get)
  %7 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %8 = call i32 %7()
; # (== (setq Chr (call $Get)) (char "@"))
  %9 = icmp eq i32 %8, 64
  br i1 %9, label %$8, label %$9
$8:
  %10 = phi i32 [%8, %$7] ; # Chr
; # (badInput)
  call void @badInput()
  unreachable
$9:
  %11 = phi i32 [%8, %$7] ; # Chr
; # (set $Chr (if (== Chr (char "?")) 127 (& Chr (hex "1F"))))
; # (if (== Chr (char "?")) 127 (& Chr (hex "1F")))
; # (== Chr (char "?"))
  %12 = icmp eq i32 %11, 63
  br i1 %12, label %$10, label %$11
$10:
  %13 = phi i32 [%11, %$9] ; # Chr
  br label %$12
$11:
  %14 = phi i32 [%11, %$9] ; # Chr
; # (& Chr (hex "1F"))
  %15 = and i32 %14, 31
  br label %$12
$12:
  %16 = phi i32 [%13, %$10], [%14, %$11] ; # Chr
  %17 = phi i32 [127, %$10], [%15, %$11] ; # ->
  store i32 %17, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
  br label %$4
$6:
  %18 = phi i32 [%4, %$3] ; # Chr
; # (? (<> Chr (char "\\")) (set $Chr (getChar Chr)) YES)
; # (<> Chr (char "\\"))
  %19 = icmp ne i32 %18, 92
  br i1 %19, label %$14, label %$13
$14:
  %20 = phi i32 [%18, %$6] ; # Chr
; # (set $Chr (getChar Chr))
; # (getChar Chr)
  %21 = call i32 @getChar(i32 %20)
  store i32 %21, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
  br label %$4
$13:
  %22 = phi i32 [%18, %$6] ; # Chr
; # (? (<> (char "^J") (setq Chr (call $Get))) (case Chr ((char "b") ...
; # (call $Get)
  %23 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %24 = call i32 %23()
; # (<> (char "^J") (setq Chr (call $Get)))
  %25 = icmp ne i32 10, %24
  br i1 %25, label %$16, label %$15
$16:
  %26 = phi i32 [%24, %$13] ; # Chr
; # (case Chr ((char "b") (set $Chr (char "^H"))) ((char "e") (set $C...
  switch i32 %26, label %$17 [
    i32 98, label %$19
    i32 101, label %$20
    i32 110, label %$21
    i32 114, label %$22
    i32 116, label %$23
  ]
$19:
  %27 = phi i32 [%26, %$16] ; # Chr
; # (set $Chr (char "^H"))
  store i32 8, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
  br label %$18
$20:
  %28 = phi i32 [%26, %$16] ; # Chr
; # (set $Chr (char "^["))
  store i32 27, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
  br label %$18
$21:
  %29 = phi i32 [%26, %$16] ; # Chr
; # (set $Chr (char "^J"))
  store i32 10, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
  br label %$18
$22:
  %30 = phi i32 [%26, %$16] ; # Chr
; # (set $Chr (char "^M"))
  store i32 13, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
  br label %$18
$23:
  %31 = phi i32 [%26, %$16] ; # Chr
; # (set $Chr (char "^I"))
  store i32 9, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
  br label %$18
$17:
  %32 = phi i32 [%26, %$16] ; # Chr
; # (set $Chr (uniChr Chr))
; # (uniChr Chr)
  %33 = call i32 @uniChr(i32 %32)
  store i32 %33, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
  br label %$18
$18:
  %34 = phi i32 [%27, %$19], [%28, %$20], [%29, %$21], [%30, %$22], [%31, %$23], [%32, %$17] ; # Chr
  %35 = phi i32 [8, %$19], [27, %$20], [10, %$21], [13, %$22], [9, %$23], [%33, %$17] ; # ->
  br label %$4
$15:
  %36 = phi i32 [%24, %$13] ; # Chr
; # (loop (setq Chr (call $Get)) (? (and (<> Chr (char " ")) (<> Chr ...
  br label %$24
$24:
  %37 = phi i32 [%36, %$15], [%45, %$27] ; # Chr
; # (call $Get)
  %38 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %39 = call i32 %38()
; # (? (and (<> Chr (char " ")) (<> Chr (char "^I"))))
; # (and (<> Chr (char " ")) (<> Chr (char "^I")))
; # (<> Chr (char " "))
  %40 = icmp ne i32 %39, 32
  br i1 %40, label %$26, label %$25
$26:
  %41 = phi i32 [%39, %$24] ; # Chr
; # (<> Chr (char "^I"))
  %42 = icmp ne i32 %41, 9
  br label %$25
$25:
  %43 = phi i32 [%39, %$24], [%41, %$26] ; # Chr
  %44 = phi i1 [0, %$24], [%42, %$26] ; # ->
  br i1 %44, label %$28, label %$27
$27:
  %45 = phi i32 [%43, %$25] ; # Chr
  br label %$24
$28:
  %46 = phi i32 [%43, %$25] ; # Chr
  %47 = phi i64 [0, %$25] ; # ->
  br label %$2
$4:
  %48 = phi i32 [%3, %$5], [%16, %$12], [%20, %$14], [%34, %$18] ; # Chr
  %49 = phi i1 [0, %$5], [1, %$12], [1, %$14], [1, %$18] ; # ->
  ret i1 %49
}

define i64 @anonymous(i64) align 8 {
$1:
; # (let P (push 0 Nm) (unless (== (symByte P) (char "$")) (ret 0)) (...
; # (push 0 Nm)
  %1 = alloca i64, i64 2, align 16
  store i64 0, i64* %1
  %2 = getelementptr i64, i64* %1, i32 1
  store i64 %0, i64* %2
; # (unless (== (symByte P) (char "$")) (ret 0))
; # (symByte P)
  %3 = call i8 @symByte(i64* %1)
; # (== (symByte P) (char "$"))
  %4 = icmp eq i8 %3, 36
  br i1 %4, label %$3, label %$2
$2:
; # (ret 0)
  ret i64 0
$3:
; # (let B (- (symByte P) (char "0")) (unless (>= 7 B) (ret 0)) (let ...
; # (symByte P)
  %5 = call i8 @symByte(i64* %1)
; # (- (symByte P) (char "0"))
  %6 = sub i8 %5, 48
; # (unless (>= 7 B) (ret 0))
; # (>= 7 B)
  %7 = icmp uge i8 7, %6
  br i1 %7, label %$5, label %$4
$4:
; # (ret 0)
  ret i64 0
$5:
; # (let N (i64 B) (loop (? (=0 (symByte P)) (sym (shl N 4))) (? (> (...
; # (i64 B)
  %8 = zext i8 %6 to i64
; # (loop (? (=0 (symByte P)) (sym (shl N 4))) (? (> (- @ (char "0"))...
  br label %$6
$6:
  %9 = phi i64 [%8, %$5], [%22, %$10] ; # N
; # (? (=0 (symByte P)) (sym (shl N 4)))
; # (symByte P)
  %10 = call i8 @symByte(i64* %1)
; # (=0 (symByte P))
  %11 = icmp eq i8 %10, 0
  br i1 %11, label %$9, label %$7
$9:
  %12 = phi i64 [%9, %$6] ; # N
; # (shl N 4)
  %13 = shl i64 %12, 4
; # (sym (shl N 4))
  %14 = or i64 %13, 8
  br label %$8
$7:
  %15 = phi i64 [%9, %$6] ; # N
; # (? (> (- @ (char "0")) 7) 0)
; # (- @ (char "0"))
  %16 = sub i8 %10, 48
; # (> (- @ (char "0")) 7)
  %17 = icmp ugt i8 %16, 7
  br i1 %17, label %$11, label %$10
$11:
  %18 = phi i64 [%15, %$7] ; # N
  br label %$8
$10:
  %19 = phi i64 [%15, %$7] ; # N
; # (i64 @)
  %20 = zext i8 %16 to i64
; # (shl N 3)
  %21 = shl i64 %19, 3
; # (| (i64 @) (shl N 3))
  %22 = or i64 %20, %21
  br label %$6
$8:
  %23 = phi i64 [%12, %$9], [%18, %$11] ; # N
  %24 = phi i64 [%14, %$9], [0, %$11] ; # ->
  ret i64 %24
}

define i64 @rdAtom(i32) align 8 {
$1:
; # (let (Int (save (val $Intern)) P (push 4 NIL ZERO NIL) C (val $Ch...
; # (val $Intern)
  %1 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 0) to i64) to i64*
  %2 = load i64, i64* %1
; # (save (val $Intern))
  %3 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %4 = load i64, i64* %3
  %5 = alloca i64, i64 2, align 16
  %6 = ptrtoint i64* %5 to i64
  %7 = inttoptr i64 %6 to i64*
  store i64 %2, i64* %7
  %8 = add i64 %6, 8
  %9 = inttoptr i64 %8 to i64*
  store i64 %4, i64* %9
  %10 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %6, i64* %10
; # (push 4 NIL ZERO NIL)
  %11 = alloca i64, i64 4, align 16
  store i64 4, i64* %11
  %12 = getelementptr i64, i64* %11, i32 2
  store i64 2, i64* %12
; # (val $Chr)
  %13 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
; # (when (and (== Chr (char "%")) (== C (char "~"))) (when (nil? (cd...
; # (and (== Chr (char "%")) (== C (char "~")))
; # (== Chr (char "%"))
  %14 = icmp eq i32 %0, 37
  br i1 %14, label %$3, label %$2
$3:
  %15 = phi i32 [%0, %$1] ; # Chr
  %16 = phi i32 [%13, %$1] ; # C
; # (== C (char "~"))
  %17 = icmp eq i32 %16, 126
  br label %$2
$2:
  %18 = phi i32 [%0, %$1], [%15, %$3] ; # Chr
  %19 = phi i32 [%13, %$1], [%16, %$3] ; # C
  %20 = phi i1 [0, %$1], [%17, %$3] ; # ->
  br i1 %20, label %$4, label %$5
$4:
  %21 = phi i32 [%18, %$2] ; # Chr
  %22 = phi i32 [%19, %$2] ; # C
; # (when (nil? (cdr Int)) (symNspErr 0 $rem))
; # (cdr Int)
  %23 = inttoptr i64 %2 to i64*
  %24 = getelementptr i64, i64* %23, i32 1
  %25 = load i64, i64* %24
; # (nil? (cdr Int))
  %26 = icmp eq i64 %25, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %26, label %$6, label %$7
$6:
  %27 = phi i32 [%21, %$4] ; # Chr
  %28 = phi i32 [%22, %$4] ; # C
; # (symNspErr 0 $rem)
  call void @symNspErr(i64 0, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 1032) to i64))
  unreachable
$7:
  %29 = phi i32 [%21, %$4] ; # Chr
  %30 = phi i32 [%22, %$4] ; # C
; # (set $Intern @)
  %31 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 0) to i64) to i64*
  store i64 %25, i64* %31
; # (call $Get)
  %32 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %33 = call i32 %32()
; # (call $Get)
  %34 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %35 = call i32 %34()
  br label %$5
$5:
  %36 = phi i32 [%18, %$2], [%33, %$7] ; # Chr
  %37 = phi i32 [%19, %$2], [%35, %$7] ; # C
; # (ofs P 2)
  %38 = getelementptr i64, i64* %11, i32 2
; # (link (ofs P 2))
  %39 = ptrtoint i64* %38 to i64
  %40 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %41 = load i64, i64* %40
  %42 = inttoptr i64 %39 to i64*
  %43 = getelementptr i64, i64* %42, i32 1
  store i64 %41, i64* %43
  %44 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %39, i64* %44
; # (i8 Chr)
  %45 = trunc i32 %36 to i8
; # (byteSym (i8 Chr) P)
  call void @byteSym(i8 %45, i64* %11)
; # (while (ge0 Chr) (if (== Chr (char "~")) (let S (requestSym (val ...
  br label %$8
$8:
  %46 = phi i32 [%37, %$5], [%87, %$13] ; # Chr
  %47 = phi i32 [%37, %$5], [%85, %$13] ; # C
; # (ge0 Chr)
  %48 = icmp sge i32 %46, 0
  br i1 %48, label %$9, label %$10
$9:
  %49 = phi i32 [%46, %$8] ; # Chr
  %50 = phi i32 [%47, %$8] ; # C
; # (if (== Chr (char "~")) (let S (requestSym (val 3 P)) (needNsp 0 ...
; # (== Chr (char "~"))
  %51 = icmp eq i32 %49, 126
  br i1 %51, label %$11, label %$12
$11:
  %52 = phi i32 [%49, %$9] ; # Chr
  %53 = phi i32 [%50, %$9] ; # C
; # (let S (requestSym (val 3 P)) (needNsp 0 S) (set (set $Intern (an...
; # (val 3 P)
  %54 = getelementptr i64, i64* %11, i32 2
  %55 = load i64, i64* %54
; # (requestSym (val 3 P))
  %56 = call i64 @requestSym(i64 %55)
; # (needNsp 0 S)
  %57 = inttoptr i64 %56 to i64*
  %58 = load i64, i64* %57
  %59 = and i64 %58, 15
  %60 = icmp eq i64 %59, 0
  br i1 %60, label %$15, label %$14
$15:
  %61 = inttoptr i64 %58 to i64*
  %62 = load i64, i64* %61
  %63 = icmp eq i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 40) to i64), %62
  br label %$14
$14:
  %64 = phi i1 [0, %$11], [%63, %$15] ; # ->
  br i1 %64, label %$17, label %$16
$16:
  call void @symNspErr(i64 0, i64 %56)
  unreachable
$17:
; # (set (set $Intern (any $Cell)) S)
; # (set $Intern (any $Cell))
; # (any $Cell)
  %65 = ptrtoint i64* bitcast ([2 x i64]* @$Cell to i64*) to i64
  %66 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 0) to i64) to i64*
  store i64 %65, i64* %66
  %67 = inttoptr i64 %65 to i64*
  store i64 %56, i64* %67
; # (set P 4 3 P ZERO)
  store i64 4, i64* %11
  %68 = getelementptr i64, i64* %11, i32 2
  store i64 2, i64* %68
  br label %$13
$12:
  %69 = phi i32 [%49, %$9] ; # Chr
  %70 = phi i32 [%50, %$9] ; # C
; # (? (strchr $Delim Chr))
; # (strchr $Delim Chr)
  %71 = call i8* @strchr(i8* bitcast ([16 x i8]* @$Delim to i8*), i32 %69)
  %72 = icmp ne i8* %71, null
  br i1 %72, label %$10, label %$18
$18:
  %73 = phi i32 [%69, %$12] ; # Chr
  %74 = phi i32 [%70, %$12] ; # C
; # (when (== Chr (char "\\")) (setq Chr (uniChr (call $Get))))
; # (== Chr (char "\\"))
  %75 = icmp eq i32 %73, 92
  br i1 %75, label %$19, label %$20
$19:
  %76 = phi i32 [%73, %$18] ; # Chr
  %77 = phi i32 [%74, %$18] ; # C
; # (call $Get)
  %78 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %79 = call i32 %78()
; # (uniChr (call $Get))
  %80 = call i32 @uniChr(i32 %79)
  br label %$20
$20:
  %81 = phi i32 [%73, %$18], [%80, %$19] ; # Chr
  %82 = phi i32 [%74, %$18], [%77, %$19] ; # C
; # (i8 Chr)
  %83 = trunc i32 %81 to i8
; # (byteSym (i8 Chr) P)
  call void @byteSym(i8 %83, i64* %11)
  br label %$13
$13:
  %84 = phi i32 [%52, %$17], [%81, %$20] ; # Chr
  %85 = phi i32 [%53, %$17], [%82, %$20] ; # C
; # (call $Get)
  %86 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %87 = call i32 %86()
  br label %$8
$10:
  %88 = phi i32 [%46, %$8], [%69, %$12] ; # Chr
  %89 = phi i32 [%47, %$8], [%70, %$12] ; # C
; # (prog1 (let (Nm (val 3 P) L (val $Intern)) (cond ((== Nm ZERO) (b...
; # (let (Nm (val 3 P) L (val $Intern)) (cond ((== Nm ZERO) (badInput...
; # (val 3 P)
  %90 = getelementptr i64, i64* %11, i32 2
  %91 = load i64, i64* %90
; # (val $Intern)
  %92 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 0) to i64) to i64*
  %93 = load i64, i64* %92
; # (cond ((== Nm ZERO) (badInput)) ((== L (any $Cell)) (intern 0 $Ni...
; # (== Nm ZERO)
  %94 = icmp eq i64 %91, 2
  br i1 %94, label %$23, label %$22
$23:
  %95 = phi i32 [%88, %$10] ; # Chr
  %96 = phi i32 [%89, %$10] ; # C
; # (badInput)
  call void @badInput()
  unreachable
$22:
  %97 = phi i32 [%88, %$10] ; # Chr
  %98 = phi i32 [%89, %$10] ; # C
; # (any $Cell)
  %99 = ptrtoint i64* bitcast ([2 x i64]* @$Cell to i64*) to i64
; # (== L (any $Cell))
  %100 = icmp eq i64 %93, %99
  br i1 %100, label %$25, label %$24
$25:
  %101 = phi i32 [%97, %$22] ; # Chr
  %102 = phi i32 [%98, %$22] ; # C
; # (car @)
  %103 = inttoptr i64 %93 to i64*
  %104 = load i64, i64* %103
; # (cdar (car @))
  %105 = inttoptr i64 %104 to i64*
  %106 = load i64, i64* %105
  %107 = inttoptr i64 %106 to i64*
  %108 = getelementptr i64, i64* %107, i32 1
  %109 = load i64, i64* %108
; # (intern 0 $Nil Nm (cdar (car @)) $Nil NO)
  %110 = call i64 @intern(i64 0, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64 %91, i64 %109, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i1 0)
  br label %$21
$24:
  %111 = phi i32 [%97, %$22] ; # Chr
  %112 = phi i32 [%98, %$22] ; # C
; # (val $Scl)
  %113 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 552) to i64) to i64*
  %114 = load i64, i64* %113
; # (int (val $Scl))
  %115 = lshr i64 %114, 4
; # (symToNum Nm (int (val $Scl)) (char ".") 0)
  %116 = call i64 @symToNum(i64 %91, i64 %115, i8 46, i8 0)
  %117 = icmp ne i64 %116, 0
  br i1 %117, label %$27, label %$26
$27:
  %118 = phi i32 [%111, %$24] ; # Chr
  %119 = phi i32 [%112, %$24] ; # C
  br label %$21
$26:
  %120 = phi i32 [%111, %$24] ; # Chr
  %121 = phi i32 [%112, %$24] ; # C
; # (anonymous Nm)
  %122 = call i64 @anonymous(i64 %91)
  %123 = icmp ne i64 %122, 0
  br i1 %123, label %$29, label %$28
$29:
  %124 = phi i32 [%120, %$26] ; # Chr
  %125 = phi i32 [%121, %$26] ; # C
  br label %$21
$28:
  %126 = phi i32 [%120, %$26] ; # Chr
  %127 = phi i32 [%121, %$26] ; # C
; # (and (== (car L) $priv) (nil? (cdr L)))
; # (car L)
  %128 = inttoptr i64 %93 to i64*
  %129 = load i64, i64* %128
; # (== (car L) $priv)
  %130 = icmp eq i64 %129, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 152) to i64)
  br i1 %130, label %$31, label %$30
$31:
  %131 = phi i32 [%126, %$28] ; # Chr
  %132 = phi i32 [%127, %$28] ; # C
; # (cdr L)
  %133 = inttoptr i64 %93 to i64*
  %134 = getelementptr i64, i64* %133, i32 1
  %135 = load i64, i64* %134
; # (nil? (cdr L))
  %136 = icmp eq i64 %135, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$30
$30:
  %137 = phi i32 [%126, %$28], [%131, %$31] ; # Chr
  %138 = phi i32 [%127, %$28], [%132, %$31] ; # C
  %139 = phi i1 [0, %$28], [%136, %$31] ; # ->
  br i1 %139, label %$33, label %$32
$33:
  %140 = phi i32 [%137, %$30] ; # Chr
  %141 = phi i32 [%138, %$30] ; # C
; # (consSym Nm $Nil)
  %142 = call i64 @consSym(i64 %91, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (intern (consSym Nm $Nil) 0 Nm $PrivT $Nil YES)
  %143 = call i64 @intern(i64 %142, i64 0, i64 %91, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 112) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i1 1)
  br label %$21
$32:
  %144 = phi i32 [%137, %$30] ; # Chr
  %145 = phi i32 [%138, %$30] ; # C
; # (requestSym Nm)
  %146 = call i64 @requestSym(i64 %91)
  br label %$21
$21:
  %147 = phi i32 [%101, %$25], [%118, %$27], [%124, %$29], [%140, %$33], [%144, %$32] ; # Chr
  %148 = phi i32 [%102, %$25], [%119, %$27], [%125, %$29], [%141, %$33], [%145, %$32] ; # C
  %149 = phi i64 [%110, %$25], [%116, %$27], [%122, %$29], [%143, %$33], [%146, %$32] ; # ->
; # (set $Intern Int)
  %150 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 0) to i64) to i64*
  store i64 %2, i64* %150
; # (drop *Safe)
  %151 = inttoptr i64 %6 to i64*
  %152 = getelementptr i64, i64* %151, i32 1
  %153 = load i64, i64* %152
  %154 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %153, i64* %154
  ret i64 %149
}

define void @rdl(i64, i64) align 8 {
$1:
; # (loop (? (== (skip) (char ")")) (call $Get)) (? (== @ (char "]"))...
  br label %$2
$2:
  %2 = phi i64 [%1, %$1], [%105, %$7] ; # P
; # (? (== (skip) (char ")")) (call $Get))
; # (skip)
  %3 = call i32 @skip()
; # (== (skip) (char ")"))
  %4 = icmp eq i32 %3, 41
  br i1 %4, label %$5, label %$3
$5:
  %5 = phi i64 [%2, %$2] ; # P
; # (call $Get)
  %6 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %7 = call i32 %6()
  br label %$4
$3:
  %8 = phi i64 [%2, %$2] ; # P
; # (? (== @ (char "]")))
; # (== @ (char "]"))
  %9 = icmp eq i32 %3, 93
  br i1 %9, label %$4, label %$6
$6:
  %10 = phi i64 [%8, %$3] ; # P
; # (cond ((== @ (char ".")) (? (strchr $Delim (call $Get)) (setq P (...
; # (== @ (char "."))
  %11 = icmp eq i32 %3, 46
  br i1 %11, label %$9, label %$8
$9:
  %12 = phi i64 [%10, %$6] ; # P
; # (? (strchr $Delim (call $Get)) (setq P (set 2 P (if (or (== (skip...
; # (call $Get)
  %13 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %14 = call i32 %13()
; # (strchr $Delim (call $Get))
  %15 = call i8* @strchr(i8* bitcast ([16 x i8]* @$Delim to i8*), i32 %14)
  %16 = icmp ne i8* %15, null
  br i1 %16, label %$11, label %$10
$11:
  %17 = phi i64 [%12, %$9] ; # P
; # (set 2 P (if (or (== (skip) (char ")")) (== @ (char "]"))) R (rea...
; # (if (or (== (skip) (char ")")) (== @ (char "]"))) R (read0 NO))
; # (or (== (skip) (char ")")) (== @ (char "]")))
; # (skip)
  %18 = call i32 @skip()
; # (== (skip) (char ")"))
  %19 = icmp eq i32 %18, 41
  br i1 %19, label %$12, label %$13
$13:
  %20 = phi i64 [%17, %$11] ; # P
; # (== @ (char "]"))
  %21 = icmp eq i32 %18, 93
  br label %$12
$12:
  %22 = phi i64 [%17, %$11], [%20, %$13] ; # P
  %23 = phi i1 [1, %$11], [%21, %$13] ; # ->
  br i1 %23, label %$14, label %$15
$14:
  %24 = phi i64 [%22, %$12] ; # P
  br label %$16
$15:
  %25 = phi i64 [%22, %$12] ; # P
; # (read0 NO)
  %26 = call i64 @read0(i1 0)
  br label %$16
$16:
  %27 = phi i64 [%24, %$14], [%25, %$15] ; # P
  %28 = phi i64 [%0, %$14], [%26, %$15] ; # ->
  %29 = inttoptr i64 %17 to i64*
  %30 = getelementptr i64, i64* %29, i32 1
  store i64 %28, i64* %30
; # (cond ((== (skip) (char ")")) (call $Get)) ((<> (val $Chr) (char ...
; # (skip)
  %31 = call i32 @skip()
; # (== (skip) (char ")"))
  %32 = icmp eq i32 %31, 41
  br i1 %32, label %$19, label %$18
$19:
  %33 = phi i64 [%28, %$16] ; # P
; # (call $Get)
  %34 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %35 = call i32 %34()
  br label %$17
$18:
  %36 = phi i64 [%28, %$16] ; # P
; # (val $Chr)
  %37 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
; # (<> (val $Chr) (char "]"))
  %38 = icmp ne i32 %37, 93
  br i1 %38, label %$21, label %$20
$21:
  %39 = phi i64 [%36, %$18] ; # P
; # (err 0 P ($ "Bad dotted pair") null)
  call void @err(i64 0, i64 %39, i8* bitcast ([16 x i8]* @$44 to i8*), i8* null)
  unreachable
$20:
  %40 = phi i64 [%36, %$18] ; # P
  br label %$17
$17:
  %41 = phi i64 [%33, %$19], [%40, %$20] ; # P
  %42 = phi i32 [%35, %$19], [0, %$20] ; # ->
  br label %$4
$10:
  %43 = phi i64 [%12, %$9] ; # P
; # (set 2 P (cons (rdAtom (char ".")) $Nil))
; # (rdAtom (char "."))
  %44 = call i64 @rdAtom(i32 46)
; # (cons (rdAtom (char ".")) $Nil)
  %45 = call i64 @cons(i64 %44, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %46 = inttoptr i64 %43 to i64*
  %47 = getelementptr i64, i64* %46, i32 1
  store i64 %45, i64* %47
  br label %$7
$8:
  %48 = phi i64 [%10, %$6] ; # P
; # (== @ (char "~"))
  %49 = icmp eq i32 %3, 126
  br i1 %49, label %$23, label %$22
$23:
  %50 = phi i64 [%48, %$8] ; # P
; # (call $Get)
  %51 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %52 = call i32 %51()
; # (let (X (save (read0 NO)) R (eval X)) (cond ((nil? R)) ((atom R) ...
; # (read0 NO)
  %53 = call i64 @read0(i1 0)
; # (save (read0 NO))
  %54 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %55 = load i64, i64* %54
  %56 = alloca i64, i64 2, align 16
  %57 = ptrtoint i64* %56 to i64
  %58 = inttoptr i64 %57 to i64*
  store i64 %53, i64* %58
  %59 = add i64 %57, 8
  %60 = inttoptr i64 %59 to i64*
  store i64 %55, i64* %60
  %61 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %57, i64* %61
; # (eval X)
  %62 = and i64 %53, 6
  %63 = icmp ne i64 %62, 0
  br i1 %63, label %$26, label %$25
$26:
  br label %$24
$25:
  %64 = and i64 %53, 8
  %65 = icmp ne i64 %64, 0
  br i1 %65, label %$28, label %$27
$28:
  %66 = inttoptr i64 %53 to i64*
  %67 = load i64, i64* %66
  br label %$24
$27:
  %68 = call i64 @evList(i64 %53)
  br label %$24
$24:
  %69 = phi i64 [%53, %$26], [%67, %$28], [%68, %$27] ; # ->
; # (cond ((nil? R)) ((atom R) (set 2 P (cons R $Nil)) (shift P)) (T ...
; # (nil? R)
  %70 = icmp eq i64 %69, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %70, label %$29, label %$30
$30:
  %71 = phi i64 [%50, %$24] ; # P
; # (atom R)
  %72 = and i64 %69, 15
  %73 = icmp ne i64 %72, 0
  br i1 %73, label %$32, label %$31
$32:
  %74 = phi i64 [%71, %$30] ; # P
; # (set 2 P (cons R $Nil))
; # (cons R $Nil)
  %75 = call i64 @cons(i64 %69, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %76 = inttoptr i64 %74 to i64*
  %77 = getelementptr i64, i64* %76, i32 1
  store i64 %75, i64* %77
; # (shift P)
  %78 = inttoptr i64 %74 to i64*
  %79 = getelementptr i64, i64* %78, i32 1
  %80 = load i64, i64* %79
  br label %$29
$31:
  %81 = phi i64 [%71, %$30] ; # P
; # (set 2 P R)
  %82 = inttoptr i64 %81 to i64*
  %83 = getelementptr i64, i64* %82, i32 1
  store i64 %69, i64* %83
; # (while (pair (cdr P)) (shift P))
  br label %$33
$33:
  %84 = phi i64 [%81, %$31], [%93, %$34] ; # P
; # (cdr P)
  %85 = inttoptr i64 %84 to i64*
  %86 = getelementptr i64, i64* %85, i32 1
  %87 = load i64, i64* %86
; # (pair (cdr P))
  %88 = and i64 %87, 15
  %89 = icmp eq i64 %88, 0
  br i1 %89, label %$34, label %$35
$34:
  %90 = phi i64 [%84, %$33] ; # P
; # (shift P)
  %91 = inttoptr i64 %90 to i64*
  %92 = getelementptr i64, i64* %91, i32 1
  %93 = load i64, i64* %92
  br label %$33
$35:
  %94 = phi i64 [%84, %$33] ; # P
  br label %$29
$29:
  %95 = phi i64 [%50, %$24], [%80, %$32], [%94, %$35] ; # P
; # (drop *Safe)
  %96 = inttoptr i64 %57 to i64*
  %97 = getelementptr i64, i64* %96, i32 1
  %98 = load i64, i64* %97
  %99 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %98, i64* %99
  br label %$7
$22:
  %100 = phi i64 [%48, %$8] ; # P
; # (set 2 P (cons (read0 NO) $Nil))
; # (read0 NO)
  %101 = call i64 @read0(i1 0)
; # (cons (read0 NO) $Nil)
  %102 = call i64 @cons(i64 %101, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %103 = inttoptr i64 %100 to i64*
  %104 = getelementptr i64, i64* %103, i32 1
  store i64 %102, i64* %104
  br label %$7
$7:
  %105 = phi i64 [%45, %$10], [%95, %$29], [%102, %$22] ; # P
  %106 = phi i64 [%45, %$10], [%95, %$29], [%102, %$22] ; # ->
  br label %$2
$4:
  %107 = phi i64 [%5, %$5], [%8, %$3], [%41, %$17] ; # P
  ret void
}

define i64 @rdList() align 8 {
$1:
; # (stkChk 0)
  %0 = load i8*, i8** @$StkLimit
  %1 = call i8* @llvm.stacksave()
  %2 = icmp ugt i8* %0, %1
  br i1 %2, label %$2, label %$3
$2:
  call void @stkErr(i64 0)
  unreachable
$3:
; # (call $Get)
  %3 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %4 = call i32 %3()
; # (save -ZERO)
  %5 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %6 = load i64, i64* %5
  %7 = alloca i64, i64 2, align 16
  %8 = ptrtoint i64* %7 to i64
  %9 = inttoptr i64 %8 to i64*
  store i64 10, i64* %9
  %10 = add i64 %8, 8
  %11 = inttoptr i64 %10 to i64*
  store i64 %6, i64* %11
  %12 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %8, i64* %12
; # (loop (? (== (skip) (char ")")) (call $Get) $Nil) (? (== @ (char ...
  br label %$4
$4:
; # (? (== (skip) (char ")")) (call $Get) $Nil)
; # (skip)
  %13 = call i32 @skip()
; # (== (skip) (char ")"))
  %14 = icmp eq i32 %13, 41
  br i1 %14, label %$7, label %$5
$7:
; # (call $Get)
  %15 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %16 = call i32 %15()
  br label %$6
$5:
; # (? (== @ (char "]")) $Nil)
; # (== @ (char "]"))
  %17 = icmp eq i32 %13, 93
  br i1 %17, label %$9, label %$8
$9:
  br label %$6
$8:
; # (? (<> @ (char "~")) (let R (safe (cons (read0 NO) $Nil)) (rdl R ...
; # (<> @ (char "~"))
  %18 = icmp ne i32 %13, 126
  br i1 %18, label %$11, label %$10
$11:
; # (let R (safe (cons (read0 NO) $Nil)) (rdl R R) R)
; # (read0 NO)
  %19 = call i64 @read0(i1 0)
; # (cons (read0 NO) $Nil)
  %20 = call i64 @cons(i64 %19, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (safe (cons (read0 NO) $Nil))
  %21 = inttoptr i64 %8 to i64*
  store i64 %20, i64* %21
; # (rdl R R)
  call void @rdl(i64 %20, i64 %20)
  br label %$6
$10:
; # (call $Get)
  %22 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %23 = call i32 %22()
; # (let (X (safe (read0 NO)) R (eval X)) (? (not (nil? R)) (if (atom...
; # (read0 NO)
  %24 = call i64 @read0(i1 0)
; # (safe (read0 NO))
  %25 = inttoptr i64 %8 to i64*
  store i64 %24, i64* %25
; # (eval X)
  %26 = and i64 %24, 6
  %27 = icmp ne i64 %26, 0
  br i1 %27, label %$14, label %$13
$14:
  br label %$12
$13:
  %28 = and i64 %24, 8
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %$16, label %$15
$16:
  %30 = inttoptr i64 %24 to i64*
  %31 = load i64, i64* %30
  br label %$12
$15:
  %32 = call i64 @evList(i64 %24)
  br label %$12
$12:
  %33 = phi i64 [%24, %$14], [%31, %$16], [%32, %$15] ; # ->
; # (? (not (nil? R)) (if (atom (safe R)) (rdl (safe (setq R (cons R ...
; # (nil? R)
  %34 = icmp eq i64 %33, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
; # (not (nil? R))
  %35 = icmp eq i1 %34, 0
  br i1 %35, label %$18, label %$17
$18:
  %36 = phi i64 [%33, %$12] ; # R
; # (if (atom (safe R)) (rdl (safe (setq R (cons R $Nil))) R) (let L ...
; # (safe R)
  %37 = inttoptr i64 %8 to i64*
  store i64 %36, i64* %37
; # (atom (safe R))
  %38 = and i64 %36, 15
  %39 = icmp ne i64 %38, 0
  br i1 %39, label %$19, label %$20
$19:
  %40 = phi i64 [%36, %$18] ; # R
; # (cons R $Nil)
  %41 = call i64 @cons(i64 %40, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (safe (setq R (cons R $Nil)))
  %42 = inttoptr i64 %8 to i64*
  store i64 %41, i64* %42
; # (rdl (safe (setq R (cons R $Nil))) R)
  call void @rdl(i64 %41, i64 %41)
  br label %$21
$20:
  %43 = phi i64 [%36, %$18] ; # R
; # (let L R (while (pair (cdr L)) (setq L @)) (rdl R L))
; # (while (pair (cdr L)) (setq L @))
  br label %$22
$22:
  %44 = phi i64 [%43, %$20], [%51, %$23] ; # R
  %45 = phi i64 [%43, %$20], [%48, %$23] ; # L
; # (cdr L)
  %46 = inttoptr i64 %45 to i64*
  %47 = getelementptr i64, i64* %46, i32 1
  %48 = load i64, i64* %47
; # (pair (cdr L))
  %49 = and i64 %48, 15
  %50 = icmp eq i64 %49, 0
  br i1 %50, label %$23, label %$24
$23:
  %51 = phi i64 [%44, %$22] ; # R
  %52 = phi i64 [%45, %$22] ; # L
  br label %$22
$24:
  %53 = phi i64 [%44, %$22] ; # R
  %54 = phi i64 [%45, %$22] ; # L
; # (rdl R L)
  call void @rdl(i64 %53, i64 %54)
  br label %$21
$21:
  %55 = phi i64 [%41, %$19], [%53, %$24] ; # R
  br label %$6
$17:
  %56 = phi i64 [%33, %$12] ; # R
  br label %$4
$6:
  %57 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$9], [%20, %$11], [%55, %$21] ; # ->
; # (drop *Safe)
  %58 = inttoptr i64 %8 to i64*
  %59 = getelementptr i64, i64* %58, i32 1
  %60 = load i64, i64* %59
  %61 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %60, i64* %61
  ret i64 %57
}

define i64 @read0(i1) align 8 {
$1:
; # (let C (skip) (when Top (let In: (inFile (val $InFile)) (In: src ...
; # (skip)
  %1 = call i32 @skip()
; # (when Top (let In: (inFile (val $InFile)) (In: src (In: line))))
  br i1 %0, label %$2, label %$3
$2:
  %2 = phi i32 [%1, %$1] ; # C
; # (let In: (inFile (val $InFile)) (In: src (In: line)))
; # (val $InFile)
  %3 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 72) to i8**)
; # (In: src (In: line))
  %4 = getelementptr i8, i8* %3, i32 20
  %5 = bitcast i8* %4 to i32*
  %6 = getelementptr i8, i8* %3, i32 16
  %7 = bitcast i8* %6 to i32*
  %8 = load i32, i32* %7
  store i32 %8, i32* %5
  br label %$3
$3:
  %9 = phi i32 [%1, %$1], [%2, %$2] ; # C
; # (cond ((lt0 C) (unless Top (eofErr)) $Nil) ((== C (char "(")) (pr...
; # (lt0 C)
  %10 = icmp slt i32 %9, 0
  br i1 %10, label %$6, label %$5
$6:
  %11 = phi i32 [%9, %$3] ; # C
; # (unless Top (eofErr))
  br i1 %0, label %$8, label %$7
$7:
  %12 = phi i32 [%11, %$6] ; # C
; # (eofErr)
  call void @eofErr()
  unreachable
$8:
  %13 = phi i32 [%11, %$6] ; # C
  br label %$4
$5:
  %14 = phi i32 [%9, %$3] ; # C
; # (== C (char "("))
  %15 = icmp eq i32 %14, 40
  br i1 %15, label %$10, label %$9
$10:
  %16 = phi i32 [%14, %$5] ; # C
; # (prog1 (rdList) (and Top (== (val $Chr) (char "]")) (call $Get)))...
; # (rdList)
  %17 = call i64 @rdList()
; # (and Top (== (val $Chr) (char "]")) (call $Get))
  br i1 %0, label %$12, label %$11
$12:
  %18 = phi i32 [%16, %$10] ; # C
; # (val $Chr)
  %19 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
; # (== (val $Chr) (char "]"))
  %20 = icmp eq i32 %19, 93
  br i1 %20, label %$13, label %$11
$13:
  %21 = phi i32 [%18, %$12] ; # C
; # (call $Get)
  %22 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %23 = call i32 %22()
  %24 = icmp ne i32 %23, 0
  br label %$11
$11:
  %25 = phi i32 [%16, %$10], [%18, %$12], [%21, %$13] ; # C
  %26 = phi i1 [0, %$10], [0, %$12], [%24, %$13] ; # ->
  br label %$4
$9:
  %27 = phi i32 [%14, %$5] ; # C
; # (== C (char "["))
  %28 = icmp eq i32 %27, 91
  br i1 %28, label %$15, label %$14
$15:
  %29 = phi i32 [%27, %$9] ; # C
; # (let X (rdList) (unless (== (val $Chr) (char "]")) (err 0 X ($ "S...
; # (rdList)
  %30 = call i64 @rdList()
; # (unless (== (val $Chr) (char "]")) (err 0 X ($ "Super parentheses...
; # (val $Chr)
  %31 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
; # (== (val $Chr) (char "]"))
  %32 = icmp eq i32 %31, 93
  br i1 %32, label %$17, label %$16
$16:
  %33 = phi i32 [%29, %$15] ; # C
; # (err 0 X ($ "Super parentheses mismatch") null)
  call void @err(i64 0, i64 %30, i8* bitcast ([27 x i8]* @$45 to i8*), i8* null)
  unreachable
$17:
  %34 = phi i32 [%29, %$15] ; # C
; # (call $Get)
  %35 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %36 = call i32 %35()
  br label %$4
$14:
  %37 = phi i32 [%27, %$9] ; # C
; # (== C (char "'"))
  %38 = icmp eq i32 %37, 39
  br i1 %38, label %$19, label %$18
$19:
  %39 = phi i32 [%37, %$14] ; # C
; # (call $Get)
  %40 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %41 = call i32 %40()
; # (read0 Top)
  %42 = call i64 @read0(i1 %0)
; # (cons $Quote (read0 Top))
  %43 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 264) to i64), i64 %42)
  br label %$4
$18:
  %44 = phi i32 [%37, %$14] ; # C
; # (== C (char ","))
  %45 = icmp eq i32 %44, 44
  br i1 %45, label %$21, label %$20
$21:
  %46 = phi i32 [%44, %$18] ; # C
; # (call $Get)
  %47 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %48 = call i32 %47()
; # (let (Tr1 (save (val $Transient)) Tr2 (save (val 2 $Transient))) ...
; # (val $Transient)
  %49 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 8) to i64) to i64*
  %50 = load i64, i64* %49
; # (save (val $Transient))
  %51 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %52 = load i64, i64* %51
  %53 = alloca i64, i64 2, align 16
  %54 = ptrtoint i64* %53 to i64
  %55 = inttoptr i64 %54 to i64*
  store i64 %50, i64* %55
  %56 = add i64 %54, 8
  %57 = inttoptr i64 %56 to i64*
  store i64 %52, i64* %57
  %58 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %54, i64* %58
; # (val 2 $Transient)
  %59 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 8) to i64) to i64*
  %60 = getelementptr i64, i64* %59, i32 1
  %61 = load i64, i64* %60
; # (save (val 2 $Transient))
  %62 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %63 = load i64, i64* %62
  %64 = alloca i64, i64 2, align 16
  %65 = ptrtoint i64* %64 to i64
  %66 = inttoptr i64 %65 to i64*
  store i64 %61, i64* %66
  %67 = add i64 %65, 8
  %68 = inttoptr i64 %67 to i64*
  store i64 %63, i64* %68
  %69 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %65, i64* %69
; # (set $Transient (set 2 $Transient $Nil))
; # (set 2 $Transient $Nil)
  %70 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 8) to i64) to i64*
  %71 = getelementptr i64, i64* %70, i32 1
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %71
  %72 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 8) to i64) to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %72
; # (prog1 (let X (read0 Top) (if (t? (val $Uni)) X (save X (if (pair...
; # (let X (read0 Top) (if (t? (val $Uni)) X (save X (if (pair (idxPu...
; # (read0 Top)
  %73 = call i64 @read0(i1 %0)
; # (if (t? (val $Uni)) X (save X (if (pair (idxPut $Uni X $T)) (car ...
; # (val $Uni)
  %74 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 776) to i64) to i64*
  %75 = load i64, i64* %74
; # (t? (val $Uni))
  %76 = icmp eq i64 %75, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %76, label %$22, label %$23
$22:
  %77 = phi i32 [%46, %$21] ; # C
  br label %$24
$23:
  %78 = phi i32 [%46, %$21] ; # C
; # (save X (if (pair (idxPut $Uni X $T)) (car @) X))
  %79 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %80 = load i64, i64* %79
  %81 = alloca i64, i64 2, align 16
  %82 = ptrtoint i64* %81 to i64
  %83 = inttoptr i64 %82 to i64*
  store i64 %73, i64* %83
  %84 = add i64 %82, 8
  %85 = inttoptr i64 %84 to i64*
  store i64 %80, i64* %85
  %86 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %82, i64* %86
; # (if (pair (idxPut $Uni X $T)) (car @) X)
; # (idxPut $Uni X $T)
  %87 = call i64 @idxPut(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 776) to i64), i64 %73, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64))
; # (pair (idxPut $Uni X $T))
  %88 = and i64 %87, 15
  %89 = icmp eq i64 %88, 0
  br i1 %89, label %$25, label %$26
$25:
  %90 = phi i32 [%78, %$23] ; # C
; # (car @)
  %91 = inttoptr i64 %87 to i64*
  %92 = load i64, i64* %91
  br label %$27
$26:
  %93 = phi i32 [%78, %$23] ; # C
  br label %$27
$27:
  %94 = phi i32 [%90, %$25], [%93, %$26] ; # C
  %95 = phi i64 [%92, %$25], [%73, %$26] ; # ->
; # drop
  %96 = inttoptr i64 %82 to i64*
  %97 = getelementptr i64, i64* %96, i32 1
  %98 = load i64, i64* %97
  %99 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %98, i64* %99
  br label %$24
$24:
  %100 = phi i32 [%77, %$22], [%94, %$27] ; # C
  %101 = phi i64 [%73, %$22], [%95, %$27] ; # ->
; # (set 2 $Transient Tr2)
  %102 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 8) to i64) to i64*
  %103 = getelementptr i64, i64* %102, i32 1
  store i64 %61, i64* %103
; # (set $Transient Tr1)
  %104 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 8) to i64) to i64*
  store i64 %50, i64* %104
; # (drop *Safe)
  %105 = inttoptr i64 %54 to i64*
  %106 = getelementptr i64, i64* %105, i32 1
  %107 = load i64, i64* %106
  %108 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %107, i64* %108
  br label %$4
$20:
  %109 = phi i32 [%44, %$18] ; # C
; # (== C (char "`"))
  %110 = icmp eq i32 %109, 96
  br i1 %110, label %$29, label %$28
$29:
  %111 = phi i32 [%109, %$20] ; # C
; # (call $Get)
  %112 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %113 = call i32 %112()
; # (let E (read0 Top) (save E (eval E)))
; # (read0 Top)
  %114 = call i64 @read0(i1 %0)
; # (save E (eval E))
  %115 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %116 = load i64, i64* %115
  %117 = alloca i64, i64 2, align 16
  %118 = ptrtoint i64* %117 to i64
  %119 = inttoptr i64 %118 to i64*
  store i64 %114, i64* %119
  %120 = add i64 %118, 8
  %121 = inttoptr i64 %120 to i64*
  store i64 %116, i64* %121
  %122 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %118, i64* %122
; # (eval E)
  %123 = and i64 %114, 6
  %124 = icmp ne i64 %123, 0
  br i1 %124, label %$32, label %$31
$32:
  br label %$30
$31:
  %125 = and i64 %114, 8
  %126 = icmp ne i64 %125, 0
  br i1 %126, label %$34, label %$33
$34:
  %127 = inttoptr i64 %114 to i64*
  %128 = load i64, i64* %127
  br label %$30
$33:
  %129 = call i64 @evList(i64 %114)
  br label %$30
$30:
  %130 = phi i64 [%114, %$32], [%128, %$34], [%129, %$33] ; # ->
; # drop
  %131 = inttoptr i64 %118 to i64*
  %132 = getelementptr i64, i64* %131, i32 1
  %133 = load i64, i64* %132
  %134 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %133, i64* %134
  br label %$4
$28:
  %135 = phi i32 [%109, %$20] ; # C
; # (== C (char "\""))
  %136 = icmp eq i32 %135, 34
  br i1 %136, label %$36, label %$35
$36:
  %137 = phi i32 [%135, %$28] ; # C
; # (if (== (setq C (call $Get)) (char "\"")) (prog (call $Get) $Nil)...
; # (call $Get)
  %138 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %139 = call i32 %138()
; # (== (setq C (call $Get)) (char "\""))
  %140 = icmp eq i32 %139, 34
  br i1 %140, label %$37, label %$38
$37:
  %141 = phi i32 [%139, %$36] ; # C
; # (call $Get)
  %142 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %143 = call i32 %142()
  br label %$39
$38:
  %144 = phi i32 [%139, %$36] ; # C
; # (unless (testEsc C) (eofErr))
; # (testEsc C)
  %145 = call i1 @testEsc(i32 %144)
  br i1 %145, label %$41, label %$40
$40:
  %146 = phi i32 [%144, %$38] ; # C
; # (eofErr)
  call void @eofErr()
  unreachable
$41:
  %147 = phi i32 [%144, %$38] ; # C
; # (let (P (push 4 NIL ZERO NIL) Q (link (ofs P 2))) (loop (charSym ...
; # (push 4 NIL ZERO NIL)
  %148 = alloca i64, i64 4, align 16
  store i64 4, i64* %148
  %149 = getelementptr i64, i64* %148, i32 2
  store i64 2, i64* %149
; # (ofs P 2)
  %150 = getelementptr i64, i64* %148, i32 2
; # (link (ofs P 2))
  %151 = ptrtoint i64* %150 to i64
  %152 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %153 = load i64, i64* %152
  %154 = inttoptr i64 %151 to i64*
  %155 = getelementptr i64, i64* %154, i32 1
  store i64 %153, i64* %155
  %156 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %151, i64* %156
; # (loop (charSym (val $Chr) P) (? (== (setq C (call $Get)) (char "\...
  br label %$42
$42:
  %157 = phi i32 [%147, %$41], [%165, %$46] ; # C
; # (val $Chr)
  %158 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
; # (charSym (val $Chr) P)
  call void @charSym(i32 %158, i64* %148)
; # (? (== (setq C (call $Get)) (char "\"")))
; # (call $Get)
  %159 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %160 = call i32 %159()
; # (== (setq C (call $Get)) (char "\""))
  %161 = icmp eq i32 %160, 34
  br i1 %161, label %$44, label %$43
$43:
  %162 = phi i32 [%160, %$42] ; # C
; # (unless (testEsc C) (eofErr))
; # (testEsc C)
  %163 = call i1 @testEsc(i32 %162)
  br i1 %163, label %$46, label %$45
$45:
  %164 = phi i32 [%162, %$43] ; # C
; # (eofErr)
  call void @eofErr()
  unreachable
$46:
  %165 = phi i32 [%162, %$43] ; # C
  br label %$42
$44:
  %166 = phi i32 [%160, %$42] ; # C
  %167 = phi i64 [0, %$42] ; # ->
; # (call $Get)
  %168 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %169 = call i32 %168()
; # (drop Q (intern 0 0 (val Q) $Transient $Nil NO))
; # (val Q)
  %170 = inttoptr i64 %151 to i64*
  %171 = load i64, i64* %170
; # (intern 0 0 (val Q) $Transient $Nil NO)
  %172 = call i64 @intern(i64 0, i64 0, i64 %171, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i1 0)
  %173 = inttoptr i64 %151 to i64*
  %174 = getelementptr i64, i64* %173, i32 1
  %175 = load i64, i64* %174
  %176 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %175, i64* %176
  br label %$39
$39:
  %177 = phi i32 [%141, %$37], [%166, %$44] ; # C
  %178 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$37], [%172, %$44] ; # ->
  br label %$4
$35:
  %179 = phi i32 [%135, %$28] ; # C
; # (== C (char "{"))
  %180 = icmp eq i32 %179, 123
  br i1 %180, label %$48, label %$47
$48:
  %181 = phi i32 [%179, %$35] ; # C
; # (prog1 (if (== (setq C (call $Get)) (char "}")) (consSym ZERO $Ni...
; # (if (== (setq C (call $Get)) (char "}")) (consSym ZERO $Nil) (let...
; # (call $Get)
  %182 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %183 = call i32 %182()
; # (== (setq C (call $Get)) (char "}"))
  %184 = icmp eq i32 %183, 125
  br i1 %184, label %$49, label %$50
$49:
  %185 = phi i32 [%183, %$48] ; # C
; # (consSym ZERO $Nil)
  %186 = call i64 @consSym(i64 2, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  br label %$51
$50:
  %187 = phi i32 [%183, %$48] ; # C
; # (let F (i32 0) (while (>= C (char "@")) (when (> C (char "O")) (b...
; # (i32 0)
; # (while (>= C (char "@")) (when (> C (char "O")) (badInput)) (setq...
  br label %$52
$52:
  %188 = phi i32 [%187, %$50], [%202, %$56] ; # C
  %189 = phi i32 [0, %$50], [%200, %$56] ; # F
; # (>= C (char "@"))
  %190 = icmp sge i32 %188, 64
  br i1 %190, label %$53, label %$54
$53:
  %191 = phi i32 [%188, %$52] ; # C
  %192 = phi i32 [%189, %$52] ; # F
; # (when (> C (char "O")) (badInput))
; # (> C (char "O"))
  %193 = icmp sgt i32 %191, 79
  br i1 %193, label %$55, label %$56
$55:
  %194 = phi i32 [%191, %$53] ; # C
  %195 = phi i32 [%192, %$53] ; # F
; # (badInput)
  call void @badInput()
  unreachable
$56:
  %196 = phi i32 [%191, %$53] ; # C
  %197 = phi i32 [%192, %$53] ; # F
; # (shl F 4)
  %198 = shl i32 %197, 4
; # (- C (char "@"))
  %199 = sub i32 %196, 64
; # (| (shl F 4) (- C (char "@")))
  %200 = or i32 %198, %199
; # (call $Get)
  %201 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %202 = call i32 %201()
  br label %$52
$54:
  %203 = phi i32 [%188, %$52] ; # C
  %204 = phi i32 [%189, %$52] ; # F
; # (let N 0 (loop (unless (and (>= C (char "0")) (>= (char "7") C)) ...
; # (loop (unless (and (>= C (char "0")) (>= (char "7") C)) (badInput...
  br label %$57
$57:
  %205 = phi i32 [%203, %$54], [%230, %$62] ; # C
  %206 = phi i32 [%204, %$54], [%231, %$62] ; # F
  %207 = phi i64 [0, %$54], [%232, %$62] ; # N
; # (unless (and (>= C (char "0")) (>= (char "7") C)) (badInput))
; # (and (>= C (char "0")) (>= (char "7") C))
; # (>= C (char "0"))
  %208 = icmp sge i32 %205, 48
  br i1 %208, label %$59, label %$58
$59:
  %209 = phi i32 [%205, %$57] ; # C
  %210 = phi i32 [%206, %$57] ; # F
  %211 = phi i64 [%207, %$57] ; # N
; # (>= (char "7") C)
  %212 = icmp sge i32 55, %209
  br label %$58
$58:
  %213 = phi i32 [%205, %$57], [%209, %$59] ; # C
  %214 = phi i32 [%206, %$57], [%210, %$59] ; # F
  %215 = phi i64 [%207, %$57], [%211, %$59] ; # N
  %216 = phi i1 [0, %$57], [%212, %$59] ; # ->
  br i1 %216, label %$61, label %$60
$60:
  %217 = phi i32 [%213, %$58] ; # C
  %218 = phi i32 [%214, %$58] ; # F
  %219 = phi i64 [%215, %$58] ; # N
; # (badInput)
  call void @badInput()
  unreachable
$61:
  %220 = phi i32 [%213, %$58] ; # C
  %221 = phi i32 [%214, %$58] ; # F
  %222 = phi i64 [%215, %$58] ; # N
; # (shl N 3)
  %223 = shl i64 %222, 3
; # (- C (char "0"))
  %224 = sub i32 %220, 48
; # (i64 (- C (char "0")))
  %225 = sext i32 %224 to i64
; # (| (shl N 3) (i64 (- C (char "0"))))
  %226 = or i64 %223, %225
; # (? (== (setq C (call $Get)) (char "}")))
; # (call $Get)
  %227 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %228 = call i32 %227()
; # (== (setq C (call $Get)) (char "}"))
  %229 = icmp eq i32 %228, 125
  br i1 %229, label %$63, label %$62
$62:
  %230 = phi i32 [%228, %$61] ; # C
  %231 = phi i32 [%221, %$61] ; # F
  %232 = phi i64 [%226, %$61] ; # N
  br label %$57
$63:
  %233 = phi i32 [%228, %$61] ; # C
  %234 = phi i32 [%221, %$61] ; # F
  %235 = phi i64 [%226, %$61] ; # N
  %236 = phi i64 [0, %$61] ; # ->
; # (extNm F N)
  %237 = call i64 @extNm(i32 %234, i64 %235)
; # (extern (extNm F N))
  %238 = call i64 @extern(i64 %237)
  br label %$51
$51:
  %239 = phi i32 [%185, %$49], [%233, %$63] ; # C
  %240 = phi i64 [%186, %$49], [%238, %$63] ; # ->
; # (call $Get)
  %241 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %242 = call i32 %241()
  br label %$4
$47:
  %243 = phi i32 [%179, %$35] ; # C
; # (or (== C (char ")")) (== C (char "]")) (== C (char "~")))
; # (== C (char ")"))
  %244 = icmp eq i32 %243, 41
  br i1 %244, label %$64, label %$65
$65:
  %245 = phi i32 [%243, %$47] ; # C
; # (== C (char "]"))
  %246 = icmp eq i32 %245, 93
  br i1 %246, label %$64, label %$66
$66:
  %247 = phi i32 [%245, %$65] ; # C
; # (== C (char "~"))
  %248 = icmp eq i32 %247, 126
  br label %$64
$64:
  %249 = phi i32 [%243, %$47], [%245, %$65], [%247, %$66] ; # C
  %250 = phi i1 [1, %$47], [1, %$65], [%248, %$66] ; # ->
  br i1 %250, label %$68, label %$67
$68:
  %251 = phi i32 [%249, %$64] ; # C
; # (badInput)
  call void @badInput()
  unreachable
$67:
  %252 = phi i32 [%249, %$64] ; # C
; # (when (== C (char "\\")) (call $Get))
; # (== C (char "\\"))
  %253 = icmp eq i32 %252, 92
  br i1 %253, label %$69, label %$70
$69:
  %254 = phi i32 [%252, %$67] ; # C
; # (call $Get)
  %255 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %256 = call i32 %255()
  br label %$70
$70:
  %257 = phi i32 [%252, %$67], [%254, %$69] ; # C
; # (val $Chr)
  %258 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
; # (call $Get)
  %259 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %260 = call i32 %259()
; # (rdAtom C)
  %261 = call i64 @rdAtom(i32 %258)
  br label %$4
$4:
  %262 = phi i32 [%13, %$8], [%25, %$11], [%34, %$17], [%39, %$19], [%100, %$24], [%111, %$30], [%177, %$39], [%239, %$51], [%258, %$70] ; # C
  %263 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$8], [%17, %$11], [%30, %$17], [%43, %$19], [%101, %$24], [%130, %$30], [%178, %$39], [%240, %$51], [%261, %$70] ; # ->
  ret i64 %263
}

define i64 @read1(i32) align 8 {
$1:
; # (unless (val $Chr) (call $Get))
; # (val $Chr)
  %1 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
  %2 = icmp ne i32 %1, 0
  br i1 %2, label %$3, label %$2
$2:
; # (call $Get)
  %3 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %4 = call i32 %3()
  br label %$3
$3:
; # (if (== End (val $Chr)) $Nil (read0 YES))
; # (val $Chr)
  %5 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
; # (== End (val $Chr))
  %6 = icmp eq i32 %0, %5
  br i1 %6, label %$4, label %$5
$4:
  br label %$6
$5:
; # (read0 YES)
  %7 = call i64 @read0(i1 1)
  br label %$6
$6:
  %8 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$4], [%7, %$5] ; # ->
  ret i64 %8
}

define i64 @token(i64, i32) align 8 {
$1:
; # (let C (if (val $Chr) @ (call $Get)) (cond ((lt0 (skipc Cmt)) 0) ...
; # (if (val $Chr) @ (call $Get))
; # (val $Chr)
  %2 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
  %3 = icmp ne i32 %2, 0
  br i1 %3, label %$2, label %$3
$2:
  br label %$4
$3:
; # (call $Get)
  %4 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %5 = call i32 %4()
  br label %$4
$4:
  %6 = phi i32 [%2, %$2], [%5, %$3] ; # ->
; # (cond ((lt0 (skipc Cmt)) 0) ((== (setq C @) (char "\"")) (cond ((...
; # (skipc Cmt)
  %7 = call i32 @skipc(i32 %1)
; # (lt0 (skipc Cmt))
  %8 = icmp slt i32 %7, 0
  br i1 %8, label %$7, label %$6
$7:
  %9 = phi i32 [%6, %$4] ; # C
  br label %$5
$6:
  %10 = phi i32 [%6, %$4] ; # C
; # (== (setq C @) (char "\""))
  %11 = icmp eq i32 %7, 34
  br i1 %11, label %$9, label %$8
$9:
  %12 = phi i32 [%7, %$6] ; # C
; # (cond ((== (setq C (call $Get)) (char "\"")) (call $Get) $Nil) ((...
; # (call $Get)
  %13 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %14 = call i32 %13()
; # (== (setq C (call $Get)) (char "\""))
  %15 = icmp eq i32 %14, 34
  br i1 %15, label %$12, label %$11
$12:
  %16 = phi i32 [%14, %$9] ; # C
; # (call $Get)
  %17 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %18 = call i32 %17()
  br label %$10
$11:
  %19 = phi i32 [%14, %$9] ; # C
; # (testEsc C)
  %20 = call i1 @testEsc(i32 %19)
; # (not (testEsc C))
  %21 = icmp eq i1 %20, 0
  br i1 %21, label %$14, label %$13
$14:
  %22 = phi i32 [%19, %$11] ; # C
  br label %$10
$13:
  %23 = phi i32 [%19, %$11] ; # C
; # (let (Y (cons (mkChar (val $Chr)) $Nil) R (save Y)) (loop (? (== ...
; # (val $Chr)
  %24 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
; # (mkChar (val $Chr))
  %25 = call i64 @mkChar(i32 %24)
; # (cons (mkChar (val $Chr)) $Nil)
  %26 = call i64 @cons(i64 %25, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (save Y)
  %27 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %28 = load i64, i64* %27
  %29 = alloca i64, i64 2, align 16
  %30 = ptrtoint i64* %29 to i64
  %31 = inttoptr i64 %30 to i64*
  store i64 %26, i64* %31
  %32 = add i64 %30, 8
  %33 = inttoptr i64 %32 to i64*
  store i64 %28, i64* %33
  %34 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %30, i64* %34
; # (loop (? (== (setq C (call $Get)) (char "\"")) (call $Get)) (? (n...
  br label %$15
$15:
  %35 = phi i32 [%23, %$13], [%48, %$19] ; # C
  %36 = phi i64 [%26, %$13], [%52, %$19] ; # Y
; # (? (== (setq C (call $Get)) (char "\"")) (call $Get))
; # (call $Get)
  %37 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %38 = call i32 %37()
; # (== (setq C (call $Get)) (char "\""))
  %39 = icmp eq i32 %38, 34
  br i1 %39, label %$18, label %$16
$18:
  %40 = phi i32 [%38, %$15] ; # C
  %41 = phi i64 [%36, %$15] ; # Y
; # (call $Get)
  %42 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %43 = call i32 %42()
  br label %$17
$16:
  %44 = phi i32 [%38, %$15] ; # C
  %45 = phi i64 [%36, %$15] ; # Y
; # (? (not (testEsc C)))
; # (testEsc C)
  %46 = call i1 @testEsc(i32 %44)
; # (not (testEsc C))
  %47 = icmp eq i1 %46, 0
  br i1 %47, label %$17, label %$19
$19:
  %48 = phi i32 [%44, %$16] ; # C
  %49 = phi i64 [%45, %$16] ; # Y
; # (set 2 Y (cons (mkChar (val $Chr)) $Nil))
; # (val $Chr)
  %50 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
; # (mkChar (val $Chr))
  %51 = call i64 @mkChar(i32 %50)
; # (cons (mkChar (val $Chr)) $Nil)
  %52 = call i64 @cons(i64 %51, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %53 = inttoptr i64 %49 to i64*
  %54 = getelementptr i64, i64* %53, i32 1
  store i64 %52, i64* %54
  br label %$15
$17:
  %55 = phi i32 [%40, %$18], [%44, %$16] ; # C
  %56 = phi i64 [%41, %$18], [%45, %$16] ; # Y
  %57 = phi i32 [%43, %$18], [0, %$16] ; # ->
; # (drop *Safe)
  %58 = inttoptr i64 %30 to i64*
  %59 = getelementptr i64, i64* %58, i32 1
  %60 = load i64, i64* %59
  %61 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %60, i64* %61
  br label %$10
$10:
  %62 = phi i32 [%16, %$12], [%22, %$14], [%55, %$17] ; # C
  %63 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$12], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$14], [%26, %$17] ; # ->
  br label %$5
$8:
  %64 = phi i32 [%7, %$6] ; # C
; # (and (>= (char "9") C) (>= C (char "0")))
; # (>= (char "9") C)
  %65 = icmp sge i32 57, %64
  br i1 %65, label %$21, label %$20
$21:
  %66 = phi i32 [%64, %$8] ; # C
; # (>= C (char "0"))
  %67 = icmp sge i32 %66, 48
  br label %$20
$20:
  %68 = phi i32 [%64, %$8], [%66, %$21] ; # C
  %69 = phi i1 [0, %$8], [%67, %$21] ; # ->
  br i1 %69, label %$23, label %$22
$23:
  %70 = phi i32 [%68, %$20] ; # C
; # (let P (push 4 NIL ZERO NIL) (link (ofs P 2) T) (loop (byteSym (i...
; # (push 4 NIL ZERO NIL)
  %71 = alloca i64, i64 4, align 16
  store i64 4, i64* %71
  %72 = getelementptr i64, i64* %71, i32 2
  store i64 2, i64* %72
; # (ofs P 2)
  %73 = getelementptr i64, i64* %71, i32 2
; # (link (ofs P 2) T)
  %74 = ptrtoint i64* %73 to i64
  %75 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %76 = load i64, i64* %75
  %77 = inttoptr i64 %74 to i64*
  %78 = getelementptr i64, i64* %77, i32 1
  store i64 %76, i64* %78
  %79 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %74, i64* %79
; # (loop (byteSym (i8 C) P) (? (and (<> (setq C (call $Get)) (char "...
  br label %$24
$24:
  %80 = phi i32 [%70, %$23], [%93, %$29] ; # C
; # (i8 C)
  %81 = trunc i32 %80 to i8
; # (byteSym (i8 C) P)
  call void @byteSym(i8 %81, i64* %71)
; # (? (and (<> (setq C (call $Get)) (char ".")) (or (> (char "0") C)...
; # (and (<> (setq C (call $Get)) (char ".")) (or (> (char "0") C) (>...
; # (call $Get)
  %82 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %83 = call i32 %82()
; # (<> (setq C (call $Get)) (char "."))
  %84 = icmp ne i32 %83, 46
  br i1 %84, label %$26, label %$25
$26:
  %85 = phi i32 [%83, %$24] ; # C
; # (or (> (char "0") C) (> C (char "9")))
; # (> (char "0") C)
  %86 = icmp sgt i32 48, %85
  br i1 %86, label %$27, label %$28
$28:
  %87 = phi i32 [%85, %$26] ; # C
; # (> C (char "9"))
  %88 = icmp sgt i32 %87, 57
  br label %$27
$27:
  %89 = phi i32 [%85, %$26], [%87, %$28] ; # C
  %90 = phi i1 [1, %$26], [%88, %$28] ; # ->
  br label %$25
$25:
  %91 = phi i32 [%83, %$24], [%89, %$27] ; # C
  %92 = phi i1 [0, %$24], [%90, %$27] ; # ->
  br i1 %92, label %$30, label %$29
$29:
  %93 = phi i32 [%91, %$25] ; # C
  br label %$24
$30:
  %94 = phi i32 [%91, %$25] ; # C
  %95 = phi i64 [0, %$25] ; # ->
; # (val 3 P)
  %96 = getelementptr i64, i64* %71, i32 2
  %97 = load i64, i64* %96
; # (val $Scl)
  %98 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 552) to i64) to i64*
  %99 = load i64, i64* %98
; # (int (val $Scl))
  %100 = lshr i64 %99, 4
; # (symToNum (val 3 P) (int (val $Scl)) (char ".") 0)
  %101 = call i64 @symToNum(i64 %97, i64 %100, i8 46, i8 0)
; # (drop *Safe)
  %102 = inttoptr i64 %74 to i64*
  %103 = getelementptr i64, i64* %102, i32 1
  %104 = load i64, i64* %103
  %105 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %104, i64* %105
  br label %$5
$22:
  %106 = phi i32 [%68, %$20] ; # C
; # (let (Nm (xName Set) S (bufString Nm (b8 (bufSize Nm)))) (if (or ...
; # (xName Set)
  %107 = call i64 @xName(i64 %0)
; # (bufSize Nm)
  %108 = call i64 @bufSize(i64 %107)
; # (b8 (bufSize Nm))
  %109 = alloca i8, i64 %108
; # (bufString Nm (b8 (bufSize Nm)))
  %110 = call i8* @bufString(i64 %107, i8* %109)
; # (if (or (== C (char "+")) (== C (char "-")) (noToken C S)) (prog1...
; # (or (== C (char "+")) (== C (char "-")) (noToken C S))
; # (== C (char "+"))
  %111 = icmp eq i32 %106, 43
  br i1 %111, label %$31, label %$32
$32:
  %112 = phi i32 [%106, %$22] ; # C
; # (== C (char "-"))
  %113 = icmp eq i32 %112, 45
  br i1 %113, label %$31, label %$33
$33:
  %114 = phi i32 [%112, %$32] ; # C
; # (noToken C S)
  %115 = icmp eq i32 %114, 92
  br i1 %115, label %$34, label %$35
$35:
  %116 = icmp sge i32 122, %114
  br i1 %116, label %$37, label %$36
$37:
  %117 = icmp sge i32 %114, 97
  br label %$36
$36:
  %118 = phi i1 [0, %$35], [%117, %$37] ; # ->
  br i1 %118, label %$34, label %$38
$38:
  %119 = icmp sge i32 90, %114
  br i1 %119, label %$40, label %$39
$40:
  %120 = icmp sge i32 %114, 65
  br label %$39
$39:
  %121 = phi i1 [0, %$38], [%120, %$40] ; # ->
  br i1 %121, label %$34, label %$41
$41:
  %122 = call i8* @strchr(i8* %110, i32 %114)
  %123 = icmp ne i8* %122, null
  br label %$34
$34:
  %124 = phi i1 [1, %$33], [1, %$36], [1, %$39], [%123, %$41] ; # ->
  %125 = icmp eq i1 %124, 0
  br label %$31
$31:
  %126 = phi i32 [%106, %$22], [%112, %$32], [%114, %$34] ; # C
  %127 = phi i1 [1, %$22], [1, %$32], [%125, %$34] ; # ->
  br i1 %127, label %$42, label %$43
$42:
  %128 = phi i32 [%126, %$31] ; # C
; # (prog1 (mkChar (getChar C)) (call $Get))
; # (getChar C)
  %129 = call i32 @getChar(i32 %128)
; # (mkChar (getChar C))
  %130 = call i64 @mkChar(i32 %129)
; # (call $Get)
  %131 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %132 = call i32 %131()
  br label %$44
$43:
  %133 = phi i32 [%126, %$31] ; # C
; # (when (== C (char "\\")) (call $Get))
; # (== C (char "\\"))
  %134 = icmp eq i32 %133, 92
  br i1 %134, label %$45, label %$46
$45:
  %135 = phi i32 [%133, %$43] ; # C
; # (call $Get)
  %136 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %137 = call i32 %136()
  br label %$46
$46:
  %138 = phi i32 [%133, %$43], [%135, %$45] ; # C
; # (let P (push 4 NIL ZERO NIL) (link (ofs P 2) T) (loop (byteSym (i...
; # (push 4 NIL ZERO NIL)
  %139 = alloca i64, i64 4, align 16
  store i64 4, i64* %139
  %140 = getelementptr i64, i64* %139, i32 2
  store i64 2, i64* %140
; # (ofs P 2)
  %141 = getelementptr i64, i64* %139, i32 2
; # (link (ofs P 2) T)
  %142 = ptrtoint i64* %141 to i64
  %143 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %144 = load i64, i64* %143
  %145 = inttoptr i64 %142 to i64*
  %146 = getelementptr i64, i64* %145, i32 1
  store i64 %144, i64* %146
  %147 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %142, i64* %147
; # (loop (byteSym (i8 C) P) (? (and (noToken (setq C (call $Get)) S)...
  br label %$47
$47:
  %148 = phi i32 [%138, %$46], [%176, %$63] ; # C
; # (i8 C)
  %149 = trunc i32 %148 to i8
; # (byteSym (i8 C) P)
  call void @byteSym(i8 %149, i64* %139)
; # (? (and (noToken (setq C (call $Get)) S) (or (> (char "0") C) (> ...
; # (and (noToken (setq C (call $Get)) S) (or (> (char "0") C) (> C (...
; # (call $Get)
  %150 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %151 = call i32 %150()
; # (noToken (setq C (call $Get)) S)
  %152 = icmp eq i32 %151, 92
  br i1 %152, label %$49, label %$50
$50:
  %153 = icmp sge i32 122, %151
  br i1 %153, label %$52, label %$51
$52:
  %154 = icmp sge i32 %151, 97
  br label %$51
$51:
  %155 = phi i1 [0, %$50], [%154, %$52] ; # ->
  br i1 %155, label %$49, label %$53
$53:
  %156 = icmp sge i32 90, %151
  br i1 %156, label %$55, label %$54
$55:
  %157 = icmp sge i32 %151, 65
  br label %$54
$54:
  %158 = phi i1 [0, %$53], [%157, %$55] ; # ->
  br i1 %158, label %$49, label %$56
$56:
  %159 = call i8* @strchr(i8* %110, i32 %151)
  %160 = icmp ne i8* %159, null
  br label %$49
$49:
  %161 = phi i1 [1, %$47], [1, %$51], [1, %$54], [%160, %$56] ; # ->
  %162 = icmp eq i1 %161, 0
  br i1 %162, label %$57, label %$48
$57:
  %163 = phi i32 [%151, %$49] ; # C
; # (or (> (char "0") C) (> C (char "9")))
; # (> (char "0") C)
  %164 = icmp sgt i32 48, %163
  br i1 %164, label %$58, label %$59
$59:
  %165 = phi i32 [%163, %$57] ; # C
; # (> C (char "9"))
  %166 = icmp sgt i32 %165, 57
  br label %$58
$58:
  %167 = phi i32 [%163, %$57], [%165, %$59] ; # C
  %168 = phi i1 [1, %$57], [%166, %$59] ; # ->
  br label %$48
$48:
  %169 = phi i32 [%151, %$49], [%167, %$58] ; # C
  %170 = phi i1 [0, %$49], [%168, %$58] ; # ->
  br i1 %170, label %$61, label %$60
$60:
  %171 = phi i32 [%169, %$48] ; # C
; # (when (== C (char "\\")) (call $Get))
; # (== C (char "\\"))
  %172 = icmp eq i32 %171, 92
  br i1 %172, label %$62, label %$63
$62:
  %173 = phi i32 [%171, %$60] ; # C
; # (call $Get)
  %174 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %175 = call i32 %174()
  br label %$63
$63:
  %176 = phi i32 [%171, %$60], [%173, %$62] ; # C
  br label %$47
$61:
  %177 = phi i32 [%169, %$48] ; # C
  %178 = phi i64 [0, %$48] ; # ->
; # (val 3 P)
  %179 = getelementptr i64, i64* %139, i32 2
  %180 = load i64, i64* %179
; # (requestSym (val 3 P))
  %181 = call i64 @requestSym(i64 %180)
; # (drop *Safe)
  %182 = inttoptr i64 %142 to i64*
  %183 = getelementptr i64, i64* %182, i32 1
  %184 = load i64, i64* %183
  %185 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %184, i64* %185
  br label %$44
$44:
  %186 = phi i32 [%128, %$42], [%177, %$61] ; # C
  %187 = phi i64 [%130, %$42], [%181, %$61] ; # ->
  br label %$5
$5:
  %188 = phi i32 [%9, %$7], [%62, %$10], [%94, %$30], [%186, %$44] ; # C
  %189 = phi i64 [0, %$7], [%63, %$10], [%101, %$30], [%187, %$44] ; # ->
  ret i64 %189
}

define i64 @_Read(i64) align 8 {
$1:
; # (let X (cdr Exe) (prog1 (if (atom X) (read1 0) (let Y (save (need...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (prog1 (if (atom X) (read1 0) (let Y (save (needSymb Exe (eval (+...
; # (if (atom X) (read1 0) (let Y (save (needSymb Exe (eval (++ X))))...
; # (atom X)
  %4 = and i64 %3, 15
  %5 = icmp ne i64 %4, 0
  br i1 %5, label %$2, label %$3
$2:
  %6 = phi i64 [%3, %$1] ; # X
; # (read1 0)
  %7 = call i64 @read1(i32 0)
  br label %$4
$3:
  %8 = phi i64 [%3, %$1] ; # X
; # (let Y (save (needSymb Exe (eval (++ X)))) (if (token Y (firstCha...
; # (++ X)
  %9 = inttoptr i64 %8 to i64*
  %10 = load i64, i64* %9
  %11 = getelementptr i64, i64* %9, i32 1
  %12 = load i64, i64* %11
; # (eval (++ X))
  %13 = and i64 %10, 6
  %14 = icmp ne i64 %13, 0
  br i1 %14, label %$7, label %$6
$7:
  br label %$5
$6:
  %15 = and i64 %10, 8
  %16 = icmp ne i64 %15, 0
  br i1 %16, label %$9, label %$8
$9:
  %17 = inttoptr i64 %10 to i64*
  %18 = load i64, i64* %17
  br label %$5
$8:
  %19 = call i64 @evList(i64 %10)
  br label %$5
$5:
  %20 = phi i64 [%10, %$7], [%18, %$9], [%19, %$8] ; # ->
; # (needSymb Exe (eval (++ X)))
  %21 = xor i64 %20, 8
  %22 = and i64 %21, 14
  %23 = icmp eq i64 %22, 0
  br i1 %23, label %$11, label %$10
$10:
  call void @symErr(i64 %0, i64 %20)
  unreachable
$11:
; # (save (needSymb Exe (eval (++ X))))
  %24 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %25 = load i64, i64* %24
  %26 = alloca i64, i64 2, align 16
  %27 = ptrtoint i64* %26 to i64
  %28 = inttoptr i64 %27 to i64*
  store i64 %20, i64* %28
  %29 = add i64 %27, 8
  %30 = inttoptr i64 %29 to i64*
  store i64 %25, i64* %30
  %31 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %27, i64* %31
; # (if (token Y (firstChar (needSymb Exe (eval (car X))))) @ $Nil)
; # (car X)
  %32 = inttoptr i64 %12 to i64*
  %33 = load i64, i64* %32
; # (eval (car X))
  %34 = and i64 %33, 6
  %35 = icmp ne i64 %34, 0
  br i1 %35, label %$14, label %$13
$14:
  br label %$12
$13:
  %36 = and i64 %33, 8
  %37 = icmp ne i64 %36, 0
  br i1 %37, label %$16, label %$15
$16:
  %38 = inttoptr i64 %33 to i64*
  %39 = load i64, i64* %38
  br label %$12
$15:
  %40 = call i64 @evList(i64 %33)
  br label %$12
$12:
  %41 = phi i64 [%33, %$14], [%39, %$16], [%40, %$15] ; # ->
; # (needSymb Exe (eval (car X)))
  %42 = xor i64 %41, 8
  %43 = and i64 %42, 14
  %44 = icmp eq i64 %43, 0
  br i1 %44, label %$18, label %$17
$17:
  call void @symErr(i64 %0, i64 %41)
  unreachable
$18:
; # (firstChar (needSymb Exe (eval (car X))))
  %45 = call i32 @firstChar(i64 %41)
; # (token Y (firstChar (needSymb Exe (eval (car X)))))
  %46 = call i64 @token(i64 %20, i32 %45)
  %47 = icmp ne i64 %46, 0
  br i1 %47, label %$19, label %$20
$19:
  %48 = phi i64 [%12, %$18] ; # X
  br label %$21
$20:
  %49 = phi i64 [%12, %$18] ; # X
  br label %$21
$21:
  %50 = phi i64 [%48, %$19], [%49, %$20] ; # X
  %51 = phi i64 [%46, %$19], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$20] ; # ->
; # (drop *Safe)
  %52 = inttoptr i64 %27 to i64*
  %53 = getelementptr i64, i64* %52, i32 1
  %54 = load i64, i64* %53
  %55 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %54, i64* %55
  br label %$4
$4:
  %56 = phi i64 [%6, %$2], [%50, %$21] ; # X
  %57 = phi i64 [%7, %$2], [%51, %$21] ; # ->
; # (and (== (val $Chr) (char "^J")) (== (val $InFile) (val (val $InF...
; # (val $Chr)
  %58 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
; # (== (val $Chr) (char "^J"))
  %59 = icmp eq i32 %58, 10
  br i1 %59, label %$23, label %$22
$23:
  %60 = phi i64 [%56, %$4] ; # X
; # (val $InFile)
  %61 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 72) to i8**)
; # (val $InFiles)
  %62 = load i8**, i8*** @$InFiles
; # (val (val $InFiles))
  %63 = load i8*, i8** %62
; # (== (val $InFile) (val (val $InFiles)))
  %64 = icmp eq i8* %61, %63
  br i1 %64, label %$24, label %$22
$24:
  %65 = phi i64 [%60, %$23] ; # X
; # (set $Chr 0)
  store i32 0, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
  %66 = icmp ne i32 0, 0
  br label %$22
$22:
  %67 = phi i64 [%56, %$4], [%60, %$23], [%65, %$24] ; # X
  %68 = phi i1 [0, %$4], [0, %$23], [%66, %$24] ; # ->
  ret i64 %57
}

define i64 @_Key(i64) align 8 {
$1:
; # (flushAll)
  call void @flushAll()
; # (let (X (cdr Exe) Cnt (if (nil? (eval (++ X))) 292MY (xCnt Exe @)...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (if (nil? (eval (++ X))) 292MY (xCnt Exe @))
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (nil? (eval (++ X)))
  %16 = icmp eq i64 %15, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %16, label %$7, label %$8
$7:
  br label %$9
$8:
; # (xCnt Exe @)
  %17 = call i64 @xCnt(i64 %0, i64 %15)
  br label %$9
$9:
  %18 = phi i64 [9223372036854775807, %$7], [%17, %$8] ; # ->
; # (if (nil? (eval (car X))) -ZERO (needChkVar Exe @))
; # (car X)
  %19 = inttoptr i64 %7 to i64*
  %20 = load i64, i64* %19
; # (eval (car X))
  %21 = and i64 %20, 6
  %22 = icmp ne i64 %21, 0
  br i1 %22, label %$12, label %$11
$12:
  br label %$10
$11:
  %23 = and i64 %20, 8
  %24 = icmp ne i64 %23, 0
  br i1 %24, label %$14, label %$13
$14:
  %25 = inttoptr i64 %20 to i64*
  %26 = load i64, i64* %25
  br label %$10
$13:
  %27 = call i64 @evList(i64 %20)
  br label %$10
$10:
  %28 = phi i64 [%20, %$12], [%26, %$14], [%27, %$13] ; # ->
; # (nil? (eval (car X)))
  %29 = icmp eq i64 %28, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %29, label %$15, label %$16
$15:
  br label %$17
$16:
; # (needChkVar Exe @)
  %30 = and i64 %28, 6
  %31 = icmp ne i64 %30, 0
  br i1 %31, label %$18, label %$19
$18:
  call void @varErr(i64 %0, i64 %28)
  unreachable
$19:
  %32 = icmp uge i64 %28, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %32, label %$21, label %$20
$21:
  %33 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %28
  br label %$20
$20:
  %34 = phi i1 [0, %$19], [%33, %$21] ; # ->
  br i1 %34, label %$22, label %$23
$22:
  call void @protErr(i64 %0, i64 %28)
  unreachable
$23:
  br label %$17
$17:
  %35 = phi i64 [10, %$15], [%28, %$23] ; # ->
; # (save (if (nil? (eval (car X))) -ZERO (needChkVar Exe @)))
  %36 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %37 = load i64, i64* %36
  %38 = alloca i64, i64 2, align 16
  %39 = ptrtoint i64* %38 to i64
  %40 = inttoptr i64 %39 to i64*
  store i64 %35, i64* %40
  %41 = add i64 %39, 8
  %42 = inttoptr i64 %41 to i64*
  store i64 %37, i64* %42
  %43 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %39, i64* %43
; # (val Termio)
  %44 = load i8*, i8** @Termio
; # (prog2 (setRaw) (if (waitFd Exe 0 Cnt) (let (Ms @ C (stdinByte)) ...
; # (setRaw)
  call void @setRaw()
; # (if (waitFd Exe 0 Cnt) (let (Ms @ C (stdinByte)) (unless (== Var ...
; # (waitFd Exe 0 Cnt)
  %45 = call i64 @waitFd(i64 %0, i32 0, i64 %18)
  %46 = icmp ne i64 %45, 0
  br i1 %46, label %$24, label %$25
$24:
; # (let (Ms @ C (stdinByte)) (unless (== Var -ZERO) (set Var (cnt Ms...
; # (stdinByte)
  %47 = call i32 @stdinByte()
; # (unless (== Var -ZERO) (set Var (cnt Ms)))
; # (== Var -ZERO)
  %48 = icmp eq i64 %35, 10
  br i1 %48, label %$28, label %$27
$27:
; # (set Var (cnt Ms))
; # (cnt Ms)
  %49 = shl i64 %45, 4
  %50 = or i64 %49, 2
  %51 = inttoptr i64 %35 to i64*
  store i64 %50, i64* %51
  br label %$28
$28:
; # (cond ((>= 127 C) C) ((== C (hex "FF")) (i32 TOP)) (T (let B (ifn...
; # (>= 127 C)
  %52 = icmp sge i32 127, %47
  br i1 %52, label %$31, label %$30
$31:
  br label %$29
$30:
; # (== C (hex "FF"))
  %53 = icmp eq i32 %47, 255
  br i1 %53, label %$33, label %$32
$33:
; # (i32 TOP)
  br label %$29
$32:
; # (let B (ifn (& C (hex "20")) (& C (hex "1F")) (let A (ifn (& C (h...
; # (ifn (& C (hex "20")) (& C (hex "1F")) (let A (ifn (& C (hex "10"...
; # (& C (hex "20"))
  %54 = and i32 %47, 32
  %55 = icmp ne i32 %54, 0
  br i1 %55, label %$35, label %$34
$34:
; # (& C (hex "1F"))
  %56 = and i32 %47, 31
  br label %$36
$35:
; # (let A (ifn (& C (hex "10")) (& C (hex "0F")) (| (shl (& C 7) 6) ...
; # (ifn (& C (hex "10")) (& C (hex "0F")) (| (shl (& C 7) 6) (& (std...
; # (& C (hex "10"))
  %57 = and i32 %47, 16
  %58 = icmp ne i32 %57, 0
  br i1 %58, label %$38, label %$37
$37:
; # (& C (hex "0F"))
  %59 = and i32 %47, 15
  br label %$39
$38:
; # (& C 7)
  %60 = and i32 %47, 7
; # (shl (& C 7) 6)
  %61 = shl i32 %60, 6
; # (stdinByte)
  %62 = call i32 @stdinByte()
; # (& (stdinByte) (hex "3F"))
  %63 = and i32 %62, 63
; # (| (shl (& C 7) 6) (& (stdinByte) (hex "3F")))
  %64 = or i32 %61, %63
  br label %$39
$39:
  %65 = phi i32 [%59, %$37], [%64, %$38] ; # ->
; # (shl A 6)
  %66 = shl i32 %65, 6
; # (stdinByte)
  %67 = call i32 @stdinByte()
; # (& (stdinByte) (hex "3F"))
  %68 = and i32 %67, 63
; # (| (shl A 6) (& (stdinByte) (hex "3F")))
  %69 = or i32 %66, %68
  br label %$36
$36:
  %70 = phi i32 [%56, %$34], [%69, %$39] ; # ->
; # (shl B 6)
  %71 = shl i32 %70, 6
; # (stdinByte)
  %72 = call i32 @stdinByte()
; # (& (stdinByte) (hex "3F"))
  %73 = and i32 %72, 63
; # (| (shl B 6) (& (stdinByte) (hex "3F")))
  %74 = or i32 %71, %73
  br label %$29
$29:
  %75 = phi i32 [%47, %$31], [1114112, %$33], [%74, %$36] ; # ->
; # (mkChar (cond ((>= 127 C) C) ((== C (hex "FF")) (i32 TOP)) (T (le...
  %76 = call i64 @mkChar(i32 %75)
  br label %$26
$25:
  br label %$26
$26:
  %77 = phi i64 [%76, %$29], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$25] ; # ->
; # (unless Raw (setCooked))
  %78 = icmp ne i8* %44, null
  br i1 %78, label %$41, label %$40
$40:
; # (setCooked)
  call void @setCooked()
  br label %$41
$41:
; # (drop *Safe)
  %79 = inttoptr i64 %39 to i64*
  %80 = getelementptr i64, i64* %79, i32 1
  %81 = load i64, i64* %80
  %82 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %81, i64* %82
  ret i64 %77
}

define i64 @_Peek(i64) align 8 {
$1:
; # (let C (if (val $Chr) @ (call $Get)) (if (lt0 C) $Nil (mkChar C))...
; # (if (val $Chr) @ (call $Get))
; # (val $Chr)
  %1 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
  %2 = icmp ne i32 %1, 0
  br i1 %2, label %$2, label %$3
$2:
  br label %$4
$3:
; # (call $Get)
  %3 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %4 = call i32 %3()
  br label %$4
$4:
  %5 = phi i32 [%1, %$2], [%4, %$3] ; # ->
; # (if (lt0 C) $Nil (mkChar C))
; # (lt0 C)
  %6 = icmp slt i32 %5, 0
  br i1 %6, label %$5, label %$6
$5:
  br label %$7
$6:
; # (mkChar C)
  %7 = call i64 @mkChar(i32 %5)
  br label %$7
$7:
  %8 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$5], [%7, %$6] ; # ->
  ret i64 %8
}

define i64 @_Char(i64) align 8 {
$1:
; # (let X (cdr Exe) (cond ((atom X) (let Chr (if (val $Chr) @ (call ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (cond ((atom X) (let Chr (if (val $Chr) @ (call $Get)) (prog1 (if...
; # (atom X)
  %4 = and i64 %3, 15
  %5 = icmp ne i64 %4, 0
  br i1 %5, label %$4, label %$3
$4:
; # (let Chr (if (val $Chr) @ (call $Get)) (prog1 (if (lt0 Chr) $Nil ...
; # (if (val $Chr) @ (call $Get))
; # (val $Chr)
  %6 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
  %7 = icmp ne i32 %6, 0
  br i1 %7, label %$5, label %$6
$5:
  br label %$7
$6:
; # (call $Get)
  %8 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %9 = call i32 %8()
  br label %$7
$7:
  %10 = phi i32 [%6, %$5], [%9, %$6] ; # ->
; # (prog1 (if (lt0 Chr) $Nil (mkChar (getChar Chr))) (call $Get))
; # (if (lt0 Chr) $Nil (mkChar (getChar Chr)))
; # (lt0 Chr)
  %11 = icmp slt i32 %10, 0
  br i1 %11, label %$8, label %$9
$8:
  br label %$10
$9:
; # (getChar Chr)
  %12 = call i32 @getChar(i32 %10)
; # (mkChar (getChar Chr))
  %13 = call i64 @mkChar(i32 %12)
  br label %$10
$10:
  %14 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$8], [%13, %$9] ; # ->
; # (call $Get)
  %15 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %16 = call i32 %15()
  br label %$2
$3:
; # (car X)
  %17 = inttoptr i64 %3 to i64*
  %18 = load i64, i64* %17
; # (eval (car X))
  %19 = and i64 %18, 6
  %20 = icmp ne i64 %19, 0
  br i1 %20, label %$13, label %$12
$13:
  br label %$11
$12:
  %21 = and i64 %18, 8
  %22 = icmp ne i64 %21, 0
  br i1 %22, label %$15, label %$14
$15:
  %23 = inttoptr i64 %18 to i64*
  %24 = load i64, i64* %23
  br label %$11
$14:
  %25 = call i64 @evList(i64 %18)
  br label %$11
$11:
  %26 = phi i64 [%18, %$13], [%24, %$15], [%25, %$14] ; # ->
; # (cnt? (eval (car X)))
  %27 = and i64 %26, 2
  %28 = icmp ne i64 %27, 0
  br i1 %28, label %$17, label %$16
$17:
; # (if (int @) (mkChar (i32 @)) $Nil)
; # (int @)
  %29 = lshr i64 %26, 4
  %30 = icmp ne i64 %29, 0
  br i1 %30, label %$18, label %$19
$18:
; # (i32 @)
  %31 = trunc i64 %29 to i32
; # (mkChar (i32 @))
  %32 = call i64 @mkChar(i32 %31)
  br label %$20
$19:
  br label %$20
$20:
  %33 = phi i64 [%32, %$18], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$19] ; # ->
  br label %$2
$16:
; # (t? @)
  %34 = icmp eq i64 %26, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %34, label %$22, label %$21
$22:
; # (mkChar TOP)
  %35 = call i64 @mkChar(i32 1114112)
  br label %$2
$21:
; # (symb? @)
  %36 = xor i64 %26, 8
  %37 = and i64 %36, 14
  %38 = icmp eq i64 %37, 0
  br i1 %38, label %$24, label %$23
$24:
; # (firstChar @)
  %39 = call i32 @firstChar(i64 %26)
; # (i64 (firstChar @))
  %40 = sext i32 %39 to i64
; # (cnt (i64 (firstChar @)))
  %41 = shl i64 %40, 4
  %42 = or i64 %41, 2
  br label %$2
$23:
; # (atomErr Exe @)
  call void @atomErr(i64 %0, i64 %26)
  unreachable
$2:
  %43 = phi i64 [%14, %$10], [%33, %$20], [%35, %$22], [%42, %$24] ; # ->
  ret i64 %43
}

define i64 @_Skip(i64) align 8 {
$1:
; # (if (lt0 (skipc (firstChar (evSym (cdr Exe))))) $Nil (mkChar @))
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (evSym (cdr Exe))
  %4 = call i64 @evSym(i64 %3)
; # (firstChar (evSym (cdr Exe)))
  %5 = call i32 @firstChar(i64 %4)
; # (skipc (firstChar (evSym (cdr Exe))))
  %6 = call i32 @skipc(i32 %5)
; # (lt0 (skipc (firstChar (evSym (cdr Exe)))))
  %7 = icmp slt i32 %6, 0
  br i1 %7, label %$2, label %$3
$2:
  br label %$4
$3:
; # (mkChar @)
  %8 = call i64 @mkChar(i32 %6)
  br label %$4
$4:
  %9 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%8, %$3] ; # ->
  ret i64 %9
}

define i64 @_Eol(i64) align 8 {
$1:
; # (let C (if (val $Chr) @ (call $Get)) (if (or (le0 C) (== C (char ...
; # (if (val $Chr) @ (call $Get))
; # (val $Chr)
  %1 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
  %2 = icmp ne i32 %1, 0
  br i1 %2, label %$2, label %$3
$2:
  br label %$4
$3:
; # (call $Get)
  %3 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %4 = call i32 %3()
  br label %$4
$4:
  %5 = phi i32 [%1, %$2], [%4, %$3] ; # ->
; # (if (or (le0 C) (== C (char "^J"))) $T $Nil)
; # (or (le0 C) (== C (char "^J")))
; # (le0 C)
  %6 = icmp sle i32 %5, 0
  br i1 %6, label %$5, label %$6
$6:
; # (== C (char "^J"))
  %7 = icmp eq i32 %5, 10
  br label %$5
$5:
  %8 = phi i1 [1, %$4], [%7, %$6] ; # ->
  br i1 %8, label %$7, label %$8
$7:
  br label %$9
$8:
  br label %$9
$9:
  %9 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # ->
  ret i64 %9
}

define i64 @_Eof(i64) align 8 {
$1:
; # (nond ((nil? (eval (cadr Exe))) (set $Chr -1) $T) ((=0 (val $Chr)...
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$5, label %$4
$5:
  br label %$3
$4:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$7, label %$6
$7:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$3
$6:
  %12 = call i64 @evList(i64 %5)
  br label %$3
$3:
  %13 = phi i64 [%5, %$5], [%11, %$7], [%12, %$6] ; # ->
; # (nil? (eval (cadr Exe)))
  %14 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %14, label %$8, label %$9
$9:
; # (set $Chr -1)
  store i32 -1, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
  br label %$2
$8:
; # (val $Chr)
  %15 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
; # (=0 (val $Chr))
  %16 = icmp eq i32 %15, 0
  br i1 %16, label %$10, label %$11
$11:
; # (if (lt0 @) $T $Nil)
; # (lt0 @)
  %17 = icmp slt i32 %15, 0
  br i1 %17, label %$12, label %$13
$12:
  br label %$14
$13:
  br label %$14
$14:
  %18 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$12], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$13] ; # ->
  br label %$2
$10:
; # (if (lt0 (call $Get)) $T $Nil)
; # (call $Get)
  %19 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %20 = call i32 %19()
; # (lt0 (call $Get))
  %21 = icmp slt i32 %20, 0
  br i1 %21, label %$15, label %$16
$15:
  br label %$17
$16:
  br label %$17
$17:
  %22 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$15], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$16] ; # ->
  br label %$2
$2:
  %23 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$9], [%18, %$14], [%22, %$17] ; # ->
  ret i64 %23
}

define i64 @_From(i64) align 8 {
$1:
; # (let (X (cdr Exe) N 1 Y (evSym X) Nm (xName Y) L (link (push Y NI...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (evSym X)
  %4 = call i64 @evSym(i64 %3)
; # (xName Y)
  %5 = call i64 @xName(i64 %4)
; # (bufSize Nm)
  %6 = call i64 @bufSize(i64 %5)
; # (b8 (bufSize Nm))
  %7 = alloca i8, i64 %6
; # (bufString Nm (b8 (bufSize Nm)))
  %8 = call i8* @bufString(i64 %5, i8* %7)
; # (any (bufString Nm (b8 (bufSize Nm))))
  %9 = ptrtoint i8* %8 to i64
; # (push Y NIL 0 (any (bufString Nm (b8 (bufSize Nm)))))
  %10 = alloca i64, i64 4, align 16
  %11 = ptrtoint i64* %10 to i64
  %12 = inttoptr i64 %11 to i64*
  store i64 %4, i64* %12
  %13 = add i64 %11, 16
  %14 = inttoptr i64 %13 to i64*
  store i64 0, i64* %14
  %15 = add i64 %11, 24
  %16 = inttoptr i64 %15 to i64*
  store i64 %9, i64* %16
; # (link (push Y NIL 0 (any (bufString Nm (b8 (bufSize Nm))))))
  %17 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %18 = load i64, i64* %17
  %19 = inttoptr i64 %11 to i64*
  %20 = getelementptr i64, i64* %19, i32 1
  store i64 %18, i64* %20
  %21 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %11, i64* %21
; # (while (pair (shift X)) (setq Y (evSym X) Nm (xName Y) L (link (p...
  br label %$2
$2:
  %22 = phi i64 [%3, %$1], [%32, %$3] ; # X
  %23 = phi i64 [1, %$1], [%55, %$3] ; # N
  %24 = phi i64 [%4, %$1], [%37, %$3] ; # Y
  %25 = phi i64 [%5, %$1], [%38, %$3] ; # Nm
  %26 = phi i64 [%11, %$1], [%44, %$3] ; # L
; # (shift X)
  %27 = inttoptr i64 %22 to i64*
  %28 = getelementptr i64, i64* %27, i32 1
  %29 = load i64, i64* %28
; # (pair (shift X))
  %30 = and i64 %29, 15
  %31 = icmp eq i64 %30, 0
  br i1 %31, label %$3, label %$4
$3:
  %32 = phi i64 [%29, %$2] ; # X
  %33 = phi i64 [%23, %$2] ; # N
  %34 = phi i64 [%24, %$2] ; # Y
  %35 = phi i64 [%25, %$2] ; # Nm
  %36 = phi i64 [%26, %$2] ; # L
; # (evSym X)
  %37 = call i64 @evSym(i64 %32)
; # (xName Y)
  %38 = call i64 @xName(i64 %37)
; # (bufSize Nm)
  %39 = call i64 @bufSize(i64 %38)
; # (b8 (bufSize Nm))
  %40 = alloca i8, i64 %39
; # (bufString Nm (b8 (bufSize Nm)))
  %41 = call i8* @bufString(i64 %38, i8* %40)
; # (any (bufString Nm (b8 (bufSize Nm))))
  %42 = ptrtoint i8* %41 to i64
; # (push Y NIL 0 (any (bufString Nm (b8 (bufSize Nm)))))
  %43 = alloca i64, i64 4, align 16
  %44 = ptrtoint i64* %43 to i64
  %45 = inttoptr i64 %44 to i64*
  store i64 %37, i64* %45
  %46 = add i64 %44, 16
  %47 = inttoptr i64 %46 to i64*
  store i64 0, i64* %47
  %48 = add i64 %44, 24
  %49 = inttoptr i64 %48 to i64*
  store i64 %42, i64* %49
; # (link (push Y NIL 0 (any (bufString Nm (b8 (bufSize Nm))))))
  %50 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %51 = load i64, i64* %50
  %52 = inttoptr i64 %44 to i64*
  %53 = getelementptr i64, i64* %52, i32 1
  store i64 %51, i64* %53
  %54 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %44, i64* %54
; # (inc 'N)
  %55 = add i64 %33, 1
  br label %$2
$4:
  %56 = phi i64 [%29, %$2] ; # X
  %57 = phi i64 [%23, %$2] ; # N
  %58 = phi i64 [%24, %$2] ; # Y
  %59 = phi i64 [%25, %$2] ; # Nm
  %60 = phi i64 [%26, %$2] ; # L
; # (unless (val $Chr) (call $Get))
; # (val $Chr)
  %61 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
  %62 = icmp ne i32 %61, 0
  br i1 %62, label %$6, label %$5
$5:
  %63 = phi i64 [%56, %$4] ; # X
  %64 = phi i64 [%57, %$4] ; # N
  %65 = phi i64 [%58, %$4] ; # Y
  %66 = phi i64 [%59, %$4] ; # Nm
  %67 = phi i64 [%60, %$4] ; # L
; # (call $Get)
  %68 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %69 = call i32 %68()
  br label %$6
$6:
  %70 = phi i64 [%56, %$4], [%63, %$5] ; # X
  %71 = phi i64 [%57, %$4], [%64, %$5] ; # N
  %72 = phi i64 [%58, %$4], [%65, %$5] ; # Y
  %73 = phi i64 [%59, %$4], [%66, %$5] ; # Nm
  %74 = phi i64 [%60, %$4], [%67, %$5] ; # L
; # (while (ge0 (val $Chr)) (let (B (i8 @) Q (i64* L) I N) (loop (loo...
  br label %$7
$7:
  %75 = phi i64 [%70, %$6], [%223, %$22] ; # X
  %76 = phi i64 [%71, %$6], [%224, %$22] ; # N
  %77 = phi i64 [%72, %$6], [%225, %$22] ; # Y
  %78 = phi i64 [%73, %$6], [%226, %$22] ; # Nm
  %79 = phi i64 [%74, %$6], [%227, %$22] ; # L
; # (val $Chr)
  %80 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
; # (ge0 (val $Chr))
  %81 = icmp sge i32 %80, 0
  br i1 %81, label %$8, label %$9
$8:
  %82 = phi i64 [%75, %$7] ; # X
  %83 = phi i64 [%76, %$7] ; # N
  %84 = phi i64 [%77, %$7] ; # Y
  %85 = phi i64 [%78, %$7] ; # Nm
  %86 = phi i64 [%79, %$7] ; # L
; # (let (B (i8 @) Q (i64* L) I N) (loop (loop (let S (ofs (i8* (val ...
; # (i8 @)
  %87 = trunc i32 %80 to i8
; # (i64* L)
  %88 = inttoptr i64 %86 to i64*
; # (loop (loop (let S (ofs (i8* (val 4 Q)) (val 3 Q)) (when (== B (v...
  br label %$10
$10:
  %89 = phi i64 [%82, %$8], [%213, %$21] ; # X
  %90 = phi i64 [%83, %$8], [%214, %$21] ; # N
  %91 = phi i64 [%84, %$8], [%215, %$21] ; # Y
  %92 = phi i64 [%85, %$8], [%216, %$21] ; # Nm
  %93 = phi i64 [%86, %$8], [%217, %$21] ; # L
  %94 = phi i64* [%88, %$8], [%222, %$21] ; # Q
  %95 = phi i64 [%83, %$8], [%219, %$21] ; # I
; # (loop (let S (ofs (i8* (val 4 Q)) (val 3 Q)) (when (== B (val S))...
  br label %$11
$11:
  %96 = phi i64 [%89, %$10], [%195, %$19] ; # X
  %97 = phi i64 [%90, %$10], [%196, %$19] ; # N
  %98 = phi i64 [%91, %$10], [%197, %$19] ; # Y
  %99 = phi i64 [%92, %$10], [%198, %$19] ; # Nm
  %100 = phi i64 [%93, %$10], [%199, %$19] ; # L
  %101 = phi i64* [%94, %$10], [%200, %$19] ; # Q
  %102 = phi i64 [%95, %$10], [%201, %$19] ; # I
; # (let S (ofs (i8* (val 4 Q)) (val 3 Q)) (when (== B (val S)) (set ...
; # (val 4 Q)
  %103 = getelementptr i64, i64* %101, i32 3
  %104 = load i64, i64* %103
; # (i8* (val 4 Q))
  %105 = inttoptr i64 %104 to i8*
; # (val 3 Q)
  %106 = getelementptr i64, i64* %101, i32 2
  %107 = load i64, i64* %106
; # (ofs (i8* (val 4 Q)) (val 3 Q))
  %108 = getelementptr i8, i8* %105, i64 %107
; # (when (== B (val S)) (set 3 Q (inc (val 3 Q))) (? (val 2 S)) (cal...
; # (val S)
  %109 = load i8, i8* %108
; # (== B (val S))
  %110 = icmp eq i8 %87, %109
  br i1 %110, label %$12, label %$13
$12:
  %111 = phi i64 [%96, %$11] ; # X
  %112 = phi i64 [%97, %$11] ; # N
  %113 = phi i64 [%98, %$11] ; # Y
  %114 = phi i64 [%99, %$11] ; # Nm
  %115 = phi i64 [%100, %$11] ; # L
  %116 = phi i64* [%101, %$11] ; # Q
  %117 = phi i64 [%102, %$11] ; # I
; # (set 3 Q (inc (val 3 Q)))
; # (val 3 Q)
  %118 = getelementptr i64, i64* %116, i32 2
  %119 = load i64, i64* %118
; # (inc (val 3 Q))
  %120 = add i64 %119, 1
  %121 = getelementptr i64, i64* %116, i32 2
  store i64 %120, i64* %121
; # (? (val 2 S))
; # (val 2 S)
  %122 = getelementptr i8, i8* %108, i32 1
  %123 = load i8, i8* %122
  %124 = icmp ne i8 %123, 0
  br i1 %124, label %$15, label %$14
$14:
  %125 = phi i64 [%111, %$12] ; # X
  %126 = phi i64 [%112, %$12] ; # N
  %127 = phi i64 [%113, %$12] ; # Y
  %128 = phi i64 [%114, %$12] ; # Nm
  %129 = phi i64 [%115, %$12] ; # L
  %130 = phi i64* [%116, %$12] ; # Q
  %131 = phi i64 [%117, %$12] ; # I
; # (call $Get)
  %132 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %133 = call i32 %132()
; # (drop P)
  %134 = inttoptr i64 %11 to i64*
  %135 = getelementptr i64, i64* %134, i32 1
  %136 = load i64, i64* %135
  %137 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %136, i64* %137
; # (val Q)
  %138 = load i64, i64* %130
; # (ret (val Q))
  ret i64 %138
$13:
  %139 = phi i64 [%96, %$11] ; # X
  %140 = phi i64 [%97, %$11] ; # N
  %141 = phi i64 [%98, %$11] ; # Y
  %142 = phi i64 [%99, %$11] ; # Nm
  %143 = phi i64 [%100, %$11] ; # L
  %144 = phi i64* [%101, %$11] ; # Q
  %145 = phi i64 [%102, %$11] ; # I
; # (? (=0 (val 3 Q)))
; # (val 3 Q)
  %146 = getelementptr i64, i64* %144, i32 2
  %147 = load i64, i64* %146
; # (=0 (val 3 Q))
  %148 = icmp eq i64 %147, 0
  br i1 %148, label %$15, label %$16
$16:
  %149 = phi i64 [%139, %$13] ; # X
  %150 = phi i64 [%140, %$13] ; # N
  %151 = phi i64 [%141, %$13] ; # Y
  %152 = phi i64 [%142, %$13] ; # Nm
  %153 = phi i64 [%143, %$13] ; # L
  %154 = phi i64* [%144, %$13] ; # Q
  %155 = phi i64 [%145, %$13] ; # I
; # (let S (ofs (i8* (val 4 Q)) 1) (while (set 3 Q (dec (val 3 Q))) (...
; # (val 4 Q)
  %156 = getelementptr i64, i64* %154, i32 3
  %157 = load i64, i64* %156
; # (i8* (val 4 Q))
  %158 = inttoptr i64 %157 to i8*
; # (ofs (i8* (val 4 Q)) 1)
  %159 = getelementptr i8, i8* %158, i32 1
; # (while (set 3 Q (dec (val 3 Q))) (? (=0 (memcmp (i8* (val 4 Q)) S...
  br label %$17
$17:
  %160 = phi i64 [%149, %$16], [%186, %$20] ; # X
  %161 = phi i64 [%150, %$16], [%187, %$20] ; # N
  %162 = phi i64 [%151, %$16], [%188, %$20] ; # Y
  %163 = phi i64 [%152, %$16], [%189, %$20] ; # Nm
  %164 = phi i64 [%153, %$16], [%190, %$20] ; # L
  %165 = phi i64* [%154, %$16], [%191, %$20] ; # Q
  %166 = phi i64 [%155, %$16], [%192, %$20] ; # I
  %167 = phi i8* [%159, %$16], [%194, %$20] ; # S
; # (set 3 Q (dec (val 3 Q)))
; # (val 3 Q)
  %168 = getelementptr i64, i64* %165, i32 2
  %169 = load i64, i64* %168
; # (dec (val 3 Q))
  %170 = sub i64 %169, 1
  %171 = getelementptr i64, i64* %165, i32 2
  store i64 %170, i64* %171
  %172 = icmp ne i64 %170, 0
  br i1 %172, label %$18, label %$19
$18:
  %173 = phi i64 [%160, %$17] ; # X
  %174 = phi i64 [%161, %$17] ; # N
  %175 = phi i64 [%162, %$17] ; # Y
  %176 = phi i64 [%163, %$17] ; # Nm
  %177 = phi i64 [%164, %$17] ; # L
  %178 = phi i64* [%165, %$17] ; # Q
  %179 = phi i64 [%166, %$17] ; # I
  %180 = phi i8* [%167, %$17] ; # S
; # (? (=0 (memcmp (i8* (val 4 Q)) S @)))
; # (val 4 Q)
  %181 = getelementptr i64, i64* %178, i32 3
  %182 = load i64, i64* %181
; # (i8* (val 4 Q))
  %183 = inttoptr i64 %182 to i8*
; # (memcmp (i8* (val 4 Q)) S @)
  %184 = call i32 @memcmp(i8* %183, i8* %180, i64 %170)
; # (=0 (memcmp (i8* (val 4 Q)) S @))
  %185 = icmp eq i32 %184, 0
  br i1 %185, label %$19, label %$20
$20:
  %186 = phi i64 [%173, %$18] ; # X
  %187 = phi i64 [%174, %$18] ; # N
  %188 = phi i64 [%175, %$18] ; # Y
  %189 = phi i64 [%176, %$18] ; # Nm
  %190 = phi i64 [%177, %$18] ; # L
  %191 = phi i64* [%178, %$18] ; # Q
  %192 = phi i64 [%179, %$18] ; # I
  %193 = phi i8* [%180, %$18] ; # S
; # (inc 'S)
  %194 = getelementptr i8, i8* %193, i32 1
  br label %$17
$19:
  %195 = phi i64 [%160, %$17], [%173, %$18] ; # X
  %196 = phi i64 [%161, %$17], [%174, %$18] ; # N
  %197 = phi i64 [%162, %$17], [%175, %$18] ; # Y
  %198 = phi i64 [%163, %$17], [%176, %$18] ; # Nm
  %199 = phi i64 [%164, %$17], [%177, %$18] ; # L
  %200 = phi i64* [%165, %$17], [%178, %$18] ; # Q
  %201 = phi i64 [%166, %$17], [%179, %$18] ; # I
  %202 = phi i8* [%167, %$17], [%180, %$18] ; # S
  br label %$11
$15:
  %203 = phi i64 [%111, %$12], [%139, %$13] ; # X
  %204 = phi i64 [%112, %$12], [%140, %$13] ; # N
  %205 = phi i64 [%113, %$12], [%141, %$13] ; # Y
  %206 = phi i64 [%114, %$12], [%142, %$13] ; # Nm
  %207 = phi i64 [%115, %$12], [%143, %$13] ; # L
  %208 = phi i64* [%116, %$12], [%144, %$13] ; # Q
  %209 = phi i64 [%117, %$12], [%145, %$13] ; # I
  %210 = phi i64 [0, %$12], [0, %$13] ; # ->
; # (? (=0 (dec 'I)))
; # (dec 'I)
  %211 = sub i64 %209, 1
; # (=0 (dec 'I))
  %212 = icmp eq i64 %211, 0
  br i1 %212, label %$22, label %$21
$21:
  %213 = phi i64 [%203, %$15] ; # X
  %214 = phi i64 [%204, %$15] ; # N
  %215 = phi i64 [%205, %$15] ; # Y
  %216 = phi i64 [%206, %$15] ; # Nm
  %217 = phi i64 [%207, %$15] ; # L
  %218 = phi i64* [%208, %$15] ; # Q
  %219 = phi i64 [%211, %$15] ; # I
; # (val 2 Q)
  %220 = getelementptr i64, i64* %218, i32 1
  %221 = load i64, i64* %220
; # (i64* (val 2 Q))
  %222 = inttoptr i64 %221 to i64*
  br label %$10
$22:
  %223 = phi i64 [%203, %$15] ; # X
  %224 = phi i64 [%204, %$15] ; # N
  %225 = phi i64 [%205, %$15] ; # Y
  %226 = phi i64 [%206, %$15] ; # Nm
  %227 = phi i64 [%207, %$15] ; # L
  %228 = phi i64* [%208, %$15] ; # Q
  %229 = phi i64 [%211, %$15] ; # I
  %230 = phi i64 [0, %$15] ; # ->
; # (call $Get)
  %231 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %232 = call i32 %231()
  br label %$7
$9:
  %233 = phi i64 [%75, %$7] ; # X
  %234 = phi i64 [%76, %$7] ; # N
  %235 = phi i64 [%77, %$7] ; # Y
  %236 = phi i64 [%78, %$7] ; # Nm
  %237 = phi i64 [%79, %$7] ; # L
; # (drop P)
  %238 = inttoptr i64 %11 to i64*
  %239 = getelementptr i64, i64* %238, i32 1
  %240 = load i64, i64* %239
  %241 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %240, i64* %241
  ret i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
}

define i64 @_Till(i64) align 8 {
$1:
; # (let (X (cdr Exe) Nm (xName (evSym X)) S (bufString Nm (b8 (bufSi...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (evSym X)
  %4 = call i64 @evSym(i64 %3)
; # (xName (evSym X))
  %5 = call i64 @xName(i64 %4)
; # (bufSize Nm)
  %6 = call i64 @bufSize(i64 %5)
; # (b8 (bufSize Nm))
  %7 = alloca i8, i64 %6
; # (bufString Nm (b8 (bufSize Nm)))
  %8 = call i8* @bufString(i64 %5, i8* %7)
; # (let C (if (val $Chr) @ (call $Get)) (cond ((or (lt0 C) (strchr S...
; # (if (val $Chr) @ (call $Get))
; # (val $Chr)
  %9 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
  %10 = icmp ne i32 %9, 0
  br i1 %10, label %$2, label %$3
$2:
  br label %$4
$3:
; # (call $Get)
  %11 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %12 = call i32 %11()
  br label %$4
$4:
  %13 = phi i32 [%9, %$2], [%12, %$3] ; # ->
; # (cond ((or (lt0 C) (strchr S C)) $Nil) ((nil? (eval (cadr X))) (l...
; # (or (lt0 C) (strchr S C))
; # (lt0 C)
  %14 = icmp slt i32 %13, 0
  br i1 %14, label %$6, label %$7
$7:
  %15 = phi i32 [%13, %$4] ; # C
; # (strchr S C)
  %16 = call i8* @strchr(i8* %8, i32 %15)
  %17 = icmp ne i8* %16, null
  br label %$6
$6:
  %18 = phi i32 [%13, %$4], [%15, %$7] ; # C
  %19 = phi i1 [1, %$4], [%17, %$7] ; # ->
  br i1 %19, label %$9, label %$8
$9:
  %20 = phi i32 [%18, %$6] ; # C
  br label %$5
$8:
  %21 = phi i32 [%18, %$6] ; # C
; # (cadr X)
  %22 = inttoptr i64 %3 to i64*
  %23 = getelementptr i64, i64* %22, i32 1
  %24 = load i64, i64* %23
  %25 = inttoptr i64 %24 to i64*
  %26 = load i64, i64* %25
; # (eval (cadr X))
  %27 = and i64 %26, 6
  %28 = icmp ne i64 %27, 0
  br i1 %28, label %$12, label %$11
$12:
  br label %$10
$11:
  %29 = and i64 %26, 8
  %30 = icmp ne i64 %29, 0
  br i1 %30, label %$14, label %$13
$14:
  %31 = inttoptr i64 %26 to i64*
  %32 = load i64, i64* %31
  br label %$10
$13:
  %33 = call i64 @evList(i64 %26)
  br label %$10
$10:
  %34 = phi i64 [%26, %$12], [%32, %$14], [%33, %$13] ; # ->
; # (nil? (eval (cadr X)))
  %35 = icmp eq i64 %34, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %35, label %$16, label %$15
$16:
  %36 = phi i32 [%21, %$10] ; # C
; # (let (Y (cons (mkChar (getChar C)) $Nil) R (save Y)) (until (or (...
; # (getChar C)
  %37 = call i32 @getChar(i32 %36)
; # (mkChar (getChar C))
  %38 = call i64 @mkChar(i32 %37)
; # (cons (mkChar (getChar C)) $Nil)
  %39 = call i64 @cons(i64 %38, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (save Y)
  %40 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %41 = load i64, i64* %40
  %42 = alloca i64, i64 2, align 16
  %43 = ptrtoint i64* %42 to i64
  %44 = inttoptr i64 %43 to i64*
  store i64 %39, i64* %44
  %45 = add i64 %43, 8
  %46 = inttoptr i64 %45 to i64*
  store i64 %41, i64* %46
  %47 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %43, i64* %47
; # (until (or (le0 (setq C (call $Get))) (strchr S C)) (setq Y (set ...
  br label %$17
$17:
  %48 = phi i32 [%36, %$16], [%60, %$20] ; # C
  %49 = phi i64 [%39, %$16], [%64, %$20] ; # Y
; # (or (le0 (setq C (call $Get))) (strchr S C))
; # (call $Get)
  %50 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %51 = call i32 %50()
; # (le0 (setq C (call $Get)))
  %52 = icmp sle i32 %51, 0
  br i1 %52, label %$18, label %$19
$19:
  %53 = phi i32 [%51, %$17] ; # C
  %54 = phi i64 [%49, %$17] ; # Y
; # (strchr S C)
  %55 = call i8* @strchr(i8* %8, i32 %53)
  %56 = icmp ne i8* %55, null
  br label %$18
$18:
  %57 = phi i32 [%51, %$17], [%53, %$19] ; # C
  %58 = phi i64 [%49, %$17], [%54, %$19] ; # Y
  %59 = phi i1 [1, %$17], [%56, %$19] ; # ->
  br i1 %59, label %$21, label %$20
$20:
  %60 = phi i32 [%57, %$18] ; # C
  %61 = phi i64 [%58, %$18] ; # Y
; # (set 2 Y (cons (mkChar (getChar C)) $Nil))
; # (getChar C)
  %62 = call i32 @getChar(i32 %60)
; # (mkChar (getChar C))
  %63 = call i64 @mkChar(i32 %62)
; # (cons (mkChar (getChar C)) $Nil)
  %64 = call i64 @cons(i64 %63, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %65 = inttoptr i64 %61 to i64*
  %66 = getelementptr i64, i64* %65, i32 1
  store i64 %64, i64* %66
  br label %$17
$21:
  %67 = phi i32 [%57, %$18] ; # C
  %68 = phi i64 [%58, %$18] ; # Y
; # (drop *Safe)
  %69 = inttoptr i64 %43 to i64*
  %70 = getelementptr i64, i64* %69, i32 1
  %71 = load i64, i64* %70
  %72 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %71, i64* %72
  br label %$5
$15:
  %73 = phi i32 [%21, %$10] ; # C
; # (let (P (push 4 NIL ZERO NIL) Q (link (ofs P 2))) (loop (charSym ...
; # (push 4 NIL ZERO NIL)
  %74 = alloca i64, i64 4, align 16
  store i64 4, i64* %74
  %75 = getelementptr i64, i64* %74, i32 2
  store i64 2, i64* %75
; # (ofs P 2)
  %76 = getelementptr i64, i64* %74, i32 2
; # (link (ofs P 2))
  %77 = ptrtoint i64* %76 to i64
  %78 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %79 = load i64, i64* %78
  %80 = inttoptr i64 %77 to i64*
  %81 = getelementptr i64, i64* %80, i32 1
  store i64 %79, i64* %81
  %82 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %77, i64* %82
; # (loop (charSym (getChar C) P) (? (le0 (setq C (call $Get)))) (? (...
  br label %$22
$22:
  %83 = phi i32 [%73, %$15], [%91, %$25] ; # C
; # (getChar C)
  %84 = call i32 @getChar(i32 %83)
; # (charSym (getChar C) P)
  call void @charSym(i32 %84, i64* %74)
; # (? (le0 (setq C (call $Get))))
; # (call $Get)
  %85 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %86 = call i32 %85()
; # (le0 (setq C (call $Get)))
  %87 = icmp sle i32 %86, 0
  br i1 %87, label %$24, label %$23
$23:
  %88 = phi i32 [%86, %$22] ; # C
; # (? (strchr S C))
; # (strchr S C)
  %89 = call i8* @strchr(i8* %8, i32 %88)
  %90 = icmp ne i8* %89, null
  br i1 %90, label %$24, label %$25
$25:
  %91 = phi i32 [%88, %$23] ; # C
  br label %$22
$24:
  %92 = phi i32 [%86, %$22], [%88, %$23] ; # C
  %93 = phi i64 [0, %$22], [0, %$23] ; # ->
; # (drop Q (consStr (val 3 P)))
; # (val 3 P)
  %94 = getelementptr i64, i64* %74, i32 2
  %95 = load i64, i64* %94
; # (consStr (val 3 P))
  %96 = call i64 @consStr(i64 %95)
  %97 = inttoptr i64 %77 to i64*
  %98 = getelementptr i64, i64* %97, i32 1
  %99 = load i64, i64* %98
  %100 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %99, i64* %100
  br label %$5
$5:
  %101 = phi i32 [%20, %$9], [%67, %$21], [%92, %$24] ; # C
  %102 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$9], [%39, %$21], [%96, %$24] ; # ->
  ret i64 %102
}

define i1 @eol(i32) align 8 {
$1:
; # (cond ((lt0 C) YES) ((== C (char "^J")) (set $Chr 0) YES) ((== C ...
; # (lt0 C)
  %1 = icmp slt i32 %0, 0
  br i1 %1, label %$4, label %$3
$4:
  br label %$2
$3:
; # (== C (char "^J"))
  %2 = icmp eq i32 %0, 10
  br i1 %2, label %$6, label %$5
$6:
; # (set $Chr 0)
  store i32 0, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
  br label %$2
$5:
; # (== C (char "^M"))
  %3 = icmp eq i32 %0, 13
  br i1 %3, label %$8, label %$7
$8:
; # (when (== (call $Get) (char "^J")) (set $Chr 0))
; # (call $Get)
  %4 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %5 = call i32 %4()
; # (== (call $Get) (char "^J"))
  %6 = icmp eq i32 %5, 10
  br i1 %6, label %$9, label %$10
$9:
; # (set $Chr 0)
  store i32 0, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
  br label %$10
$10:
  br label %$2
$7:
  br label %$2
$2:
  %7 = phi i1 [1, %$4], [1, %$6], [1, %$10], [0, %$7] ; # ->
  ret i1 %7
}

define i64 @_Line(i64) align 8 {
$1:
; # (let C (if (val $Chr) @ (call $Get)) (if (eol C) $Nil (let X (cdr...
; # (if (val $Chr) @ (call $Get))
; # (val $Chr)
  %1 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
  %2 = icmp ne i32 %1, 0
  br i1 %2, label %$2, label %$3
$2:
  br label %$4
$3:
; # (call $Get)
  %3 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %4 = call i32 %3()
  br label %$4
$4:
  %5 = phi i32 [%1, %$2], [%4, %$3] ; # ->
; # (if (eol C) $Nil (let X (cdr Exe) (cond ((nil? (eval (++ X))) (le...
; # (eol C)
  %6 = call i1 @eol(i32 %5)
  br i1 %6, label %$5, label %$6
$5:
  %7 = phi i32 [%5, %$4] ; # C
  br label %$7
$6:
  %8 = phi i32 [%5, %$4] ; # C
; # (let X (cdr Exe) (cond ((nil? (eval (++ X))) (let (Y (cons (mkCha...
; # (cdr Exe)
  %9 = inttoptr i64 %0 to i64*
  %10 = getelementptr i64, i64* %9, i32 1
  %11 = load i64, i64* %10
; # (cond ((nil? (eval (++ X))) (let (Y (cons (mkChar (getChar C)) $N...
; # (++ X)
  %12 = inttoptr i64 %11 to i64*
  %13 = load i64, i64* %12
  %14 = getelementptr i64, i64* %12, i32 1
  %15 = load i64, i64* %14
; # (eval (++ X))
  %16 = and i64 %13, 6
  %17 = icmp ne i64 %16, 0
  br i1 %17, label %$11, label %$10
$11:
  br label %$9
$10:
  %18 = and i64 %13, 8
  %19 = icmp ne i64 %18, 0
  br i1 %19, label %$13, label %$12
$13:
  %20 = inttoptr i64 %13 to i64*
  %21 = load i64, i64* %20
  br label %$9
$12:
  %22 = call i64 @evList(i64 %13)
  br label %$9
$9:
  %23 = phi i64 [%13, %$11], [%21, %$13], [%22, %$12] ; # ->
; # (nil? (eval (++ X)))
  %24 = icmp eq i64 %23, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %24, label %$15, label %$14
$15:
  %25 = phi i32 [%8, %$9] ; # C
  %26 = phi i64 [%15, %$9] ; # X
; # (let (Y (cons (mkChar (getChar C)) $Nil) R (save Y)) (when (pair ...
; # (getChar C)
  %27 = call i32 @getChar(i32 %25)
; # (mkChar (getChar C))
  %28 = call i64 @mkChar(i32 %27)
; # (cons (mkChar (getChar C)) $Nil)
  %29 = call i64 @cons(i64 %28, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (save Y)
  %30 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %31 = load i64, i64* %30
  %32 = alloca i64, i64 2, align 16
  %33 = ptrtoint i64* %32 to i64
  %34 = inttoptr i64 %33 to i64*
  store i64 %29, i64* %34
  %35 = add i64 %33, 8
  %36 = inttoptr i64 %35 to i64*
  store i64 %31, i64* %36
  %37 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %33, i64* %37
; # (when (pair X) (let Z (set Y (cons (car Y) $Nil)) (loop (let N (e...
; # (pair X)
  %38 = and i64 %26, 15
  %39 = icmp eq i64 %38, 0
  br i1 %39, label %$16, label %$17
$16:
  %40 = phi i32 [%25, %$15] ; # C
  %41 = phi i64 [%26, %$15] ; # X
  %42 = phi i64 [%29, %$15] ; # Y
; # (let Z (set Y (cons (car Y) $Nil)) (loop (let N (evCnt Exe X) (wh...
; # (set Y (cons (car Y) $Nil))
; # (car Y)
  %43 = inttoptr i64 %42 to i64*
  %44 = load i64, i64* %43
; # (cons (car Y) $Nil)
  %45 = call i64 @cons(i64 %44, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %46 = inttoptr i64 %42 to i64*
  store i64 %45, i64* %46
; # (loop (let N (evCnt Exe X) (while (gt0 (dec 'N)) (when (eol (setq...
  br label %$18
$18:
  %47 = phi i32 [%40, %$16], [%111, %$27] ; # C
  %48 = phi i64 [%41, %$16], [%112, %$27] ; # X
  %49 = phi i64 [%42, %$16], [%118, %$27] ; # Y
  %50 = phi i64 [%45, %$16], [%117, %$27] ; # Z
; # (let N (evCnt Exe X) (while (gt0 (dec 'N)) (when (eol (setq C (ca...
; # (evCnt Exe X)
  %51 = call i64 @evCnt(i64 %0, i64 %48)
; # (while (gt0 (dec 'N)) (when (eol (setq C (call $Get))) (ret R)) (...
  br label %$19
$19:
  %52 = phi i32 [%47, %$18], [%76, %$23] ; # C
  %53 = phi i64 [%48, %$18], [%77, %$23] ; # X
  %54 = phi i64 [%49, %$18], [%78, %$23] ; # Y
  %55 = phi i64 [%50, %$18], [%83, %$23] ; # Z
  %56 = phi i64 [%51, %$18], [%80, %$23] ; # N
; # (dec 'N)
  %57 = sub i64 %56, 1
; # (gt0 (dec 'N))
  %58 = icmp sgt i64 %57, 0
  br i1 %58, label %$20, label %$21
$20:
  %59 = phi i32 [%52, %$19] ; # C
  %60 = phi i64 [%53, %$19] ; # X
  %61 = phi i64 [%54, %$19] ; # Y
  %62 = phi i64 [%55, %$19] ; # Z
  %63 = phi i64 [%57, %$19] ; # N
; # (when (eol (setq C (call $Get))) (ret R))
; # (call $Get)
  %64 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %65 = call i32 %64()
; # (eol (setq C (call $Get)))
  %66 = call i1 @eol(i32 %65)
  br i1 %66, label %$22, label %$23
$22:
  %67 = phi i32 [%65, %$20] ; # C
  %68 = phi i64 [%60, %$20] ; # X
  %69 = phi i64 [%61, %$20] ; # Y
  %70 = phi i64 [%62, %$20] ; # Z
  %71 = phi i64 [%63, %$20] ; # N
; # (ret R)
; # (drop *Safe)
  %72 = inttoptr i64 %33 to i64*
  %73 = getelementptr i64, i64* %72, i32 1
  %74 = load i64, i64* %73
  %75 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %74, i64* %75
  ret i64 %29
$23:
  %76 = phi i32 [%65, %$20] ; # C
  %77 = phi i64 [%60, %$20] ; # X
  %78 = phi i64 [%61, %$20] ; # Y
  %79 = phi i64 [%62, %$20] ; # Z
  %80 = phi i64 [%63, %$20] ; # N
; # (set 2 Z (cons (mkChar (getChar C)) $Nil))
; # (getChar C)
  %81 = call i32 @getChar(i32 %76)
; # (mkChar (getChar C))
  %82 = call i64 @mkChar(i32 %81)
; # (cons (mkChar (getChar C)) $Nil)
  %83 = call i64 @cons(i64 %82, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %84 = inttoptr i64 %79 to i64*
  %85 = getelementptr i64, i64* %84, i32 1
  store i64 %83, i64* %85
  br label %$19
$21:
  %86 = phi i32 [%52, %$19] ; # C
  %87 = phi i64 [%53, %$19] ; # X
  %88 = phi i64 [%54, %$19] ; # Y
  %89 = phi i64 [%55, %$19] ; # Z
  %90 = phi i64 [%57, %$19] ; # N
; # (? (atom (shift X)))
; # (shift X)
  %91 = inttoptr i64 %87 to i64*
  %92 = getelementptr i64, i64* %91, i32 1
  %93 = load i64, i64* %92
; # (atom (shift X))
  %94 = and i64 %93, 15
  %95 = icmp ne i64 %94, 0
  br i1 %95, label %$25, label %$24
$24:
  %96 = phi i32 [%86, %$21] ; # C
  %97 = phi i64 [%93, %$21] ; # X
  %98 = phi i64 [%88, %$21] ; # Y
  %99 = phi i64 [%89, %$21] ; # Z
; # (when (eol (setq C (call $Get))) (ret R))
; # (call $Get)
  %100 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %101 = call i32 %100()
; # (eol (setq C (call $Get)))
  %102 = call i1 @eol(i32 %101)
  br i1 %102, label %$26, label %$27
$26:
  %103 = phi i32 [%101, %$24] ; # C
  %104 = phi i64 [%97, %$24] ; # X
  %105 = phi i64 [%98, %$24] ; # Y
  %106 = phi i64 [%99, %$24] ; # Z
; # (ret R)
; # (drop *Safe)
  %107 = inttoptr i64 %33 to i64*
  %108 = getelementptr i64, i64* %107, i32 1
  %109 = load i64, i64* %108
  %110 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %109, i64* %110
  ret i64 %29
$27:
  %111 = phi i32 [%101, %$24] ; # C
  %112 = phi i64 [%97, %$24] ; # X
  %113 = phi i64 [%98, %$24] ; # Y
  %114 = phi i64 [%99, %$24] ; # Z
; # (set 2 Y (cons (setq Z (cons (mkChar (getChar C)) $Nil)) $Nil))
; # (getChar C)
  %115 = call i32 @getChar(i32 %111)
; # (mkChar (getChar C))
  %116 = call i64 @mkChar(i32 %115)
; # (cons (mkChar (getChar C)) $Nil)
  %117 = call i64 @cons(i64 %116, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (cons (setq Z (cons (mkChar (getChar C)) $Nil)) $Nil)
  %118 = call i64 @cons(i64 %117, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %119 = inttoptr i64 %113 to i64*
  %120 = getelementptr i64, i64* %119, i32 1
  store i64 %118, i64* %120
  br label %$18
$25:
  %121 = phi i32 [%86, %$21] ; # C
  %122 = phi i64 [%93, %$21] ; # X
  %123 = phi i64 [%88, %$21] ; # Y
  %124 = phi i64 [%89, %$21] ; # Z
  %125 = phi i64 [0, %$21] ; # ->
  br label %$17
$17:
  %126 = phi i32 [%25, %$15], [%121, %$25] ; # C
  %127 = phi i64 [%26, %$15], [%122, %$25] ; # X
  %128 = phi i64 [%29, %$15], [%123, %$25] ; # Y
; # (until (eol (setq C (call $Get))) (setq Y (set 2 Y (cons (mkChar ...
  br label %$28
$28:
  %129 = phi i32 [%126, %$17], [%135, %$29] ; # C
  %130 = phi i64 [%127, %$17], [%136, %$29] ; # X
  %131 = phi i64 [%128, %$17], [%140, %$29] ; # Y
; # (call $Get)
  %132 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %133 = call i32 %132()
; # (eol (setq C (call $Get)))
  %134 = call i1 @eol(i32 %133)
  br i1 %134, label %$30, label %$29
$29:
  %135 = phi i32 [%133, %$28] ; # C
  %136 = phi i64 [%130, %$28] ; # X
  %137 = phi i64 [%131, %$28] ; # Y
; # (set 2 Y (cons (mkChar (getChar C)) $Nil))
; # (getChar C)
  %138 = call i32 @getChar(i32 %135)
; # (mkChar (getChar C))
  %139 = call i64 @mkChar(i32 %138)
; # (cons (mkChar (getChar C)) $Nil)
  %140 = call i64 @cons(i64 %139, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %141 = inttoptr i64 %137 to i64*
  %142 = getelementptr i64, i64* %141, i32 1
  store i64 %140, i64* %142
  br label %$28
$30:
  %143 = phi i32 [%133, %$28] ; # C
  %144 = phi i64 [%130, %$28] ; # X
  %145 = phi i64 [%131, %$28] ; # Y
; # (drop *Safe)
  %146 = inttoptr i64 %33 to i64*
  %147 = getelementptr i64, i64* %146, i32 1
  %148 = load i64, i64* %147
  %149 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %148, i64* %149
  br label %$8
$14:
  %150 = phi i32 [%8, %$9] ; # C
  %151 = phi i64 [%15, %$9] ; # X
; # (atom X)
  %152 = and i64 %151, 15
  %153 = icmp ne i64 %152, 0
  br i1 %153, label %$32, label %$31
$32:
  %154 = phi i32 [%150, %$14] ; # C
  %155 = phi i64 [%151, %$14] ; # X
; # (let (P (push 4 NIL ZERO NIL) Q (link (ofs P 2))) (loop (charSym ...
; # (push 4 NIL ZERO NIL)
  %156 = alloca i64, i64 4, align 16
  store i64 4, i64* %156
  %157 = getelementptr i64, i64* %156, i32 2
  store i64 2, i64* %157
; # (ofs P 2)
  %158 = getelementptr i64, i64* %156, i32 2
; # (link (ofs P 2))
  %159 = ptrtoint i64* %158 to i64
  %160 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %161 = load i64, i64* %160
  %162 = inttoptr i64 %159 to i64*
  %163 = getelementptr i64, i64* %162, i32 1
  store i64 %161, i64* %163
  %164 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %159, i64* %164
; # (loop (charSym (getChar C) P) (? (eol (setq C (call $Get)))))
  br label %$33
$33:
  %165 = phi i32 [%154, %$32], [%171, %$34] ; # C
  %166 = phi i64 [%155, %$32], [%172, %$34] ; # X
; # (getChar C)
  %167 = call i32 @getChar(i32 %165)
; # (charSym (getChar C) P)
  call void @charSym(i32 %167, i64* %156)
; # (? (eol (setq C (call $Get))))
; # (call $Get)
  %168 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %169 = call i32 %168()
; # (eol (setq C (call $Get)))
  %170 = call i1 @eol(i32 %169)
  br i1 %170, label %$35, label %$34
$34:
  %171 = phi i32 [%169, %$33] ; # C
  %172 = phi i64 [%166, %$33] ; # X
  br label %$33
$35:
  %173 = phi i32 [%169, %$33] ; # C
  %174 = phi i64 [%166, %$33] ; # X
  %175 = phi i64 [0, %$33] ; # ->
; # (drop Q (consStr (val 3 P)))
; # (val 3 P)
  %176 = getelementptr i64, i64* %156, i32 2
  %177 = load i64, i64* %176
; # (consStr (val 3 P))
  %178 = call i64 @consStr(i64 %177)
  %179 = inttoptr i64 %159 to i64*
  %180 = getelementptr i64, i64* %179, i32 1
  %181 = load i64, i64* %180
  %182 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %181, i64* %182
  br label %$8
$31:
  %183 = phi i32 [%150, %$14] ; # C
  %184 = phi i64 [%151, %$14] ; # X
; # (let (N (evCnt Exe X) P (push 4 NIL ZERO NIL) Q (link (ofs P 2) T...
; # (evCnt Exe X)
  %185 = call i64 @evCnt(i64 %0, i64 %184)
; # (push 4 NIL ZERO NIL)
  %186 = alloca i64, i64 4, align 16
  store i64 4, i64* %186
  %187 = getelementptr i64, i64* %186, i32 2
  store i64 2, i64* %187
; # (ofs P 2)
  %188 = getelementptr i64, i64* %186, i32 2
; # (link (ofs P 2) T)
  %189 = ptrtoint i64* %188 to i64
  %190 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %191 = load i64, i64* %190
  %192 = inttoptr i64 %189 to i64*
  %193 = getelementptr i64, i64* %192, i32 1
  store i64 %191, i64* %193
  %194 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %189, i64* %194
; # (loop (charSym (getChar C) P) (when (eol (setq C (call $Get))) (r...
  br label %$36
$36:
  %195 = phi i32 [%183, %$31], [%218, %$39] ; # C
  %196 = phi i64 [%184, %$31], [%219, %$39] ; # X
  %197 = phi i64 [%185, %$31], [%220, %$39] ; # N
; # (getChar C)
  %198 = call i32 @getChar(i32 %195)
; # (charSym (getChar C) P)
  call void @charSym(i32 %198, i64* %186)
; # (when (eol (setq C (call $Get))) (ret (cons (consStr (val Q)) $Ni...
; # (call $Get)
  %199 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %200 = call i32 %199()
; # (eol (setq C (call $Get)))
  %201 = call i1 @eol(i32 %200)
  br i1 %201, label %$37, label %$38
$37:
  %202 = phi i32 [%200, %$36] ; # C
  %203 = phi i64 [%196, %$36] ; # X
  %204 = phi i64 [%197, %$36] ; # N
; # (val Q)
  %205 = inttoptr i64 %189 to i64*
  %206 = load i64, i64* %205
; # (consStr (val Q))
  %207 = call i64 @consStr(i64 %206)
; # (cons (consStr (val Q)) $Nil)
  %208 = call i64 @cons(i64 %207, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (ret (cons (consStr (val Q)) $Nil))
; # (drop *Safe)
  %209 = inttoptr i64 %189 to i64*
  %210 = getelementptr i64, i64* %209, i32 1
  %211 = load i64, i64* %210
  %212 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %211, i64* %212
  ret i64 %208
$38:
  %213 = phi i32 [%200, %$36] ; # C
  %214 = phi i64 [%196, %$36] ; # X
  %215 = phi i64 [%197, %$36] ; # N
; # (? (=0 (dec 'N)))
; # (dec 'N)
  %216 = sub i64 %215, 1
; # (=0 (dec 'N))
  %217 = icmp eq i64 %216, 0
  br i1 %217, label %$40, label %$39
$39:
  %218 = phi i32 [%213, %$38] ; # C
  %219 = phi i64 [%214, %$38] ; # X
  %220 = phi i64 [%216, %$38] ; # N
  br label %$36
$40:
  %221 = phi i32 [%213, %$38] ; # C
  %222 = phi i64 [%214, %$38] ; # X
  %223 = phi i64 [%216, %$38] ; # N
  %224 = phi i64 [0, %$38] ; # ->
; # (let (Y (cons (consStr (val Q)) $Nil) R (save Y)) (while (pair (s...
; # (val Q)
  %225 = inttoptr i64 %189 to i64*
  %226 = load i64, i64* %225
; # (consStr (val Q))
  %227 = call i64 @consStr(i64 %226)
; # (cons (consStr (val Q)) $Nil)
  %228 = call i64 @cons(i64 %227, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (save Y)
  %229 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %230 = load i64, i64* %229
  %231 = alloca i64, i64 2, align 16
  %232 = ptrtoint i64* %231 to i64
  %233 = inttoptr i64 %232 to i64*
  store i64 %228, i64* %233
  %234 = add i64 %232, 8
  %235 = inttoptr i64 %234 to i64*
  store i64 %230, i64* %235
  %236 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %232, i64* %236
; # (while (pair (shift X)) (setq N (evCnt Exe X)) (set P 4 3 P ZERO)...
  br label %$41
$41:
  %237 = phi i32 [%221, %$40], [%284, %$48] ; # C
  %238 = phi i64 [%222, %$40], [%285, %$48] ; # X
  %239 = phi i64 [%223, %$40], [%286, %$48] ; # N
  %240 = phi i64 [%228, %$40], [%292, %$48] ; # Y
; # (shift X)
  %241 = inttoptr i64 %238 to i64*
  %242 = getelementptr i64, i64* %241, i32 1
  %243 = load i64, i64* %242
; # (pair (shift X))
  %244 = and i64 %243, 15
  %245 = icmp eq i64 %244, 0
  br i1 %245, label %$42, label %$43
$42:
  %246 = phi i32 [%237, %$41] ; # C
  %247 = phi i64 [%243, %$41] ; # X
  %248 = phi i64 [%239, %$41] ; # N
  %249 = phi i64 [%240, %$41] ; # Y
; # (evCnt Exe X)
  %250 = call i64 @evCnt(i64 %0, i64 %247)
; # (set P 4 3 P ZERO)
  store i64 4, i64* %186
  %251 = getelementptr i64, i64* %186, i32 2
  store i64 2, i64* %251
; # (loop (charSym (getChar C) P) (when (eol (setq C (call $Get))) (s...
  br label %$44
$44:
  %252 = phi i32 [%246, %$42], [%280, %$47] ; # C
  %253 = phi i64 [%247, %$42], [%281, %$47] ; # X
  %254 = phi i64 [%250, %$42], [%282, %$47] ; # N
  %255 = phi i64 [%249, %$42], [%283, %$47] ; # Y
; # (getChar C)
  %256 = call i32 @getChar(i32 %252)
; # (charSym (getChar C) P)
  call void @charSym(i32 %256, i64* %186)
; # (when (eol (setq C (call $Get))) (set 2 Y (cons (consStr (val Q))...
; # (call $Get)
  %257 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %258 = call i32 %257()
; # (eol (setq C (call $Get)))
  %259 = call i1 @eol(i32 %258)
  br i1 %259, label %$45, label %$46
$45:
  %260 = phi i32 [%258, %$44] ; # C
  %261 = phi i64 [%253, %$44] ; # X
  %262 = phi i64 [%254, %$44] ; # N
  %263 = phi i64 [%255, %$44] ; # Y
; # (set 2 Y (cons (consStr (val Q)) $Nil))
; # (val Q)
  %264 = inttoptr i64 %189 to i64*
  %265 = load i64, i64* %264
; # (consStr (val Q))
  %266 = call i64 @consStr(i64 %265)
; # (cons (consStr (val Q)) $Nil)
  %267 = call i64 @cons(i64 %266, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %268 = inttoptr i64 %263 to i64*
  %269 = getelementptr i64, i64* %268, i32 1
  store i64 %267, i64* %269
; # (ret R)
; # (drop *Safe)
  %270 = inttoptr i64 %189 to i64*
  %271 = getelementptr i64, i64* %270, i32 1
  %272 = load i64, i64* %271
  %273 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %272, i64* %273
  ret i64 %228
$46:
  %274 = phi i32 [%258, %$44] ; # C
  %275 = phi i64 [%253, %$44] ; # X
  %276 = phi i64 [%254, %$44] ; # N
  %277 = phi i64 [%255, %$44] ; # Y
; # (? (=0 (dec 'N)))
; # (dec 'N)
  %278 = sub i64 %276, 1
; # (=0 (dec 'N))
  %279 = icmp eq i64 %278, 0
  br i1 %279, label %$48, label %$47
$47:
  %280 = phi i32 [%274, %$46] ; # C
  %281 = phi i64 [%275, %$46] ; # X
  %282 = phi i64 [%278, %$46] ; # N
  %283 = phi i64 [%277, %$46] ; # Y
  br label %$44
$48:
  %284 = phi i32 [%274, %$46] ; # C
  %285 = phi i64 [%275, %$46] ; # X
  %286 = phi i64 [%278, %$46] ; # N
  %287 = phi i64 [%277, %$46] ; # Y
  %288 = phi i64 [0, %$46] ; # ->
; # (set 2 Y (cons (consStr (val Q)) $Nil))
; # (val Q)
  %289 = inttoptr i64 %189 to i64*
  %290 = load i64, i64* %289
; # (consStr (val Q))
  %291 = call i64 @consStr(i64 %290)
; # (cons (consStr (val Q)) $Nil)
  %292 = call i64 @cons(i64 %291, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %293 = inttoptr i64 %287 to i64*
  %294 = getelementptr i64, i64* %293, i32 1
  store i64 %292, i64* %294
  br label %$41
$43:
  %295 = phi i32 [%237, %$41] ; # C
  %296 = phi i64 [%243, %$41] ; # X
  %297 = phi i64 [%239, %$41] ; # N
  %298 = phi i64 [%240, %$41] ; # Y
; # (loop (setq Y (set 2 Y (cons (mkChar (getChar C)) $Nil))) (? (eol...
  br label %$49
$49:
  %299 = phi i32 [%295, %$43], [%311, %$50] ; # C
  %300 = phi i64 [%296, %$43], [%312, %$50] ; # X
  %301 = phi i64 [%297, %$43], [%313, %$50] ; # N
  %302 = phi i64 [%298, %$43], [%314, %$50] ; # Y
; # (set 2 Y (cons (mkChar (getChar C)) $Nil))
; # (getChar C)
  %303 = call i32 @getChar(i32 %299)
; # (mkChar (getChar C))
  %304 = call i64 @mkChar(i32 %303)
; # (cons (mkChar (getChar C)) $Nil)
  %305 = call i64 @cons(i64 %304, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %306 = inttoptr i64 %302 to i64*
  %307 = getelementptr i64, i64* %306, i32 1
  store i64 %305, i64* %307
; # (? (eol (setq C (call $Get))))
; # (call $Get)
  %308 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %309 = call i32 %308()
; # (eol (setq C (call $Get)))
  %310 = call i1 @eol(i32 %309)
  br i1 %310, label %$51, label %$50
$50:
  %311 = phi i32 [%309, %$49] ; # C
  %312 = phi i64 [%300, %$49] ; # X
  %313 = phi i64 [%301, %$49] ; # N
  %314 = phi i64 [%305, %$49] ; # Y
  br label %$49
$51:
  %315 = phi i32 [%309, %$49] ; # C
  %316 = phi i64 [%300, %$49] ; # X
  %317 = phi i64 [%301, %$49] ; # N
  %318 = phi i64 [%305, %$49] ; # Y
  %319 = phi i64 [0, %$49] ; # ->
; # (drop *Safe)
  %320 = inttoptr i64 %189 to i64*
  %321 = getelementptr i64, i64* %320, i32 1
  %322 = load i64, i64* %321
  %323 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %322, i64* %323
  br label %$8
$8:
  %324 = phi i32 [%143, %$30], [%173, %$35], [%315, %$51] ; # C
  %325 = phi i64 [%144, %$30], [%174, %$35], [%316, %$51] ; # X
  %326 = phi i64 [%29, %$30], [%178, %$35], [%228, %$51] ; # ->
  br label %$7
$7:
  %327 = phi i32 [%7, %$5], [%324, %$8] ; # C
  %328 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$5], [%326, %$8] ; # ->
  ret i64 %328
}

define i64 @_In(i64) align 8 {
$1:
; # (let X (cdr Exe) (rdOpen Exe (eval (++ X)) (b8+ (ioFrame T))) (pr...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (b8+ (ioFrame T))
  %16 = alloca i8, i64 28, align 8
; # (rdOpen Exe (eval (++ X)) (b8+ (ioFrame T)))
  call void @rdOpen(i64 %0, i64 %15, i8* %16)
; # (prog1 (run X) (popInFiles))
; # (run X)
  br label %$7
$7:
  %17 = phi i64 [%7, %$2], [%39, %$16] ; # Prg
  %18 = inttoptr i64 %17 to i64*
  %19 = load i64, i64* %18
  %20 = getelementptr i64, i64* %18, i32 1
  %21 = load i64, i64* %20
  %22 = and i64 %21, 15
  %23 = icmp ne i64 %22, 0
  br i1 %23, label %$10, label %$8
$10:
  %24 = phi i64 [%21, %$7] ; # Prg
  %25 = and i64 %19, 6
  %26 = icmp ne i64 %25, 0
  br i1 %26, label %$13, label %$12
$13:
  br label %$11
$12:
  %27 = and i64 %19, 8
  %28 = icmp ne i64 %27, 0
  br i1 %28, label %$15, label %$14
$15:
  %29 = inttoptr i64 %19 to i64*
  %30 = load i64, i64* %29
  br label %$11
$14:
  %31 = call i64 @evList(i64 %19)
  br label %$11
$11:
  %32 = phi i64 [%19, %$13], [%30, %$15], [%31, %$14] ; # ->
  br label %$9
$8:
  %33 = phi i64 [%21, %$7] ; # Prg
  %34 = and i64 %19, 15
  %35 = icmp eq i64 %34, 0
  br i1 %35, label %$17, label %$16
$17:
  %36 = phi i64 [%33, %$8] ; # Prg
  %37 = call i64 @evList(i64 %19)
  %38 = icmp ne i64 %37, 0
  br label %$16
$16:
  %39 = phi i64 [%33, %$8], [%36, %$17] ; # Prg
  %40 = phi i1 [0, %$8], [%38, %$17] ; # ->
  br label %$7
$9:
  %41 = phi i64 [%24, %$11] ; # Prg
  %42 = phi i64 [%32, %$11] ; # ->
; # (popInFiles)
  call void @popInFiles()
  ret i64 %42
}

define i64 @_Out(i64) align 8 {
$1:
; # (let X (cdr Exe) (wrOpen Exe (eval (++ X)) (b8+ (ioFrame T))) (pr...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (b8+ (ioFrame T))
  %16 = alloca i8, i64 28, align 8
; # (wrOpen Exe (eval (++ X)) (b8+ (ioFrame T)))
  call void @wrOpen(i64 %0, i64 %15, i8* %16)
; # (prog1 (run X) (popOutFiles))
; # (run X)
  br label %$7
$7:
  %17 = phi i64 [%7, %$2], [%39, %$16] ; # Prg
  %18 = inttoptr i64 %17 to i64*
  %19 = load i64, i64* %18
  %20 = getelementptr i64, i64* %18, i32 1
  %21 = load i64, i64* %20
  %22 = and i64 %21, 15
  %23 = icmp ne i64 %22, 0
  br i1 %23, label %$10, label %$8
$10:
  %24 = phi i64 [%21, %$7] ; # Prg
  %25 = and i64 %19, 6
  %26 = icmp ne i64 %25, 0
  br i1 %26, label %$13, label %$12
$13:
  br label %$11
$12:
  %27 = and i64 %19, 8
  %28 = icmp ne i64 %27, 0
  br i1 %28, label %$15, label %$14
$15:
  %29 = inttoptr i64 %19 to i64*
  %30 = load i64, i64* %29
  br label %$11
$14:
  %31 = call i64 @evList(i64 %19)
  br label %$11
$11:
  %32 = phi i64 [%19, %$13], [%30, %$15], [%31, %$14] ; # ->
  br label %$9
$8:
  %33 = phi i64 [%21, %$7] ; # Prg
  %34 = and i64 %19, 15
  %35 = icmp eq i64 %34, 0
  br i1 %35, label %$17, label %$16
$17:
  %36 = phi i64 [%33, %$8] ; # Prg
  %37 = call i64 @evList(i64 %19)
  %38 = icmp ne i64 %37, 0
  br label %$16
$16:
  %39 = phi i64 [%33, %$8], [%36, %$17] ; # Prg
  %40 = phi i1 [0, %$8], [%38, %$17] ; # ->
  br label %$7
$9:
  %41 = phi i64 [%24, %$11] ; # Prg
  %42 = phi i64 [%32, %$11] ; # ->
; # (popOutFiles)
  call void @popOutFiles()
  ret i64 %42
}

define i64 @_Err(i64) align 8 {
$1:
; # (let X (cdr Exe) (erOpen Exe (eval (++ X)) (b8+ (ctFrame T))) (pr...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (b8+ (ctFrame T))
  %16 = alloca i8, i64 12, align 8
; # (erOpen Exe (eval (++ X)) (b8+ (ctFrame T)))
  call void @erOpen(i64 %0, i64 %15, i8* %16)
; # (prog1 (run X) (popErrFiles))
; # (run X)
  br label %$7
$7:
  %17 = phi i64 [%7, %$2], [%39, %$16] ; # Prg
  %18 = inttoptr i64 %17 to i64*
  %19 = load i64, i64* %18
  %20 = getelementptr i64, i64* %18, i32 1
  %21 = load i64, i64* %20
  %22 = and i64 %21, 15
  %23 = icmp ne i64 %22, 0
  br i1 %23, label %$10, label %$8
$10:
  %24 = phi i64 [%21, %$7] ; # Prg
  %25 = and i64 %19, 6
  %26 = icmp ne i64 %25, 0
  br i1 %26, label %$13, label %$12
$13:
  br label %$11
$12:
  %27 = and i64 %19, 8
  %28 = icmp ne i64 %27, 0
  br i1 %28, label %$15, label %$14
$15:
  %29 = inttoptr i64 %19 to i64*
  %30 = load i64, i64* %29
  br label %$11
$14:
  %31 = call i64 @evList(i64 %19)
  br label %$11
$11:
  %32 = phi i64 [%19, %$13], [%30, %$15], [%31, %$14] ; # ->
  br label %$9
$8:
  %33 = phi i64 [%21, %$7] ; # Prg
  %34 = and i64 %19, 15
  %35 = icmp eq i64 %34, 0
  br i1 %35, label %$17, label %$16
$17:
  %36 = phi i64 [%33, %$8] ; # Prg
  %37 = call i64 @evList(i64 %19)
  %38 = icmp ne i64 %37, 0
  br label %$16
$16:
  %39 = phi i64 [%33, %$8], [%36, %$17] ; # Prg
  %40 = phi i1 [0, %$8], [%38, %$17] ; # ->
  br label %$7
$9:
  %41 = phi i64 [%24, %$11] ; # Prg
  %42 = phi i64 [%32, %$11] ; # ->
; # (popErrFiles)
  call void @popErrFiles()
  ret i64 %42
}

define i64 @_Ctl(i64) align 8 {
$1:
; # (let X (cdr Exe) (ctOpen Exe (eval (++ X)) (b8+ (ctFrame T))) (pr...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (b8+ (ctFrame T))
  %16 = alloca i8, i64 12, align 8
; # (ctOpen Exe (eval (++ X)) (b8+ (ctFrame T)))
  call void @ctOpen(i64 %0, i64 %15, i8* %16)
; # (prog1 (run X) (popCtlFiles))
; # (run X)
  br label %$7
$7:
  %17 = phi i64 [%7, %$2], [%39, %$16] ; # Prg
  %18 = inttoptr i64 %17 to i64*
  %19 = load i64, i64* %18
  %20 = getelementptr i64, i64* %18, i32 1
  %21 = load i64, i64* %20
  %22 = and i64 %21, 15
  %23 = icmp ne i64 %22, 0
  br i1 %23, label %$10, label %$8
$10:
  %24 = phi i64 [%21, %$7] ; # Prg
  %25 = and i64 %19, 6
  %26 = icmp ne i64 %25, 0
  br i1 %26, label %$13, label %$12
$13:
  br label %$11
$12:
  %27 = and i64 %19, 8
  %28 = icmp ne i64 %27, 0
  br i1 %28, label %$15, label %$14
$15:
  %29 = inttoptr i64 %19 to i64*
  %30 = load i64, i64* %29
  br label %$11
$14:
  %31 = call i64 @evList(i64 %19)
  br label %$11
$11:
  %32 = phi i64 [%19, %$13], [%30, %$15], [%31, %$14] ; # ->
  br label %$9
$8:
  %33 = phi i64 [%21, %$7] ; # Prg
  %34 = and i64 %19, 15
  %35 = icmp eq i64 %34, 0
  br i1 %35, label %$17, label %$16
$17:
  %36 = phi i64 [%33, %$8] ; # Prg
  %37 = call i64 @evList(i64 %19)
  %38 = icmp ne i64 %37, 0
  br label %$16
$16:
  %39 = phi i64 [%33, %$8], [%36, %$17] ; # Prg
  %40 = phi i1 [0, %$8], [%38, %$17] ; # ->
  br label %$7
$9:
  %41 = phi i64 [%24, %$11] ; # Prg
  %42 = phi i64 [%32, %$11] ; # ->
; # (popCtlFiles)
  call void @popCtlFiles()
  ret i64 %42
}

define void @pushInput(i8*, i64) align 8 {
$1:
; # (let Iox: (ioxFrame Iox) (Iox: link (val $InFrames)) (Iox: file n...
; # (Iox: link (val $InFrames))
  %2 = bitcast i8* %0 to i8**
  %3 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 40) to i8**)
  store i8* %3, i8** %2
; # (Iox: file null)
  %4 = getelementptr i8, i8* %0, i32 8
  %5 = bitcast i8* %4 to i8**
  store i8* null, i8** %5
; # (Iox: fun (val (i8** $Get)))
  %6 = getelementptr i8, i8* %0, i32 16
  %7 = bitcast i8* %6 to i8**
  %8 = bitcast i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**) to i8**
  %9 = load i8*, i8** %8
  store i8* %9, i8** %7
; # (Iox: exe Exe)
  %10 = getelementptr i8, i8* %0, i32 24
  %11 = ptrtoint i8* %10 to i64
  %12 = inttoptr i64 %11 to i64*
  store i64 %1, i64* %12
; # (Iox: chr (val $Chr))
  %13 = getelementptr i8, i8* %0, i32 32
  %14 = bitcast i8* %13 to i32*
  %15 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
  store i32 %15, i32* %14
; # (set $InFrames (Iox:) $Get (fun (i32) getIn) $IoChar 0 $Chr 0)
; # (Iox:)
  store i8* %0, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 40) to i8**)
; # (fun (i32) getIn)
  store i32()* @getIn, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  store i64 0, i64* @$IoChar
  store i32 0, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
  ret void
}

define void @pushOutput(i8*, i64) align 8 {
$1:
; # (let Iox: (ioxFrame Iox) (Iox: link (val $OutFrames)) (Iox: file ...
; # (Iox: link (val $OutFrames))
  %2 = bitcast i8* %0 to i8**
  %3 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 48) to i8**)
  store i8* %3, i8** %2
; # (Iox: file null)
  %4 = getelementptr i8, i8* %0, i32 8
  %5 = bitcast i8* %4 to i8**
  store i8* null, i8** %5
; # (Iox: fun (val (i8** $Put)))
  %6 = getelementptr i8, i8* %0, i32 16
  %7 = bitcast i8* %6 to i8**
  %8 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**) to i8**
  %9 = load i8*, i8** %8
  store i8* %9, i8** %7
; # (Iox: exe Exe)
  %10 = getelementptr i8, i8* %0, i32 24
  %11 = ptrtoint i8* %10 to i64
  %12 = inttoptr i64 %11 to i64*
  store i64 %1, i64* %12
; # (Iox: chr 0)
  %13 = getelementptr i8, i8* %0, i32 32
  %14 = bitcast i8* %13 to i32*
  store i32 0, i32* %14
; # (set $OutFrames (Iox:) $Put (fun (void i8) putOut))
; # (Iox:)
  store i8* %0, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 48) to i8**)
; # (fun (void i8) putOut)
  store void(i8)* @putOut, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  ret void
}

define i64 @_Input(i64) align 8 {
$1:
; # (let X (cdr Exe) (pushInput (b8+ (ioxFrame T)) (++ X)) (prog1 (ru...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (b8+ (ioxFrame T))
  %4 = alloca i8, i64 36, align 8
; # (++ X)
  %5 = inttoptr i64 %3 to i64*
  %6 = load i64, i64* %5
  %7 = getelementptr i64, i64* %5, i32 1
  %8 = load i64, i64* %7
; # (pushInput (b8+ (ioxFrame T)) (++ X))
  call void @pushInput(i8* %4, i64 %6)
; # (prog1 (run X) (popInFiles))
; # (run X)
  br label %$2
$2:
  %9 = phi i64 [%8, %$1], [%31, %$11] ; # Prg
  %10 = inttoptr i64 %9 to i64*
  %11 = load i64, i64* %10
  %12 = getelementptr i64, i64* %10, i32 1
  %13 = load i64, i64* %12
  %14 = and i64 %13, 15
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$5, label %$3
$5:
  %16 = phi i64 [%13, %$2] ; # Prg
  %17 = and i64 %11, 6
  %18 = icmp ne i64 %17, 0
  br i1 %18, label %$8, label %$7
$8:
  br label %$6
$7:
  %19 = and i64 %11, 8
  %20 = icmp ne i64 %19, 0
  br i1 %20, label %$10, label %$9
$10:
  %21 = inttoptr i64 %11 to i64*
  %22 = load i64, i64* %21
  br label %$6
$9:
  %23 = call i64 @evList(i64 %11)
  br label %$6
$6:
  %24 = phi i64 [%11, %$8], [%22, %$10], [%23, %$9] ; # ->
  br label %$4
$3:
  %25 = phi i64 [%13, %$2] ; # Prg
  %26 = and i64 %11, 15
  %27 = icmp eq i64 %26, 0
  br i1 %27, label %$12, label %$11
$12:
  %28 = phi i64 [%25, %$3] ; # Prg
  %29 = call i64 @evList(i64 %11)
  %30 = icmp ne i64 %29, 0
  br label %$11
$11:
  %31 = phi i64 [%25, %$3], [%28, %$12] ; # Prg
  %32 = phi i1 [0, %$3], [%30, %$12] ; # ->
  br label %$2
$4:
  %33 = phi i64 [%16, %$6] ; # Prg
  %34 = phi i64 [%24, %$6] ; # ->
; # (popInFiles)
  call void @popInFiles()
  ret i64 %34
}

define i64 @_Output(i64) align 8 {
$1:
; # (let X (cdr Exe) (pushOutput (b8+ (ioxFrame T)) (++ X)) (prog1 (r...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (b8+ (ioxFrame T))
  %4 = alloca i8, i64 36, align 8
; # (++ X)
  %5 = inttoptr i64 %3 to i64*
  %6 = load i64, i64* %5
  %7 = getelementptr i64, i64* %5, i32 1
  %8 = load i64, i64* %7
; # (pushOutput (b8+ (ioxFrame T)) (++ X))
  call void @pushOutput(i8* %4, i64 %6)
; # (prog1 (run X) (popOutFiles))
; # (run X)
  br label %$2
$2:
  %9 = phi i64 [%8, %$1], [%31, %$11] ; # Prg
  %10 = inttoptr i64 %9 to i64*
  %11 = load i64, i64* %10
  %12 = getelementptr i64, i64* %10, i32 1
  %13 = load i64, i64* %12
  %14 = and i64 %13, 15
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$5, label %$3
$5:
  %16 = phi i64 [%13, %$2] ; # Prg
  %17 = and i64 %11, 6
  %18 = icmp ne i64 %17, 0
  br i1 %18, label %$8, label %$7
$8:
  br label %$6
$7:
  %19 = and i64 %11, 8
  %20 = icmp ne i64 %19, 0
  br i1 %20, label %$10, label %$9
$10:
  %21 = inttoptr i64 %11 to i64*
  %22 = load i64, i64* %21
  br label %$6
$9:
  %23 = call i64 @evList(i64 %11)
  br label %$6
$6:
  %24 = phi i64 [%11, %$8], [%22, %$10], [%23, %$9] ; # ->
  br label %$4
$3:
  %25 = phi i64 [%13, %$2] ; # Prg
  %26 = and i64 %11, 15
  %27 = icmp eq i64 %26, 0
  br i1 %27, label %$12, label %$11
$12:
  %28 = phi i64 [%25, %$3] ; # Prg
  %29 = call i64 @evList(i64 %11)
  %30 = icmp ne i64 %29, 0
  br label %$11
$11:
  %31 = phi i64 [%25, %$3], [%28, %$12] ; # Prg
  %32 = phi i1 [0, %$3], [%30, %$12] ; # ->
  br label %$2
$4:
  %33 = phi i64 [%16, %$6] ; # Prg
  %34 = phi i64 [%24, %$6] ; # ->
; # (popOutFiles)
  call void @popOutFiles()
  ret i64 %34
}

define i64 @_Fd(i64) align 8 {
$1:
; # (let (X (eval (cadr Exe)) Fd (currFd Exe)) (unless (nil? X) (dup2...
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (currFd Exe)
  %14 = call i32 @currFd(i64 %0)
; # (unless (nil? X) (dup2 Fd (i32 (xCnt Exe X))))
; # (nil? X)
  %15 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %15, label %$8, label %$7
$7:
; # (xCnt Exe X)
  %16 = call i64 @xCnt(i64 %0, i64 %13)
; # (i32 (xCnt Exe X))
  %17 = trunc i64 %16 to i32
; # (dup2 Fd (i32 (xCnt Exe X)))
  %18 = call i32 @dup2(i32 %14, i32 %17)
  br label %$8
$8:
; # (i64 Fd)
  %19 = sext i32 %14 to i64
; # (cnt (i64 Fd))
  %20 = shl i64 %19, 4
  %21 = or i64 %20, 2
  ret i64 %21
}

define i32 @forkLisp(i64) align 8 {
$1:
; # (flushAll)
  call void @flushAll()
; # (unless (val $Spkr) (when (lt0 (pipe $SpMiPipe)) (pipeErr Exe)) (...
; # (val $Spkr)
  %1 = load i32, i32* @$Spkr
  %2 = icmp ne i32 %1, 0
  br i1 %2, label %$3, label %$2
$2:
; # (when (lt0 (pipe $SpMiPipe)) (pipeErr Exe))
; # (pipe $SpMiPipe)
  %3 = call i32 @pipe(i32* bitcast ([2 x i32]* @$SpMiPipe to i32*))
; # (lt0 (pipe $SpMiPipe))
  %4 = icmp slt i32 %3, 0
  br i1 %4, label %$4, label %$5
$4:
; # (pipeErr Exe)
  call void @pipeErr(i64 %0)
  unreachable
$5:
; # (set $Spkr (val $SpMiPipe))
; # (val $SpMiPipe)
  %5 = load i32, i32* bitcast ([2 x i32]* @$SpMiPipe to i32*)
  store i32 %5, i32* @$Spkr
; # (closeOnExec Exe (set $Spkr (val $SpMiPipe)))
  call void @closeOnExec(i64 %0, i32 %5)
; # (val 2 $SpMiPipe)
  %6 = getelementptr i32, i32* bitcast ([2 x i32]* @$SpMiPipe to i32*), i32 1
  %7 = load i32, i32* %6
; # (closeOnExec Exe (val 2 $SpMiPipe))
  call void @closeOnExec(i64 %0, i32 %7)
  br label %$3
$3:
; # (let (Hear (b32 2) Tell (b32 2)) (when (or (lt0 (pipe Hear)) (lt0...
; # (b32 2)
  %8 = alloca i32, i64 2
; # (b32 2)
  %9 = alloca i32, i64 2
; # (when (or (lt0 (pipe Hear)) (lt0 (pipe Tell))) (pipeErr Exe))
; # (or (lt0 (pipe Hear)) (lt0 (pipe Tell)))
; # (pipe Hear)
  %10 = call i32 @pipe(i32* %8)
; # (lt0 (pipe Hear))
  %11 = icmp slt i32 %10, 0
  br i1 %11, label %$6, label %$7
$7:
; # (pipe Tell)
  %12 = call i32 @pipe(i32* %9)
; # (lt0 (pipe Tell))
  %13 = icmp slt i32 %12, 0
  br label %$6
$6:
  %14 = phi i1 [1, %$3], [%13, %$7] ; # ->
  br i1 %14, label %$8, label %$9
$8:
; # (pipeErr Exe)
  call void @pipeErr(i64 %0)
  unreachable
$9:
; # (val Hear)
  %15 = load i32, i32* %8
; # (closeOnExec Exe (val Hear))
  call void @closeOnExec(i64 %0, i32 %15)
; # (val 2 Hear)
  %16 = getelementptr i32, i32* %8, i32 1
  %17 = load i32, i32* %16
; # (closeOnExec Exe (val 2 Hear))
  call void @closeOnExec(i64 %0, i32 %17)
; # (val Tell)
  %18 = load i32, i32* %9
; # (closeOnExec Exe (val Tell))
  call void @closeOnExec(i64 %0, i32 %18)
; # (val 2 Tell)
  %19 = getelementptr i32, i32* %9, i32 1
  %20 = load i32, i32* %19
; # (closeOnExec Exe (val 2 Tell))
  call void @closeOnExec(i64 %0, i32 %20)
; # (let (I (i32 0) N (val $Children)) (let Cld (val $Child) (while (...
; # (i32 0)
; # (val $Children)
  %21 = load i32, i32* @$Children
; # (let Cld (val $Child) (while (> N I) (? (=0 ((child Cld) pid))) (...
; # (val $Child)
  %22 = load i8*, i8** @$Child
; # (while (> N I) (? (=0 ((child Cld) pid))) (inc 'I) (setq Cld (ofs...
  br label %$10
$10:
  %23 = phi i32 [0, %$9], [%37, %$13] ; # I
  %24 = phi i32 [%21, %$9], [%35, %$13] ; # N
  %25 = phi i8* [%22, %$9], [%38, %$13] ; # Cld
; # (> N I)
  %26 = icmp sgt i32 %24, %23
  br i1 %26, label %$11, label %$12
$11:
  %27 = phi i32 [%23, %$10] ; # I
  %28 = phi i32 [%24, %$10] ; # N
  %29 = phi i8* [%25, %$10] ; # Cld
; # (? (=0 ((child Cld) pid)))
; # ((child Cld) pid)
  %30 = getelementptr i8, i8* %29, i32 16
  %31 = bitcast i8* %30 to i32*
  %32 = load i32, i32* %31
; # (=0 ((child Cld) pid))
  %33 = icmp eq i32 %32, 0
  br i1 %33, label %$12, label %$13
$13:
  %34 = phi i32 [%27, %$11] ; # I
  %35 = phi i32 [%28, %$11] ; # N
  %36 = phi i8* [%29, %$11] ; # Cld
; # (inc 'I)
  %37 = add i32 %34, 1
; # (ofs Cld (child T))
  %38 = getelementptr i8, i8* %36, i32 32
  br label %$10
$12:
  %39 = phi i32 [%23, %$10], [%27, %$11] ; # I
  %40 = phi i32 [%24, %$10], [%28, %$11] ; # N
  %41 = phi i8* [%25, %$10], [%29, %$11] ; # Cld
; # (cond ((lt0 (fork)) (forkErr Exe)) ((=0 @) (set $Slot I $Spkr 0 $...
; # (fork)
  %42 = call i32 @fork()
; # (lt0 (fork))
  %43 = icmp slt i32 %42, 0
  br i1 %43, label %$16, label %$15
$16:
  %44 = phi i32 [%39, %$12] ; # I
  %45 = phi i32 [%40, %$12] ; # N
; # (forkErr Exe)
  call void @forkErr(i64 %0)
  unreachable
$15:
  %46 = phi i32 [%39, %$12] ; # I
  %47 = phi i32 [%40, %$12] ; # N
; # (=0 @)
  %48 = icmp eq i32 %42, 0
  br i1 %48, label %$18, label %$17
$18:
  %49 = phi i32 [%46, %$15] ; # I
  %50 = phi i32 [%47, %$15] ; # N
; # (set $Slot I $Spkr 0 $Mic (val 2 $SpMiPipe))
  store i32 %49, i32* @$Slot
  store i32 0, i32* @$Spkr
; # (val 2 $SpMiPipe)
  %51 = getelementptr i32, i32* bitcast ([2 x i32]* @$SpMiPipe to i32*), i32 1
  %52 = load i32, i32* %51
  store i32 %52, i32* @$Mic
; # (val 2 Hear)
  %53 = getelementptr i32, i32* %8, i32 1
  %54 = load i32, i32* %53
; # (close (val 2 Hear))
  %55 = call i32 @close(i32 %54)
; # (val Tell)
  %56 = load i32, i32* %9
; # (close (val Tell))
  %57 = call i32 @close(i32 %56)
; # (val $SpMiPipe)
  %58 = load i32, i32* bitcast ([2 x i32]* @$SpMiPipe to i32*)
; # (close (val $SpMiPipe))
  %59 = call i32 @close(i32 %58)
; # (when (val $Hear) (close @) (closeInFile @) (closeOutFile @))
; # (val $Hear)
  %60 = load i32, i32* @$Hear
  %61 = icmp ne i32 %60, 0
  br i1 %61, label %$19, label %$20
$19:
  %62 = phi i32 [%49, %$18] ; # I
  %63 = phi i32 [%50, %$18] ; # N
; # (close @)
  %64 = call i32 @close(i32 %60)
; # (closeInFile @)
  call void @closeInFile(i32 %60)
; # (closeOutFile @)
  call void @closeOutFile(i32 %60)
  br label %$20
$20:
  %65 = phi i32 [%49, %$18], [%62, %$19] ; # I
  %66 = phi i32 [%50, %$18], [%63, %$19] ; # N
; # (set $Hear (val Hear))
; # (val Hear)
  %67 = load i32, i32* %8
  store i32 %67, i32* @$Hear
; # (initInFile (set $Hear (val Hear)) null)
  %68 = call i8* @initInFile(i32 %67, i8* null)
; # (when (val $Tell) (close @))
; # (val $Tell)
  %69 = load i32, i32* @$Tell
  %70 = icmp ne i32 %69, 0
  br i1 %70, label %$21, label %$22
$21:
  %71 = phi i32 [%65, %$20] ; # I
  %72 = phi i32 [%66, %$20] ; # N
; # (close @)
  %73 = call i32 @close(i32 %69)
  br label %$22
$22:
  %74 = phi i32 [%65, %$20], [%71, %$21] ; # I
  %75 = phi i32 [%66, %$20], [%72, %$21] ; # N
; # (set $Tell (val 2 Tell))
; # (val 2 Tell)
  %76 = getelementptr i32, i32* %9, i32 1
  %77 = load i32, i32* %76
  store i32 %77, i32* @$Tell
; # (set $Nfds 0)
  store i32 0, i32* @$Nfds
; # (val $Poll)
  %78 = load i64*, i64** @$Poll
; # (i8* (val $Poll))
  %79 = bitcast i64* %78 to i8*
; # (free (i8* (val $Poll)))
  call void @free(i8* %79)
; # (set $Poll (i64* null))
; # (i64* null)
  %80 = inttoptr i64 0 to i64*
  store i64* %80, i64** @$Poll
; # (let Cld (val $Child) (while (ge0 (dec 'N)) (let Cld: (child Cld)...
; # (val $Child)
  %81 = load i8*, i8** @$Child
; # (while (ge0 (dec 'N)) (let Cld: (child Cld) (when (Cld: pid) (fre...
  br label %$23
$23:
  %82 = phi i32 [%74, %$22], [%107, %$27] ; # I
  %83 = phi i32 [%75, %$22], [%108, %$27] ; # N
  %84 = phi i8* [%81, %$22], [%110, %$27] ; # Cld
; # (dec 'N)
  %85 = sub i32 %83, 1
; # (ge0 (dec 'N))
  %86 = icmp sge i32 %85, 0
  br i1 %86, label %$24, label %$25
$24:
  %87 = phi i32 [%82, %$23] ; # I
  %88 = phi i32 [%85, %$23] ; # N
  %89 = phi i8* [%84, %$23] ; # Cld
; # (let Cld: (child Cld) (when (Cld: pid) (free (Cld: buf)) (close (...
; # (when (Cld: pid) (free (Cld: buf)) (close (Cld: hear)) (close (Cl...
; # (Cld: pid)
  %90 = getelementptr i8, i8* %89, i32 16
  %91 = bitcast i8* %90 to i32*
  %92 = load i32, i32* %91
  %93 = icmp ne i32 %92, 0
  br i1 %93, label %$26, label %$27
$26:
  %94 = phi i32 [%87, %$24] ; # I
  %95 = phi i32 [%88, %$24] ; # N
  %96 = phi i8* [%89, %$24] ; # Cld
; # (Cld: buf)
  %97 = bitcast i8* %89 to i8**
  %98 = load i8*, i8** %97
; # (free (Cld: buf))
  call void @free(i8* %98)
; # (Cld: hear)
  %99 = getelementptr i8, i8* %89, i32 20
  %100 = bitcast i8* %99 to i32*
  %101 = load i32, i32* %100
; # (close (Cld: hear))
  %102 = call i32 @close(i32 %101)
; # (Cld: tell)
  %103 = getelementptr i8, i8* %89, i32 24
  %104 = bitcast i8* %103 to i32*
  %105 = load i32, i32* %104
; # (close (Cld: tell))
  %106 = call i32 @close(i32 %105)
  br label %$27
$27:
  %107 = phi i32 [%87, %$24], [%94, %$26] ; # I
  %108 = phi i32 [%88, %$24], [%95, %$26] ; # N
  %109 = phi i8* [%89, %$24], [%96, %$26] ; # Cld
; # (ofs Cld (child T))
  %110 = getelementptr i8, i8* %109, i32 32
  br label %$23
$25:
  %111 = phi i32 [%82, %$23] ; # I
  %112 = phi i32 [%85, %$23] ; # N
  %113 = phi i8* [%84, %$23] ; # Cld
; # (set $Children 0)
  store i32 0, i32* @$Children
; # (val $Child)
  %114 = load i8*, i8** @$Child
; # (free (val $Child))
  call void @free(i8* %114)
; # (set $Child null)
  store i8* null, i8** @$Child
; # (let In (val $InFrames) (while In (let In: (ioFrame In) (when (In...
; # (val $InFrames)
  %115 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 40) to i8**)
; # (while In (let In: (ioFrame In) (when (In: file) (In: pid 0)) (se...
  br label %$28
$28:
  %116 = phi i32 [%111, %$25], [%132, %$32] ; # I
  %117 = phi i32 [%112, %$25], [%133, %$32] ; # N
  %118 = phi i8* [%115, %$25], [%136, %$32] ; # In
  %119 = icmp ne i8* %118, null
  br i1 %119, label %$29, label %$30
$29:
  %120 = phi i32 [%116, %$28] ; # I
  %121 = phi i32 [%117, %$28] ; # N
  %122 = phi i8* [%118, %$28] ; # In
; # (let In: (ioFrame In) (when (In: file) (In: pid 0)) (setq In (In:...
; # (when (In: file) (In: pid 0))
; # (In: file)
  %123 = getelementptr i8, i8* %122, i32 8
  %124 = bitcast i8* %123 to i8**
  %125 = load i8*, i8** %124
  %126 = icmp ne i8* %125, null
  br i1 %126, label %$31, label %$32
$31:
  %127 = phi i32 [%120, %$29] ; # I
  %128 = phi i32 [%121, %$29] ; # N
  %129 = phi i8* [%122, %$29] ; # In
; # (In: pid 0)
  %130 = getelementptr i8, i8* %122, i32 24
  %131 = bitcast i8* %130 to i32*
  store i32 0, i32* %131
  br label %$32
$32:
  %132 = phi i32 [%120, %$29], [%127, %$31] ; # I
  %133 = phi i32 [%121, %$29], [%128, %$31] ; # N
  %134 = phi i8* [%122, %$29], [%129, %$31] ; # In
; # (In: link)
  %135 = bitcast i8* %122 to i8**
  %136 = load i8*, i8** %135
  br label %$28
$30:
  %137 = phi i32 [%116, %$28] ; # I
  %138 = phi i32 [%117, %$28] ; # N
  %139 = phi i8* [%118, %$28] ; # In
; # (let Out (val $OutFrames) (while Out (let Out: (ioFrame Out) (whe...
; # (val $OutFrames)
  %140 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 48) to i8**)
; # (while Out (let Out: (ioFrame Out) (when (Out: file) (Out: pid 0)...
  br label %$33
$33:
  %141 = phi i32 [%137, %$30], [%157, %$37] ; # I
  %142 = phi i32 [%138, %$30], [%158, %$37] ; # N
  %143 = phi i8* [%140, %$30], [%161, %$37] ; # Out
  %144 = icmp ne i8* %143, null
  br i1 %144, label %$34, label %$35
$34:
  %145 = phi i32 [%141, %$33] ; # I
  %146 = phi i32 [%142, %$33] ; # N
  %147 = phi i8* [%143, %$33] ; # Out
; # (let Out: (ioFrame Out) (when (Out: file) (Out: pid 0)) (setq Out...
; # (when (Out: file) (Out: pid 0))
; # (Out: file)
  %148 = getelementptr i8, i8* %147, i32 8
  %149 = bitcast i8* %148 to i8**
  %150 = load i8*, i8** %149
  %151 = icmp ne i8* %150, null
  br i1 %151, label %$36, label %$37
$36:
  %152 = phi i32 [%145, %$34] ; # I
  %153 = phi i32 [%146, %$34] ; # N
  %154 = phi i8* [%147, %$34] ; # Out
; # (Out: pid 0)
  %155 = getelementptr i8, i8* %147, i32 24
  %156 = bitcast i8* %155 to i32*
  store i32 0, i32* %156
  br label %$37
$37:
  %157 = phi i32 [%145, %$34], [%152, %$36] ; # I
  %158 = phi i32 [%146, %$34], [%153, %$36] ; # N
  %159 = phi i8* [%147, %$34], [%154, %$36] ; # Out
; # (Out: link)
  %160 = bitcast i8* %147 to i8**
  %161 = load i8*, i8** %160
  br label %$33
$35:
  %162 = phi i32 [%141, %$33] ; # I
  %163 = phi i32 [%142, %$33] ; # N
  %164 = phi i8* [%143, %$33] ; # Out
; # (let Ca (val $Catch) (while Ca (let Ca: (caFrame Ca) (Ca: fin ZER...
; # (val $Catch)
  %165 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 32) to i8**)
; # (while Ca (let Ca: (caFrame Ca) (Ca: fin ZERO) (setq Ca (Ca: link...
  br label %$38
$38:
  %166 = phi i32 [%162, %$35], [%170, %$39] ; # I
  %167 = phi i32 [%163, %$35], [%171, %$39] ; # N
  %168 = phi i8* [%165, %$35], [%177, %$39] ; # Ca
  %169 = icmp ne i8* %168, null
  br i1 %169, label %$39, label %$40
$39:
  %170 = phi i32 [%166, %$38] ; # I
  %171 = phi i32 [%167, %$38] ; # N
  %172 = phi i8* [%168, %$38] ; # Ca
; # (let Ca: (caFrame Ca) (Ca: fin ZERO) (setq Ca (Ca: link)))
; # (Ca: fin ZERO)
  %173 = getelementptr i8, i8* %172, i32 16
  %174 = ptrtoint i8* %173 to i64
  %175 = inttoptr i64 %174 to i64*
  store i64 2, i64* %175
; # (Ca: link)
  %176 = bitcast i8* %172 to i8**
  %177 = load i8*, i8** %176
  br label %$38
$40:
  %178 = phi i32 [%166, %$38] ; # I
  %179 = phi i32 [%167, %$38] ; # N
  %180 = phi i8* [%168, %$38] ; # Ca
; # (let R (val $Run) (while (pair R) (let X (++ R) (unless (sign? (c...
; # (val $Run)
  %181 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 600) to i64) to i64*
  %182 = load i64, i64* %181
; # (while (pair R) (let X (++ R) (unless (sign? (car X)) (let Fd (i3...
  br label %$41
$41:
  %183 = phi i32 [%178, %$40], [%205, %$45] ; # I
  %184 = phi i32 [%179, %$40], [%206, %$45] ; # N
  %185 = phi i64 [%182, %$40], [%207, %$45] ; # R
; # (pair R)
  %186 = and i64 %185, 15
  %187 = icmp eq i64 %186, 0
  br i1 %187, label %$42, label %$43
$42:
  %188 = phi i32 [%183, %$41] ; # I
  %189 = phi i32 [%184, %$41] ; # N
  %190 = phi i64 [%185, %$41] ; # R
; # (let X (++ R) (unless (sign? (car X)) (let Fd (i32 (int @)) (clos...
; # (++ R)
  %191 = inttoptr i64 %190 to i64*
  %192 = load i64, i64* %191
  %193 = getelementptr i64, i64* %191, i32 1
  %194 = load i64, i64* %193
; # (unless (sign? (car X)) (let Fd (i32 (int @)) (close Fd) (closeIn...
; # (car X)
  %195 = inttoptr i64 %192 to i64*
  %196 = load i64, i64* %195
; # (sign? (car X))
  %197 = and i64 %196, 8
  %198 = icmp ne i64 %197, 0
  br i1 %198, label %$45, label %$44
$44:
  %199 = phi i32 [%188, %$42] ; # I
  %200 = phi i32 [%189, %$42] ; # N
  %201 = phi i64 [%194, %$42] ; # R
; # (let Fd (i32 (int @)) (close Fd) (closeInFile Fd) (closeOutFile F...
; # (int @)
  %202 = lshr i64 %196, 4
; # (i32 (int @))
  %203 = trunc i64 %202 to i32
; # (close Fd)
  %204 = call i32 @close(i32 %203)
; # (closeInFile Fd)
  call void @closeInFile(i32 %203)
; # (closeOutFile Fd)
  call void @closeOutFile(i32 %203)
  br label %$45
$45:
  %205 = phi i32 [%188, %$42], [%199, %$44] ; # I
  %206 = phi i32 [%189, %$42], [%200, %$44] ; # N
  %207 = phi i64 [%194, %$42], [%201, %$44] ; # R
  br label %$41
$43:
  %208 = phi i32 [%183, %$41] ; # I
  %209 = phi i32 [%184, %$41] ; # N
  %210 = phi i64 [%185, %$41] ; # R
; # (set $Bye $Nil)
  %211 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 808) to i64) to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %211
; # (set $Run $Nil)
  %212 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 600) to i64) to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %212
; # (val Termio)
  %213 = load i8*, i8** @Termio
; # (free (val Termio))
  call void @free(i8* %213)
; # (set Termio null)
  store i8* null, i8** @Termio
; # (set $PRepl (val $Repl) $PPid (val $Pid))
; # (val $Repl)
  %214 = load i1, i1* @$Repl
  store i1 %214, i1* @$PRepl
; # (val $Pid)
  %215 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 200) to i64) to i64*
  %216 = load i64, i64* %215
  %217 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 216) to i64) to i64*
  store i64 %216, i64* %217
; # (set $Pid (cnt (i64 (getpid))))
; # (getpid)
  %218 = call i32 @getpid()
; # (i64 (getpid))
  %219 = sext i32 %218 to i64
; # (cnt (i64 (getpid)))
  %220 = shl i64 %219, 4
  %221 = or i64 %220, 2
  %222 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 200) to i64) to i64*
  store i64 %221, i64* %222
; # (val $Fork)
  %223 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 792) to i64) to i64*
  %224 = load i64, i64* %223
; # (execAt (val $Fork))
  %225 = call i64 @execAt(i64 %224)
; # (set $Fork $Nil)
  %226 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 792) to i64) to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %226
  br label %$14
$17:
  %227 = phi i32 [%46, %$15] ; # I
  %228 = phi i32 [%47, %$15] ; # N
; # (let Pid @ (when (== I N) (set $Children (inc 'N 8)) (let P (set ...
; # (when (== I N) (set $Children (inc 'N 8)) (let P (set $Child (all...
; # (== I N)
  %229 = icmp eq i32 %227, %228
  br i1 %229, label %$46, label %$47
$46:
  %230 = phi i32 [%227, %$17] ; # I
  %231 = phi i32 [%228, %$17] ; # N
; # (set $Children (inc 'N 8))
; # (inc 'N 8)
  %232 = add i32 %231, 8
  store i32 %232, i32* @$Children
; # (let P (set $Child (alloc (val $Child) (i64 (* N (child T))))) (l...
; # (set $Child (alloc (val $Child) (i64 (* N (child T)))))
; # (val $Child)
  %233 = load i8*, i8** @$Child
; # (* N (child T))
  %234 = mul i32 %232, 32
; # (i64 (* N (child T)))
  %235 = sext i32 %234 to i64
; # (alloc (val $Child) (i64 (* N (child T))))
  %236 = call i8* @alloc(i8* %233, i64 %235)
  store i8* %236, i8** @$Child
; # (let Cld (ofs P (* I (child T))) (loop ((child Cld) pid 0) (? (==...
; # (* I (child T))
  %237 = mul i32 %230, 32
; # (ofs P (* I (child T)))
  %238 = getelementptr i8, i8* %236, i32 %237
; # (loop ((child Cld) pid 0) (? (== I (dec 'N))) (setq Cld (ofs Cld ...
  br label %$48
$48:
  %239 = phi i32 [%230, %$46], [%246, %$49] ; # I
  %240 = phi i32 [%232, %$46], [%247, %$49] ; # N
  %241 = phi i8* [%238, %$46], [%249, %$49] ; # Cld
; # ((child Cld) pid 0)
  %242 = getelementptr i8, i8* %241, i32 16
  %243 = bitcast i8* %242 to i32*
  store i32 0, i32* %243
; # (? (== I (dec 'N)))
; # (dec 'N)
  %244 = sub i32 %240, 1
; # (== I (dec 'N))
  %245 = icmp eq i32 %239, %244
  br i1 %245, label %$50, label %$49
$49:
  %246 = phi i32 [%239, %$48] ; # I
  %247 = phi i32 [%244, %$48] ; # N
  %248 = phi i8* [%241, %$48] ; # Cld
; # (ofs Cld (child T))
  %249 = getelementptr i8, i8* %248, i32 32
  br label %$48
$50:
  %250 = phi i32 [%239, %$48] ; # I
  %251 = phi i32 [%244, %$48] ; # N
  %252 = phi i8* [%241, %$48] ; # Cld
  %253 = phi i64 [0, %$48] ; # ->
  br label %$47
$47:
  %254 = phi i32 [%227, %$17], [%250, %$50] ; # I
  %255 = phi i32 [%228, %$17], [%251, %$50] ; # N
; # (val Hear)
  %256 = load i32, i32* %8
; # (close (val Hear))
  %257 = call i32 @close(i32 %256)
; # (val 2 Tell)
  %258 = getelementptr i32, i32* %9, i32 1
  %259 = load i32, i32* %258
; # (close (val 2 Tell))
  %260 = call i32 @close(i32 %259)
; # (let Cld: (child (ofs (val $Child) (* I (child T)))) (Cld: buf nu...
; # (val $Child)
  %261 = load i8*, i8** @$Child
; # (* I (child T))
  %262 = mul i32 %254, 32
; # (ofs (val $Child) (* I (child T)))
  %263 = getelementptr i8, i8* %261, i32 %262
; # (Cld: buf null)
  %264 = bitcast i8* %263 to i8**
  store i8* null, i8** %264
; # (Cld: ofs (Cld: cnt 0))
  %265 = getelementptr i8, i8* %263, i32 8
  %266 = bitcast i8* %265 to i32*
  %267 = getelementptr i8, i8* %263, i32 12
  %268 = bitcast i8* %267 to i32*
  store i32 0, i32* %268
  store i32 0, i32* %266
; # (Cld: pid Pid)
  %269 = getelementptr i8, i8* %263, i32 16
  %270 = bitcast i8* %269 to i32*
  store i32 %42, i32* %270
; # (Cld: hear (val Tell))
  %271 = getelementptr i8, i8* %263, i32 20
  %272 = bitcast i8* %271 to i32*
  %273 = load i32, i32* %9
  store i32 %273, i32* %272
; # (Cld: tell (val 2 Hear))
  %274 = getelementptr i8, i8* %263, i32 24
  %275 = bitcast i8* %274 to i32*
  %276 = getelementptr i32, i32* %8, i32 1
  %277 = load i32, i32* %276
  store i32 %277, i32* %275
; # (nonBlocking (Cld: tell (val 2 Hear)))
  %278 = call i32 @nonBlocking(i32 %277)
  br label %$14
$14:
  %279 = phi i32 [%208, %$43], [%254, %$47] ; # I
  %280 = phi i32 [%209, %$43], [%255, %$47] ; # N
  %281 = phi i32 [0, %$43], [%42, %$47] ; # ->
  ret i32 %281
}

define i64 @_Pipe(i64) align 8 {
$1:
; # (let (X (cdr Exe) E (++ X) Pfd (b32 2) Io: (ioFrame (b8+ (ioFrame...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (b32 2)
  %8 = alloca i32, i64 2
; # (b8+ (ioFrame T))
  %9 = alloca i8, i64 28, align 8
; # (when (lt0 (if (pair X) (pipe Pfd) (socketPair Pfd))) (pipeErr Ex...
; # (if (pair X) (pipe Pfd) (socketPair Pfd))
; # (pair X)
  %10 = and i64 %7, 15
  %11 = icmp eq i64 %10, 0
  br i1 %11, label %$2, label %$3
$2:
; # (pipe Pfd)
  %12 = call i32 @pipe(i32* %8)
  br label %$4
$3:
; # (socketPair Pfd)
  %13 = call i32 @socketPair(i32* %8)
  br label %$4
$4:
  %14 = phi i32 [%12, %$2], [%13, %$3] ; # ->
; # (lt0 (if (pair X) (pipe Pfd) (socketPair Pfd)))
  %15 = icmp slt i32 %14, 0
  br i1 %15, label %$5, label %$6
$5:
; # (pipeErr Exe)
  call void @pipeErr(i64 %0)
  unreachable
$6:
; # (when (< (val 2 Pfd) 2) (pipeErr Exe))
; # (val 2 Pfd)
  %16 = getelementptr i32, i32* %8, i32 1
  %17 = load i32, i32* %16
; # (< (val 2 Pfd) 2)
  %18 = icmp slt i32 %17, 2
  br i1 %18, label %$7, label %$8
$7:
; # (pipeErr Exe)
  call void @pipeErr(i64 %0)
  unreachable
$8:
; # (if (forkLisp Exe) (let Pid @ (close (val 2 Pfd)) (let Fd (val Pf...
; # (forkLisp Exe)
  %19 = call i32 @forkLisp(i64 %0)
  %20 = icmp ne i32 %19, 0
  br i1 %20, label %$9, label %$10
$9:
; # (let Pid @ (close (val 2 Pfd)) (let Fd (val Pfd) (closeOnExec Exe...
; # (val 2 Pfd)
  %21 = getelementptr i32, i32* %8, i32 1
  %22 = load i32, i32* %21
; # (close (val 2 Pfd))
  %23 = call i32 @close(i32 %22)
; # (let Fd (val Pfd) (closeOnExec Exe Fd) (cond ((atom X) (initInFil...
; # (val Pfd)
  %24 = load i32, i32* %8
; # (closeOnExec Exe Fd)
  call void @closeOnExec(i64 %0, i32 %24)
; # (cond ((atom X) (initInFile Fd null) (initOutFile Fd) (cnt (i64 F...
; # (atom X)
  %25 = and i64 %7, 15
  %26 = icmp ne i64 %25, 0
  br i1 %26, label %$14, label %$13
$14:
; # (initInFile Fd null)
  %27 = call i8* @initInFile(i32 %24, i8* null)
; # (initOutFile Fd)
  %28 = call i8* @initOutFile(i32 %24)
; # (i64 Fd)
  %29 = sext i32 %24 to i64
; # (cnt (i64 Fd))
  %30 = shl i64 %29, 4
  %31 = or i64 %30, 2
  br label %$12
$13:
; # (setpgid Pid 0)
  %32 = call i32 @setpgid(i32 %19, i32 0)
; # (Io:)
; # (initInFile Fd null)
  %33 = call i8* @initInFile(i32 %24, i8* null)
; # (pushInFile (Io:) (initInFile Fd null) Pid)
  call void @pushInFile(i8* %9, i8* %33, i32 %19)
; # (prog1 (run X) (popInFiles))
; # (run X)
  br label %$15
$15:
  %34 = phi i64 [%7, %$13], [%56, %$24] ; # Prg
  %35 = inttoptr i64 %34 to i64*
  %36 = load i64, i64* %35
  %37 = getelementptr i64, i64* %35, i32 1
  %38 = load i64, i64* %37
  %39 = and i64 %38, 15
  %40 = icmp ne i64 %39, 0
  br i1 %40, label %$18, label %$16
$18:
  %41 = phi i64 [%38, %$15] ; # Prg
  %42 = and i64 %36, 6
  %43 = icmp ne i64 %42, 0
  br i1 %43, label %$21, label %$20
$21:
  br label %$19
$20:
  %44 = and i64 %36, 8
  %45 = icmp ne i64 %44, 0
  br i1 %45, label %$23, label %$22
$23:
  %46 = inttoptr i64 %36 to i64*
  %47 = load i64, i64* %46
  br label %$19
$22:
  %48 = call i64 @evList(i64 %36)
  br label %$19
$19:
  %49 = phi i64 [%36, %$21], [%47, %$23], [%48, %$22] ; # ->
  br label %$17
$16:
  %50 = phi i64 [%38, %$15] ; # Prg
  %51 = and i64 %36, 15
  %52 = icmp eq i64 %51, 0
  br i1 %52, label %$25, label %$24
$25:
  %53 = phi i64 [%50, %$16] ; # Prg
  %54 = call i64 @evList(i64 %36)
  %55 = icmp ne i64 %54, 0
  br label %$24
$24:
  %56 = phi i64 [%50, %$16], [%53, %$25] ; # Prg
  %57 = phi i1 [0, %$16], [%55, %$25] ; # ->
  br label %$15
$17:
  %58 = phi i64 [%41, %$19] ; # Prg
  %59 = phi i64 [%49, %$19] ; # ->
; # (popInFiles)
  call void @popInFiles()
  br label %$12
$12:
  %60 = phi i64 [%31, %$14], [%59, %$17] ; # ->
  br label %$11
$10:
; # (val Pfd)
  %61 = load i32, i32* %8
; # (close (val Pfd))
  %62 = call i32 @close(i32 %61)
; # (let Fd (val 2 Pfd) (if (pair X) (setpgid 0 0) (dup2 Fd 0) ((inFi...
; # (val 2 Pfd)
  %63 = getelementptr i32, i32* %8, i32 1
  %64 = load i32, i32* %63
; # (if (pair X) (setpgid 0 0) (dup2 Fd 0) ((inFile (val (val $InFile...
; # (pair X)
  %65 = and i64 %7, 15
  %66 = icmp eq i64 %65, 0
  br i1 %66, label %$26, label %$27
$26:
; # (setpgid 0 0)
  %67 = call i32 @setpgid(i32 0, i32 0)
  br label %$28
$27:
; # (dup2 Fd 0)
  %68 = call i32 @dup2(i32 %64, i32 0)
; # (val $InFiles)
  %69 = load i8**, i8*** @$InFiles
; # (val (val $InFiles))
  %70 = load i8*, i8** %69
; # ((inFile (val (val $InFiles))) tty NO)
  %71 = getelementptr i8, i8* %70, i32 4128
  %72 = bitcast i8* %71 to i1*
  store i1 0, i1* %72
  br label %$28
$28:
; # (dup2 Fd 1)
  %73 = call i32 @dup2(i32 %64, i32 1)
; # (close Fd)
  %74 = call i32 @close(i32 %64)
; # (val SIGPIPE Sig)
  %75 = getelementptr i32, i32* @Sig, i32 4
  %76 = load i32, i32* %75
; # (val SigDfl)
  %77 = load i8*, i8** @SigDfl
; # (signal (val SIGPIPE Sig) (val SigDfl))
  %78 = call i8* @signal(i32 %76, i8* %77)
; # (val $OutFile)
  %79 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 80) to i8**)
; # ((outFile (val $OutFile)) tty NO)
  %80 = getelementptr i8, i8* %79, i32 4104
  %81 = bitcast i8* %80 to i1*
  store i1 0, i1* %81
; # (Io:)
; # (val $OutFiles)
  %82 = load i8**, i8*** @$OutFiles
; # (val 2 (val $OutFiles))
  %83 = getelementptr i8*, i8** %82, i32 1
  %84 = load i8*, i8** %83
; # (pushOutFile (Io:) (val 2 (val $OutFiles)) 0)
  call void @pushOutFile(i8* %9, i8* %84, i32 0)
; # (set $LinePtr null)
  store i8* null, i8** @$LinePtr
; # (when (pair E) (evList E))
; # (pair E)
  %85 = and i64 %5, 15
  %86 = icmp eq i64 %85, 0
  br i1 %86, label %$29, label %$30
$29:
; # (evList E)
  %87 = call i64 @evList(i64 %5)
  br label %$30
$30:
; # (bye 0)
  call void @bye(i32 0)
  unreachable
$11:
  %88 = phi i64 [%60, %$12] ; # ->
  ret i64 %88
}

define i64 @_Open(i64) align 8 {
$1:
; # (let (X (cdr Exe) Nm (xName (evSym X)) S (pathString Nm (b8 (path...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (evSym X)
  %4 = call i64 @evSym(i64 %3)
; # (xName (evSym X))
  %5 = call i64 @xName(i64 %4)
; # (pathSize Nm)
  %6 = call i64 @pathSize(i64 %5)
; # (b8 (pathSize Nm))
  %7 = alloca i8, i64 %6
; # (pathString Nm (b8 (pathSize Nm)))
  %8 = call i8* @pathString(i64 %5, i8* %7)
; # (cadr X)
  %9 = inttoptr i64 %3 to i64*
  %10 = getelementptr i64, i64* %9, i32 1
  %11 = load i64, i64* %10
  %12 = inttoptr i64 %11 to i64*
  %13 = load i64, i64* %12
; # (eval (cadr X))
  %14 = and i64 %13, 6
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$4, label %$3
$4:
  br label %$2
$3:
  %16 = and i64 %13, 8
  %17 = icmp ne i64 %16, 0
  br i1 %17, label %$6, label %$5
$6:
  %18 = inttoptr i64 %13 to i64*
  %19 = load i64, i64* %18
  br label %$2
$5:
  %20 = call i64 @evList(i64 %13)
  br label %$2
$2:
  %21 = phi i64 [%13, %$4], [%19, %$6], [%20, %$5] ; # ->
; # (nil? (eval (cadr X)))
  %22 = icmp eq i64 %21, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
; # (loop (? (ge0 (if Flg (openRdWrCreate S) (openRd S))) (closeOnExe...
  br label %$7
$7:
; # (? (ge0 (if Flg (openRdWrCreate S) (openRd S))) (closeOnExec Exe ...
; # (if Flg (openRdWrCreate S) (openRd S))
  br i1 %22, label %$8, label %$9
$8:
; # (openRdWrCreate S)
  %23 = call i32 @openRdWrCreate(i8* %8)
  br label %$10
$9:
; # (openRd S)
  %24 = call i32 @openRd(i8* %8)
  br label %$10
$10:
  %25 = phi i32 [%23, %$8], [%24, %$9] ; # ->
; # (ge0 (if Flg (openRdWrCreate S) (openRd S)))
  %26 = icmp sge i32 %25, 0
  br i1 %26, label %$13, label %$11
$13:
; # (closeOnExec Exe @)
  call void @closeOnExec(i64 %0, i32 %25)
; # (strdup S)
  %27 = call i8* @strdup(i8* %8)
; # (initInFile @ (strdup S))
  %28 = call i8* @initInFile(i32 %25, i8* %27)
; # (initOutFile @)
  %29 = call i8* @initOutFile(i32 %25)
; # (i64 @)
  %30 = sext i32 %25 to i64
; # (cnt (i64 @))
  %31 = shl i64 %30, 4
  %32 = or i64 %31, 2
  br label %$12
$11:
; # (? (<> (gErrno) EINTR) $Nil)
; # (gErrno)
  %33 = call i32 @gErrno()
; # (<> (gErrno) EINTR)
  %34 = icmp ne i32 %33, 2
  br i1 %34, label %$15, label %$14
$15:
  br label %$12
$14:
; # (sigChk Exe)
  %35 = load volatile i32, i32* bitcast ([16 x i32]* @$Signal to i32*)
  %36 = icmp ne i32 %35, 0
  br i1 %36, label %$16, label %$17
$16:
  call void @sighandler(i64 %0)
  br label %$17
$17:
  br label %$7
$12:
  %37 = phi i64 [%32, %$13], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$15] ; # ->
  ret i64 %37
}

define i64 @_Close(i64) align 8 {
$1:
; # (let (X (eval (cadr Exe)) Fd (i32 (xCnt Exe X))) (loop (? (=0 (cl...
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (xCnt Exe X)
  %14 = call i64 @xCnt(i64 %0, i64 %13)
; # (i32 (xCnt Exe X))
  %15 = trunc i64 %14 to i32
; # (loop (? (=0 (close Fd)) (closeInFile Fd) (closeOutFile Fd) X) (?...
  br label %$7
$7:
; # (? (=0 (close Fd)) (closeInFile Fd) (closeOutFile Fd) X)
; # (close Fd)
  %16 = call i32 @close(i32 %15)
; # (=0 (close Fd))
  %17 = icmp eq i32 %16, 0
  br i1 %17, label %$10, label %$8
$10:
; # (closeInFile Fd)
  call void @closeInFile(i32 %15)
; # (closeOutFile Fd)
  call void @closeOutFile(i32 %15)
  br label %$9
$8:
; # (? (<> (gErrno) EINTR) $Nil)
; # (gErrno)
  %18 = call i32 @gErrno()
; # (<> (gErrno) EINTR)
  %19 = icmp ne i32 %18, 2
  br i1 %19, label %$12, label %$11
$12:
  br label %$9
$11:
; # (sigChk Exe)
  %20 = load volatile i32, i32* bitcast ([16 x i32]* @$Signal to i32*)
  %21 = icmp ne i32 %20, 0
  br i1 %21, label %$13, label %$14
$13:
  call void @sighandler(i64 %0)
  br label %$14
$14:
  br label %$7
$9:
  %22 = phi i64 [%13, %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$12] ; # ->
  ret i64 %22
}

define i64 @_Echo(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (eval (++ X))) (cond ((and (nil? Y) (atom X))...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (cond ((and (nil? Y) (atom X)) (let C (if (val $Chr) @ (call $Get...
; # (and (nil? Y) (atom X))
; # (nil? Y)
  %16 = icmp eq i64 %15, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %16, label %$9, label %$8
$9:
  %17 = phi i64 [%7, %$2] ; # X
  %18 = phi i64 [%15, %$2] ; # Y
; # (atom X)
  %19 = and i64 %17, 15
  %20 = icmp ne i64 %19, 0
  br label %$8
$8:
  %21 = phi i64 [%7, %$2], [%17, %$9] ; # X
  %22 = phi i64 [%15, %$2], [%18, %$9] ; # Y
  %23 = phi i1 [0, %$2], [%20, %$9] ; # ->
  br i1 %23, label %$11, label %$10
$11:
  %24 = phi i64 [%21, %$8] ; # X
  %25 = phi i64 [%22, %$8] ; # Y
; # (let C (if (val $Chr) @ (call $Get)) (until (lt0 C) (call $Put (i...
; # (if (val $Chr) @ (call $Get))
; # (val $Chr)
  %26 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
  %27 = icmp ne i32 %26, 0
  br i1 %27, label %$12, label %$13
$12:
  %28 = phi i64 [%24, %$11] ; # X
  %29 = phi i64 [%25, %$11] ; # Y
  br label %$14
$13:
  %30 = phi i64 [%24, %$11] ; # X
  %31 = phi i64 [%25, %$11] ; # Y
; # (call $Get)
  %32 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %33 = call i32 %32()
  br label %$14
$14:
  %34 = phi i64 [%28, %$12], [%30, %$13] ; # X
  %35 = phi i64 [%29, %$12], [%31, %$13] ; # Y
  %36 = phi i32 [%26, %$12], [%33, %$13] ; # ->
; # (until (lt0 C) (call $Put (i8 C)) (setq C (call $Get)))
  br label %$15
$15:
  %37 = phi i64 [%34, %$14], [%41, %$16] ; # X
  %38 = phi i64 [%35, %$14], [%42, %$16] ; # Y
  %39 = phi i32 [%36, %$14], [%47, %$16] ; # C
; # (lt0 C)
  %40 = icmp slt i32 %39, 0
  br i1 %40, label %$17, label %$16
$16:
  %41 = phi i64 [%37, %$15] ; # X
  %42 = phi i64 [%38, %$15] ; # Y
  %43 = phi i32 [%39, %$15] ; # C
; # (i8 C)
  %44 = trunc i32 %43 to i8
; # (call $Put (i8 C))
  %45 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %45(i8 %44)
; # (call $Get)
  %46 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %47 = call i32 %46()
  br label %$15
$17:
  %48 = phi i64 [%37, %$15] ; # X
  %49 = phi i64 [%38, %$15] ; # Y
  %50 = phi i32 [%39, %$15] ; # C
  br label %$7
$10:
  %51 = phi i64 [%21, %$8] ; # X
  %52 = phi i64 [%22, %$8] ; # Y
; # (num? Y)
  %53 = and i64 %52, 6
  %54 = icmp ne i64 %53, 0
  br i1 %54, label %$19, label %$18
$19:
  %55 = phi i64 [%51, %$10] ; # X
  %56 = phi i64 [%52, %$10] ; # Y
; # (let N (xCnt Exe Y) (when (pair X) (let C (evCnt Exe X) (while (g...
; # (xCnt Exe Y)
  %57 = call i64 @xCnt(i64 %0, i64 %56)
; # (when (pair X) (let C (evCnt Exe X) (while (ge0 (dec 'N)) (when (...
; # (pair X)
  %58 = and i64 %55, 15
  %59 = icmp eq i64 %58, 0
  br i1 %59, label %$20, label %$21
$20:
  %60 = phi i64 [%55, %$19] ; # X
  %61 = phi i64 [%56, %$19] ; # Y
  %62 = phi i64 [%57, %$19] ; # N
; # (let C (evCnt Exe X) (while (ge0 (dec 'N)) (when (lt0 (call $Get)...
; # (evCnt Exe X)
  %63 = call i64 @evCnt(i64 %0, i64 %60)
; # (while (ge0 (dec 'N)) (when (lt0 (call $Get)) (ret $Nil)))
  br label %$22
$22:
  %64 = phi i64 [%60, %$20], [%78, %$26] ; # X
  %65 = phi i64 [%61, %$20], [%79, %$26] ; # Y
  %66 = phi i64 [%62, %$20], [%80, %$26] ; # N
; # (dec 'N)
  %67 = sub i64 %66, 1
; # (ge0 (dec 'N))
  %68 = icmp sge i64 %67, 0
  br i1 %68, label %$23, label %$24
$23:
  %69 = phi i64 [%64, %$22] ; # X
  %70 = phi i64 [%65, %$22] ; # Y
  %71 = phi i64 [%67, %$22] ; # N
; # (when (lt0 (call $Get)) (ret $Nil))
; # (call $Get)
  %72 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %73 = call i32 %72()
; # (lt0 (call $Get))
  %74 = icmp slt i32 %73, 0
  br i1 %74, label %$25, label %$26
$25:
  %75 = phi i64 [%69, %$23] ; # X
  %76 = phi i64 [%70, %$23] ; # Y
  %77 = phi i64 [%71, %$23] ; # N
; # (ret $Nil)
  ret i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
$26:
  %78 = phi i64 [%69, %$23] ; # X
  %79 = phi i64 [%70, %$23] ; # Y
  %80 = phi i64 [%71, %$23] ; # N
  br label %$22
$24:
  %81 = phi i64 [%64, %$22] ; # X
  %82 = phi i64 [%65, %$22] ; # Y
  %83 = phi i64 [%67, %$22] ; # N
  br label %$21
$21:
  %84 = phi i64 [%55, %$19], [%81, %$24] ; # X
  %85 = phi i64 [%56, %$19], [%82, %$24] ; # Y
  %86 = phi i64 [%57, %$19], [%63, %$24] ; # N
; # (while (ge0 (dec 'N)) (when (lt0 (call $Get)) (ret $Nil)) (call $...
  br label %$27
$27:
  %87 = phi i64 [%84, %$21], [%101, %$31] ; # X
  %88 = phi i64 [%85, %$21], [%102, %$31] ; # Y
  %89 = phi i64 [%86, %$21], [%103, %$31] ; # N
; # (dec 'N)
  %90 = sub i64 %89, 1
; # (ge0 (dec 'N))
  %91 = icmp sge i64 %90, 0
  br i1 %91, label %$28, label %$29
$28:
  %92 = phi i64 [%87, %$27] ; # X
  %93 = phi i64 [%88, %$27] ; # Y
  %94 = phi i64 [%90, %$27] ; # N
; # (when (lt0 (call $Get)) (ret $Nil))
; # (call $Get)
  %95 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %96 = call i32 %95()
; # (lt0 (call $Get))
  %97 = icmp slt i32 %96, 0
  br i1 %97, label %$30, label %$31
$30:
  %98 = phi i64 [%92, %$28] ; # X
  %99 = phi i64 [%93, %$28] ; # Y
  %100 = phi i64 [%94, %$28] ; # N
; # (ret $Nil)
  ret i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
$31:
  %101 = phi i64 [%92, %$28] ; # X
  %102 = phi i64 [%93, %$28] ; # Y
  %103 = phi i64 [%94, %$28] ; # N
; # (i8 @)
  %104 = trunc i32 %96 to i8
; # (call $Put (i8 @))
  %105 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %105(i8 %104)
  br label %$27
$29:
  %106 = phi i64 [%87, %$27] ; # X
  %107 = phi i64 [%88, %$27] ; # Y
  %108 = phi i64 [%90, %$27] ; # N
; # (set $Chr 0)
  store i32 0, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
  br label %$7
$18:
  %109 = phi i64 [%51, %$10] ; # X
  %110 = phi i64 [%52, %$10] ; # Y
; # (pair Y)
  %111 = and i64 %110, 15
  %112 = icmp eq i64 %111, 0
  br i1 %112, label %$33, label %$32
$33:
  %113 = phi i64 [%109, %$18] ; # X
  %114 = phi i64 [%110, %$18] ; # Y
; # (argErr Exe Y)
  call void @argErr(i64 %0, i64 %114)
  unreachable
$32:
  %115 = phi i64 [%109, %$18] ; # X
  %116 = phi i64 [%110, %$18] ; # Y
; # (let (M (i64* null) N 1 Nm (xName Y) L (link (push Y NIL 0 (any (...
; # (i64* null)
  %117 = inttoptr i64 0 to i64*
; # (xName Y)
  %118 = call i64 @xName(i64 %116)
; # (bufSize Nm)
  %119 = call i64 @bufSize(i64 %118)
; # (b8 (bufSize Nm))
  %120 = alloca i8, i64 %119
; # (bufString Nm (b8 (bufSize Nm)))
  %121 = call i8* @bufString(i64 %118, i8* %120)
; # (any (bufString Nm (b8 (bufSize Nm))))
  %122 = ptrtoint i8* %121 to i64
; # (push Y NIL 0 (any (bufString Nm (b8 (bufSize Nm)))))
  %123 = alloca i64, i64 4, align 16
  %124 = ptrtoint i64* %123 to i64
  %125 = inttoptr i64 %124 to i64*
  store i64 %116, i64* %125
  %126 = add i64 %124, 16
  %127 = inttoptr i64 %126 to i64*
  store i64 0, i64* %127
  %128 = add i64 %124, 24
  %129 = inttoptr i64 %128 to i64*
  store i64 %122, i64* %129
; # (link (push Y NIL 0 (any (bufString Nm (b8 (bufSize Nm))))))
  %130 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %131 = load i64, i64* %130
  %132 = inttoptr i64 %124 to i64*
  %133 = getelementptr i64, i64* %132, i32 1
  store i64 %131, i64* %133
  %134 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %124, i64* %134
; # (while (pair X) (setq Y (evSym (++ X)) Nm (xName Y) L (link (push...
  br label %$34
$34:
  %135 = phi i64 [%115, %$32], [%152, %$35] ; # X
  %136 = phi i64 [%116, %$32], [%153, %$35] ; # Y
  %137 = phi i64* [%117, %$32], [%145, %$35] ; # M
  %138 = phi i64 [1, %$32], [%171, %$35] ; # N
  %139 = phi i64 [%118, %$32], [%154, %$35] ; # Nm
  %140 = phi i64 [%124, %$32], [%160, %$35] ; # L
; # (pair X)
  %141 = and i64 %135, 15
  %142 = icmp eq i64 %141, 0
  br i1 %142, label %$35, label %$36
$35:
  %143 = phi i64 [%135, %$34] ; # X
  %144 = phi i64 [%136, %$34] ; # Y
  %145 = phi i64* [%137, %$34] ; # M
  %146 = phi i64 [%138, %$34] ; # N
  %147 = phi i64 [%139, %$34] ; # Nm
  %148 = phi i64 [%140, %$34] ; # L
; # (++ X)
  %149 = inttoptr i64 %143 to i64*
  %150 = load i64, i64* %149
  %151 = getelementptr i64, i64* %149, i32 1
  %152 = load i64, i64* %151
; # (evSym (++ X))
  %153 = call i64 @evSym(i64 %150)
; # (xName Y)
  %154 = call i64 @xName(i64 %153)
; # (bufSize Nm)
  %155 = call i64 @bufSize(i64 %154)
; # (b8 (bufSize Nm))
  %156 = alloca i8, i64 %155
; # (bufString Nm (b8 (bufSize Nm)))
  %157 = call i8* @bufString(i64 %154, i8* %156)
; # (any (bufString Nm (b8 (bufSize Nm))))
  %158 = ptrtoint i8* %157 to i64
; # (push Y NIL 0 (any (bufString Nm (b8 (bufSize Nm)))))
  %159 = alloca i64, i64 4, align 16
  %160 = ptrtoint i64* %159 to i64
  %161 = inttoptr i64 %160 to i64*
  store i64 %153, i64* %161
  %162 = add i64 %160, 16
  %163 = inttoptr i64 %162 to i64*
  store i64 0, i64* %163
  %164 = add i64 %160, 24
  %165 = inttoptr i64 %164 to i64*
  store i64 %158, i64* %165
; # (link (push Y NIL 0 (any (bufString Nm (b8 (bufSize Nm))))))
  %166 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %167 = load i64, i64* %166
  %168 = inttoptr i64 %160 to i64*
  %169 = getelementptr i64, i64* %168, i32 1
  store i64 %167, i64* %169
  %170 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %160, i64* %170
; # (inc 'N)
  %171 = add i64 %146, 1
  br label %$34
$36:
  %172 = phi i64 [%135, %$34] ; # X
  %173 = phi i64 [%136, %$34] ; # Y
  %174 = phi i64* [%137, %$34] ; # M
  %175 = phi i64 [%138, %$34] ; # N
  %176 = phi i64 [%139, %$34] ; # Nm
  %177 = phi i64 [%140, %$34] ; # L
; # (unless (val $Chr) (call $Get))
; # (val $Chr)
  %178 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
  %179 = icmp ne i32 %178, 0
  br i1 %179, label %$38, label %$37
$37:
  %180 = phi i64 [%172, %$36] ; # X
  %181 = phi i64 [%173, %$36] ; # Y
  %182 = phi i64* [%174, %$36] ; # M
  %183 = phi i64 [%175, %$36] ; # N
  %184 = phi i64 [%176, %$36] ; # Nm
  %185 = phi i64 [%177, %$36] ; # L
; # (call $Get)
  %186 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %187 = call i32 %186()
  br label %$38
$38:
  %188 = phi i64 [%172, %$36], [%180, %$37] ; # X
  %189 = phi i64 [%173, %$36], [%181, %$37] ; # Y
  %190 = phi i64* [%174, %$36], [%182, %$37] ; # M
  %191 = phi i64 [%175, %$36], [%183, %$37] ; # N
  %192 = phi i64 [%176, %$36], [%184, %$37] ; # Nm
  %193 = phi i64 [%177, %$36], [%185, %$37] ; # L
; # (while (ge0 (val $Chr)) (let (B (i8 @) Q (i64* L) I N OutM M OutC...
  br label %$39
$39:
  %194 = phi i64 [%188, %$38], [%802, %$79] ; # X
  %195 = phi i64 [%189, %$38], [%803, %$79] ; # Y
  %196 = phi i64* [%190, %$38], [%804, %$79] ; # M
  %197 = phi i64 [%191, %$38], [%805, %$79] ; # N
  %198 = phi i64 [%192, %$38], [%806, %$79] ; # Nm
  %199 = phi i64 [%193, %$38], [%807, %$79] ; # L
; # (val $Chr)
  %200 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
; # (ge0 (val $Chr))
  %201 = icmp sge i32 %200, 0
  br i1 %201, label %$40, label %$41
$40:
  %202 = phi i64 [%194, %$39] ; # X
  %203 = phi i64 [%195, %$39] ; # Y
  %204 = phi i64* [%196, %$39] ; # M
  %205 = phi i64 [%197, %$39] ; # N
  %206 = phi i64 [%198, %$39] ; # Nm
  %207 = phi i64 [%199, %$39] ; # L
; # (let (B (i8 @) Q (i64* L) I N OutM M OutC (if M (val 3 M) 0)) (lo...
; # (i8 @)
  %208 = trunc i32 %200 to i8
; # (i64* L)
  %209 = inttoptr i64 %207 to i64*
; # (if M (val 3 M) 0)
  %210 = icmp ne i64* %204, null
  br i1 %210, label %$42, label %$43
$42:
  %211 = phi i64 [%202, %$40] ; # X
  %212 = phi i64 [%203, %$40] ; # Y
  %213 = phi i64* [%204, %$40] ; # M
  %214 = phi i64 [%205, %$40] ; # N
  %215 = phi i64 [%206, %$40] ; # Nm
  %216 = phi i64 [%207, %$40] ; # L
  %217 = phi i64* [%209, %$40] ; # Q
  %218 = phi i64 [%205, %$40] ; # I
; # (val 3 M)
  %219 = getelementptr i64, i64* %213, i32 2
  %220 = load i64, i64* %219
  br label %$44
$43:
  %221 = phi i64 [%202, %$40] ; # X
  %222 = phi i64 [%203, %$40] ; # Y
  %223 = phi i64* [%204, %$40] ; # M
  %224 = phi i64 [%205, %$40] ; # N
  %225 = phi i64 [%206, %$40] ; # Nm
  %226 = phi i64 [%207, %$40] ; # L
  %227 = phi i64* [%209, %$40] ; # Q
  %228 = phi i64 [%205, %$40] ; # I
  br label %$44
$44:
  %229 = phi i64 [%211, %$42], [%221, %$43] ; # X
  %230 = phi i64 [%212, %$42], [%222, %$43] ; # Y
  %231 = phi i64* [%213, %$42], [%223, %$43] ; # M
  %232 = phi i64 [%214, %$42], [%224, %$43] ; # N
  %233 = phi i64 [%215, %$42], [%225, %$43] ; # Nm
  %234 = phi i64 [%216, %$42], [%226, %$43] ; # L
  %235 = phi i64* [%217, %$42], [%227, %$43] ; # Q
  %236 = phi i64 [%218, %$42], [%228, %$43] ; # I
  %237 = phi i64 [%220, %$42], [0, %$43] ; # ->
; # (loop (loop (let S (ofs (i8* (val 4 Q)) (val 3 Q)) (when (== B (v...
  br label %$45
$45:
  %238 = phi i64 [%229, %$44], [%639, %$77] ; # X
  %239 = phi i64 [%230, %$44], [%640, %$77] ; # Y
  %240 = phi i64* [%231, %$44], [%641, %$77] ; # M
  %241 = phi i64 [%232, %$44], [%642, %$77] ; # N
  %242 = phi i64 [%233, %$44], [%643, %$77] ; # Nm
  %243 = phi i64 [%234, %$44], [%644, %$77] ; # L
  %244 = phi i64* [%235, %$44], [%650, %$77] ; # Q
  %245 = phi i64 [%236, %$44], [%646, %$77] ; # I
  %246 = phi i64 [%237, %$44], [%647, %$77] ; # OutC
; # (loop (let S (ofs (i8* (val 4 Q)) (val 3 Q)) (when (== B (val S))...
  br label %$46
$46:
  %247 = phi i64 [%238, %$45], [%619, %$67] ; # X
  %248 = phi i64 [%239, %$45], [%620, %$67] ; # Y
  %249 = phi i64* [%240, %$45], [%621, %$67] ; # M
  %250 = phi i64 [%241, %$45], [%622, %$67] ; # N
  %251 = phi i64 [%242, %$45], [%623, %$67] ; # Nm
  %252 = phi i64 [%243, %$45], [%624, %$67] ; # L
  %253 = phi i64* [%244, %$45], [%625, %$67] ; # Q
  %254 = phi i64 [%245, %$45], [%626, %$67] ; # I
  %255 = phi i64 [%246, %$45], [%627, %$67] ; # OutC
; # (let S (ofs (i8* (val 4 Q)) (val 3 Q)) (when (== B (val S)) (set ...
; # (val 4 Q)
  %256 = getelementptr i64, i64* %253, i32 3
  %257 = load i64, i64* %256
; # (i8* (val 4 Q))
  %258 = inttoptr i64 %257 to i8*
; # (val 3 Q)
  %259 = getelementptr i64, i64* %253, i32 2
  %260 = load i64, i64* %259
; # (ofs (i8* (val 4 Q)) (val 3 Q))
  %261 = getelementptr i8, i8* %258, i64 %260
; # (when (== B (val S)) (set 3 Q (inc (val 3 Q))) (? (val 2 S) (unle...
; # (val S)
  %262 = load i8, i8* %261
; # (== B (val S))
  %263 = icmp eq i8 %208, %262
  br i1 %263, label %$47, label %$48
$47:
  %264 = phi i64 [%247, %$46] ; # X
  %265 = phi i64 [%248, %$46] ; # Y
  %266 = phi i64* [%249, %$46] ; # M
  %267 = phi i64 [%250, %$46] ; # N
  %268 = phi i64 [%251, %$46] ; # Nm
  %269 = phi i64 [%252, %$46] ; # L
  %270 = phi i64* [%253, %$46] ; # Q
  %271 = phi i64 [%254, %$46] ; # I
  %272 = phi i64 [%255, %$46] ; # OutC
  %273 = phi i8* [%261, %$46] ; # S
; # (set 3 Q (inc (val 3 Q)))
; # (val 3 Q)
  %274 = getelementptr i64, i64* %270, i32 2
  %275 = load i64, i64* %274
; # (inc (val 3 Q))
  %276 = add i64 %275, 1
  %277 = getelementptr i64, i64* %270, i32 2
  store i64 %276, i64* %277
; # (? (val 2 S) (unless (and M (>= (val 3 M) (val 3 Q))) (setq M Q))...
; # (val 2 S)
  %278 = getelementptr i8, i8* %273, i32 1
  %279 = load i8, i8* %278
  %280 = icmp ne i8 %279, 0
  br i1 %280, label %$51, label %$49
$51:
  %281 = phi i64 [%264, %$47] ; # X
  %282 = phi i64 [%265, %$47] ; # Y
  %283 = phi i64* [%266, %$47] ; # M
  %284 = phi i64 [%267, %$47] ; # N
  %285 = phi i64 [%268, %$47] ; # Nm
  %286 = phi i64 [%269, %$47] ; # L
  %287 = phi i64* [%270, %$47] ; # Q
  %288 = phi i64 [%271, %$47] ; # I
  %289 = phi i64 [%272, %$47] ; # OutC
  %290 = phi i8* [%273, %$47] ; # S
; # (unless (and M (>= (val 3 M) (val 3 Q))) (setq M Q))
; # (and M (>= (val 3 M) (val 3 Q)))
  %291 = icmp ne i64* %283, null
  br i1 %291, label %$53, label %$52
$53:
  %292 = phi i64 [%281, %$51] ; # X
  %293 = phi i64 [%282, %$51] ; # Y
  %294 = phi i64* [%283, %$51] ; # M
  %295 = phi i64 [%284, %$51] ; # N
  %296 = phi i64 [%285, %$51] ; # Nm
  %297 = phi i64 [%286, %$51] ; # L
  %298 = phi i64* [%287, %$51] ; # Q
  %299 = phi i64 [%288, %$51] ; # I
  %300 = phi i64 [%289, %$51] ; # OutC
  %301 = phi i8* [%290, %$51] ; # S
; # (val 3 M)
  %302 = getelementptr i64, i64* %294, i32 2
  %303 = load i64, i64* %302
; # (val 3 Q)
  %304 = getelementptr i64, i64* %298, i32 2
  %305 = load i64, i64* %304
; # (>= (val 3 M) (val 3 Q))
  %306 = icmp uge i64 %303, %305
  br label %$52
$52:
  %307 = phi i64 [%281, %$51], [%292, %$53] ; # X
  %308 = phi i64 [%282, %$51], [%293, %$53] ; # Y
  %309 = phi i64* [%283, %$51], [%294, %$53] ; # M
  %310 = phi i64 [%284, %$51], [%295, %$53] ; # N
  %311 = phi i64 [%285, %$51], [%296, %$53] ; # Nm
  %312 = phi i64 [%286, %$51], [%297, %$53] ; # L
  %313 = phi i64* [%287, %$51], [%298, %$53] ; # Q
  %314 = phi i64 [%288, %$51], [%299, %$53] ; # I
  %315 = phi i64 [%289, %$51], [%300, %$53] ; # OutC
  %316 = phi i8* [%290, %$51], [%301, %$53] ; # S
  %317 = phi i1 [0, %$51], [%306, %$53] ; # ->
  br i1 %317, label %$55, label %$54
$54:
  %318 = phi i64 [%307, %$52] ; # X
  %319 = phi i64 [%308, %$52] ; # Y
  %320 = phi i64* [%309, %$52] ; # M
  %321 = phi i64 [%310, %$52] ; # N
  %322 = phi i64 [%311, %$52] ; # Nm
  %323 = phi i64 [%312, %$52] ; # L
  %324 = phi i64* [%313, %$52] ; # Q
  %325 = phi i64 [%314, %$52] ; # I
  %326 = phi i64 [%315, %$52] ; # OutC
  %327 = phi i8* [%316, %$52] ; # S
  br label %$55
$55:
  %328 = phi i64 [%307, %$52], [%318, %$54] ; # X
  %329 = phi i64 [%308, %$52], [%319, %$54] ; # Y
  %330 = phi i64* [%309, %$52], [%324, %$54] ; # M
  %331 = phi i64 [%310, %$52], [%321, %$54] ; # N
  %332 = phi i64 [%311, %$52], [%322, %$54] ; # Nm
  %333 = phi i64 [%312, %$52], [%323, %$54] ; # L
  %334 = phi i64* [%313, %$52], [%324, %$54] ; # Q
  %335 = phi i64 [%314, %$52], [%325, %$54] ; # I
  %336 = phi i64 [%315, %$52], [%326, %$54] ; # OutC
  %337 = phi i8* [%316, %$52], [%327, %$54] ; # S
  br label %$50
$49:
  %338 = phi i64 [%264, %$47] ; # X
  %339 = phi i64 [%265, %$47] ; # Y
  %340 = phi i64* [%266, %$47] ; # M
  %341 = phi i64 [%267, %$47] ; # N
  %342 = phi i64 [%268, %$47] ; # Nm
  %343 = phi i64 [%269, %$47] ; # L
  %344 = phi i64* [%270, %$47] ; # Q
  %345 = phi i64 [%271, %$47] ; # I
  %346 = phi i64 [%272, %$47] ; # OutC
  %347 = phi i8* [%273, %$47] ; # S
; # (when OutM (setq S (i8* (val 4 OutM))) (dec 'OutC (val 3 Q)) (unt...
  %348 = icmp ne i64* %204, null
  br i1 %348, label %$56, label %$57
$56:
  %349 = phi i64 [%338, %$49] ; # X
  %350 = phi i64 [%339, %$49] ; # Y
  %351 = phi i64* [%340, %$49] ; # M
  %352 = phi i64 [%341, %$49] ; # N
  %353 = phi i64 [%342, %$49] ; # Nm
  %354 = phi i64 [%343, %$49] ; # L
  %355 = phi i64* [%344, %$49] ; # Q
  %356 = phi i64 [%345, %$49] ; # I
  %357 = phi i64 [%346, %$49] ; # OutC
  %358 = phi i8* [%347, %$49] ; # S
; # (val 4 OutM)
  %359 = getelementptr i64, i64* %204, i32 3
  %360 = load i64, i64* %359
; # (i8* (val 4 OutM))
  %361 = inttoptr i64 %360 to i8*
; # (val 3 Q)
  %362 = getelementptr i64, i64* %355, i32 2
  %363 = load i64, i64* %362
; # (dec 'OutC (val 3 Q))
  %364 = sub i64 %357, %363
; # (until (lt0 OutC) (call $Put (val S)) (inc 'S) (dec 'OutC))
  br label %$58
$58:
  %365 = phi i64 [%349, %$56], [%376, %$59] ; # X
  %366 = phi i64 [%350, %$56], [%377, %$59] ; # Y
  %367 = phi i64* [%351, %$56], [%378, %$59] ; # M
  %368 = phi i64 [%352, %$56], [%379, %$59] ; # N
  %369 = phi i64 [%353, %$56], [%380, %$59] ; # Nm
  %370 = phi i64 [%354, %$56], [%381, %$59] ; # L
  %371 = phi i64* [%355, %$56], [%382, %$59] ; # Q
  %372 = phi i64 [%356, %$56], [%383, %$59] ; # I
  %373 = phi i64 [%364, %$56], [%389, %$59] ; # OutC
  %374 = phi i8* [%361, %$56], [%388, %$59] ; # S
; # (lt0 OutC)
  %375 = icmp slt i64 %373, 0
  br i1 %375, label %$60, label %$59
$59:
  %376 = phi i64 [%365, %$58] ; # X
  %377 = phi i64 [%366, %$58] ; # Y
  %378 = phi i64* [%367, %$58] ; # M
  %379 = phi i64 [%368, %$58] ; # N
  %380 = phi i64 [%369, %$58] ; # Nm
  %381 = phi i64 [%370, %$58] ; # L
  %382 = phi i64* [%371, %$58] ; # Q
  %383 = phi i64 [%372, %$58] ; # I
  %384 = phi i64 [%373, %$58] ; # OutC
  %385 = phi i8* [%374, %$58] ; # S
; # (val S)
  %386 = load i8, i8* %385
; # (call $Put (val S))
  %387 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %387(i8 %386)
; # (inc 'S)
  %388 = getelementptr i8, i8* %385, i32 1
; # (dec 'OutC)
  %389 = sub i64 %384, 1
  br label %$58
$60:
  %390 = phi i64 [%365, %$58] ; # X
  %391 = phi i64 [%366, %$58] ; # Y
  %392 = phi i64* [%367, %$58] ; # M
  %393 = phi i64 [%368, %$58] ; # N
  %394 = phi i64 [%369, %$58] ; # Nm
  %395 = phi i64 [%370, %$58] ; # L
  %396 = phi i64* [%371, %$58] ; # Q
  %397 = phi i64 [%372, %$58] ; # I
  %398 = phi i64 [%373, %$58] ; # OutC
  %399 = phi i8* [%374, %$58] ; # S
  br label %$57
$57:
  %400 = phi i64 [%338, %$49], [%390, %$60] ; # X
  %401 = phi i64 [%339, %$49], [%391, %$60] ; # Y
  %402 = phi i64* [%340, %$49], [%392, %$60] ; # M
  %403 = phi i64 [%341, %$49], [%393, %$60] ; # N
  %404 = phi i64 [%342, %$49], [%394, %$60] ; # Nm
  %405 = phi i64 [%343, %$49], [%395, %$60] ; # L
  %406 = phi i64* [%344, %$49], [%396, %$60] ; # Q
  %407 = phi i64 [%345, %$49], [%397, %$60] ; # I
  %408 = phi i64 [%346, %$49], [%398, %$60] ; # OutC
  %409 = phi i8* [%347, %$49], [%399, %$60] ; # S
; # (set $Chr 0)
  store i32 0, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
; # (drop P)
  %410 = inttoptr i64 %124 to i64*
  %411 = getelementptr i64, i64* %410, i32 1
  %412 = load i64, i64* %411
  %413 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %412, i64* %413
; # (val Q)
  %414 = load i64, i64* %406
; # (ret (val Q))
  ret i64 %414
$48:
  %415 = phi i64 [%247, %$46] ; # X
  %416 = phi i64 [%248, %$46] ; # Y
  %417 = phi i64* [%249, %$46] ; # M
  %418 = phi i64 [%250, %$46] ; # N
  %419 = phi i64 [%251, %$46] ; # Nm
  %420 = phi i64 [%252, %$46] ; # L
  %421 = phi i64* [%253, %$46] ; # Q
  %422 = phi i64 [%254, %$46] ; # I
  %423 = phi i64 [%255, %$46] ; # OutC
  %424 = phi i8* [%261, %$46] ; # S
; # (? (=0 (val 3 Q)))
; # (val 3 Q)
  %425 = getelementptr i64, i64* %421, i32 2
  %426 = load i64, i64* %425
; # (=0 (val 3 Q))
  %427 = icmp eq i64 %426, 0
  br i1 %427, label %$50, label %$61
$61:
  %428 = phi i64 [%415, %$48] ; # X
  %429 = phi i64 [%416, %$48] ; # Y
  %430 = phi i64* [%417, %$48] ; # M
  %431 = phi i64 [%418, %$48] ; # N
  %432 = phi i64 [%419, %$48] ; # Nm
  %433 = phi i64 [%420, %$48] ; # L
  %434 = phi i64* [%421, %$48] ; # Q
  %435 = phi i64 [%422, %$48] ; # I
  %436 = phi i64 [%423, %$48] ; # OutC
; # (let S (ofs (i8* (val 4 Q)) 1) (while (set 3 Q (dec (val 3 Q))) (...
; # (val 4 Q)
  %437 = getelementptr i64, i64* %434, i32 3
  %438 = load i64, i64* %437
; # (i8* (val 4 Q))
  %439 = inttoptr i64 %438 to i8*
; # (ofs (i8* (val 4 Q)) 1)
  %440 = getelementptr i8, i8* %439, i32 1
; # (while (set 3 Q (dec (val 3 Q))) (? (=0 (memcmp (i8* (val 4 Q)) S...
  br label %$62
$62:
  %441 = phi i64 [%428, %$61], [%471, %$65] ; # X
  %442 = phi i64 [%429, %$61], [%472, %$65] ; # Y
  %443 = phi i64* [%430, %$61], [%473, %$65] ; # M
  %444 = phi i64 [%431, %$61], [%474, %$65] ; # N
  %445 = phi i64 [%432, %$61], [%475, %$65] ; # Nm
  %446 = phi i64 [%433, %$61], [%476, %$65] ; # L
  %447 = phi i64* [%434, %$61], [%477, %$65] ; # Q
  %448 = phi i64 [%435, %$61], [%478, %$65] ; # I
  %449 = phi i64 [%436, %$61], [%479, %$65] ; # OutC
  %450 = phi i8* [%440, %$61], [%481, %$65] ; # S
; # (set 3 Q (dec (val 3 Q)))
; # (val 3 Q)
  %451 = getelementptr i64, i64* %447, i32 2
  %452 = load i64, i64* %451
; # (dec (val 3 Q))
  %453 = sub i64 %452, 1
  %454 = getelementptr i64, i64* %447, i32 2
  store i64 %453, i64* %454
  %455 = icmp ne i64 %453, 0
  br i1 %455, label %$63, label %$64
$63:
  %456 = phi i64 [%441, %$62] ; # X
  %457 = phi i64 [%442, %$62] ; # Y
  %458 = phi i64* [%443, %$62] ; # M
  %459 = phi i64 [%444, %$62] ; # N
  %460 = phi i64 [%445, %$62] ; # Nm
  %461 = phi i64 [%446, %$62] ; # L
  %462 = phi i64* [%447, %$62] ; # Q
  %463 = phi i64 [%448, %$62] ; # I
  %464 = phi i64 [%449, %$62] ; # OutC
  %465 = phi i8* [%450, %$62] ; # S
; # (? (=0 (memcmp (i8* (val 4 Q)) S @)))
; # (val 4 Q)
  %466 = getelementptr i64, i64* %462, i32 3
  %467 = load i64, i64* %466
; # (i8* (val 4 Q))
  %468 = inttoptr i64 %467 to i8*
; # (memcmp (i8* (val 4 Q)) S @)
  %469 = call i32 @memcmp(i8* %468, i8* %465, i64 %453)
; # (=0 (memcmp (i8* (val 4 Q)) S @))
  %470 = icmp eq i32 %469, 0
  br i1 %470, label %$64, label %$65
$65:
  %471 = phi i64 [%456, %$63] ; # X
  %472 = phi i64 [%457, %$63] ; # Y
  %473 = phi i64* [%458, %$63] ; # M
  %474 = phi i64 [%459, %$63] ; # N
  %475 = phi i64 [%460, %$63] ; # Nm
  %476 = phi i64 [%461, %$63] ; # L
  %477 = phi i64* [%462, %$63] ; # Q
  %478 = phi i64 [%463, %$63] ; # I
  %479 = phi i64 [%464, %$63] ; # OutC
  %480 = phi i8* [%465, %$63] ; # S
; # (inc 'S)
  %481 = getelementptr i8, i8* %480, i32 1
  br label %$62
$64:
  %482 = phi i64 [%441, %$62], [%456, %$63] ; # X
  %483 = phi i64 [%442, %$62], [%457, %$63] ; # Y
  %484 = phi i64* [%443, %$62], [%458, %$63] ; # M
  %485 = phi i64 [%444, %$62], [%459, %$63] ; # N
  %486 = phi i64 [%445, %$62], [%460, %$63] ; # Nm
  %487 = phi i64 [%446, %$62], [%461, %$63] ; # L
  %488 = phi i64* [%447, %$62], [%462, %$63] ; # Q
  %489 = phi i64 [%448, %$62], [%463, %$63] ; # I
  %490 = phi i64 [%449, %$62], [%464, %$63] ; # OutC
  %491 = phi i8* [%450, %$62], [%465, %$63] ; # S
; # (when (== Q M) (setq M (i64* null)) (let (Z (i64* L) J N) (loop (...
; # (== Q M)
  %492 = icmp eq i64* %488, %484
  br i1 %492, label %$66, label %$67
$66:
  %493 = phi i64 [%482, %$64] ; # X
  %494 = phi i64 [%483, %$64] ; # Y
  %495 = phi i64* [%484, %$64] ; # M
  %496 = phi i64 [%485, %$64] ; # N
  %497 = phi i64 [%486, %$64] ; # Nm
  %498 = phi i64 [%487, %$64] ; # L
  %499 = phi i64* [%488, %$64] ; # Q
  %500 = phi i64 [%489, %$64] ; # I
  %501 = phi i64 [%490, %$64] ; # OutC
; # (i64* null)
  %502 = inttoptr i64 0 to i64*
; # (let (Z (i64* L) J N) (loop (when (val 3 Z) (unless (and M (>= (v...
; # (i64* L)
  %503 = inttoptr i64 %498 to i64*
; # (loop (when (val 3 Z) (unless (and M (>= (val 3 M) (val 3 Z))) (s...
  br label %$68
$68:
  %504 = phi i64 [%493, %$66], [%593, %$75] ; # X
  %505 = phi i64 [%494, %$66], [%594, %$75] ; # Y
  %506 = phi i64* [%502, %$66], [%595, %$75] ; # M
  %507 = phi i64 [%496, %$66], [%596, %$75] ; # N
  %508 = phi i64 [%497, %$66], [%597, %$75] ; # Nm
  %509 = phi i64 [%498, %$66], [%598, %$75] ; # L
  %510 = phi i64* [%499, %$66], [%599, %$75] ; # Q
  %511 = phi i64 [%500, %$66], [%600, %$75] ; # I
  %512 = phi i64 [%501, %$66], [%601, %$75] ; # OutC
  %513 = phi i64* [%503, %$66], [%606, %$75] ; # Z
  %514 = phi i64 [%496, %$66], [%603, %$75] ; # J
; # (when (val 3 Z) (unless (and M (>= (val 3 M) (val 3 Z))) (setq M ...
; # (val 3 Z)
  %515 = getelementptr i64, i64* %513, i32 2
  %516 = load i64, i64* %515
  %517 = icmp ne i64 %516, 0
  br i1 %517, label %$69, label %$70
$69:
  %518 = phi i64 [%504, %$68] ; # X
  %519 = phi i64 [%505, %$68] ; # Y
  %520 = phi i64* [%506, %$68] ; # M
  %521 = phi i64 [%507, %$68] ; # N
  %522 = phi i64 [%508, %$68] ; # Nm
  %523 = phi i64 [%509, %$68] ; # L
  %524 = phi i64* [%510, %$68] ; # Q
  %525 = phi i64 [%511, %$68] ; # I
  %526 = phi i64 [%512, %$68] ; # OutC
  %527 = phi i64* [%513, %$68] ; # Z
  %528 = phi i64 [%514, %$68] ; # J
; # (unless (and M (>= (val 3 M) (val 3 Z))) (setq M Z))
; # (and M (>= (val 3 M) (val 3 Z)))
  %529 = icmp ne i64* %520, null
  br i1 %529, label %$72, label %$71
$72:
  %530 = phi i64 [%518, %$69] ; # X
  %531 = phi i64 [%519, %$69] ; # Y
  %532 = phi i64* [%520, %$69] ; # M
  %533 = phi i64 [%521, %$69] ; # N
  %534 = phi i64 [%522, %$69] ; # Nm
  %535 = phi i64 [%523, %$69] ; # L
  %536 = phi i64* [%524, %$69] ; # Q
  %537 = phi i64 [%525, %$69] ; # I
  %538 = phi i64 [%526, %$69] ; # OutC
  %539 = phi i64* [%527, %$69] ; # Z
  %540 = phi i64 [%528, %$69] ; # J
; # (val 3 M)
  %541 = getelementptr i64, i64* %532, i32 2
  %542 = load i64, i64* %541
; # (val 3 Z)
  %543 = getelementptr i64, i64* %539, i32 2
  %544 = load i64, i64* %543
; # (>= (val 3 M) (val 3 Z))
  %545 = icmp uge i64 %542, %544
  br label %$71
$71:
  %546 = phi i64 [%518, %$69], [%530, %$72] ; # X
  %547 = phi i64 [%519, %$69], [%531, %$72] ; # Y
  %548 = phi i64* [%520, %$69], [%532, %$72] ; # M
  %549 = phi i64 [%521, %$69], [%533, %$72] ; # N
  %550 = phi i64 [%522, %$69], [%534, %$72] ; # Nm
  %551 = phi i64 [%523, %$69], [%535, %$72] ; # L
  %552 = phi i64* [%524, %$69], [%536, %$72] ; # Q
  %553 = phi i64 [%525, %$69], [%537, %$72] ; # I
  %554 = phi i64 [%526, %$69], [%538, %$72] ; # OutC
  %555 = phi i64* [%527, %$69], [%539, %$72] ; # Z
  %556 = phi i64 [%528, %$69], [%540, %$72] ; # J
  %557 = phi i1 [0, %$69], [%545, %$72] ; # ->
  br i1 %557, label %$74, label %$73
$73:
  %558 = phi i64 [%546, %$71] ; # X
  %559 = phi i64 [%547, %$71] ; # Y
  %560 = phi i64* [%548, %$71] ; # M
  %561 = phi i64 [%549, %$71] ; # N
  %562 = phi i64 [%550, %$71] ; # Nm
  %563 = phi i64 [%551, %$71] ; # L
  %564 = phi i64* [%552, %$71] ; # Q
  %565 = phi i64 [%553, %$71] ; # I
  %566 = phi i64 [%554, %$71] ; # OutC
  %567 = phi i64* [%555, %$71] ; # Z
  %568 = phi i64 [%556, %$71] ; # J
  br label %$74
$74:
  %569 = phi i64 [%546, %$71], [%558, %$73] ; # X
  %570 = phi i64 [%547, %$71], [%559, %$73] ; # Y
  %571 = phi i64* [%548, %$71], [%567, %$73] ; # M
  %572 = phi i64 [%549, %$71], [%561, %$73] ; # N
  %573 = phi i64 [%550, %$71], [%562, %$73] ; # Nm
  %574 = phi i64 [%551, %$71], [%563, %$73] ; # L
  %575 = phi i64* [%552, %$71], [%564, %$73] ; # Q
  %576 = phi i64 [%553, %$71], [%565, %$73] ; # I
  %577 = phi i64 [%554, %$71], [%566, %$73] ; # OutC
  %578 = phi i64* [%555, %$71], [%567, %$73] ; # Z
  %579 = phi i64 [%556, %$71], [%568, %$73] ; # J
  br label %$70
$70:
  %580 = phi i64 [%504, %$68], [%569, %$74] ; # X
  %581 = phi i64 [%505, %$68], [%570, %$74] ; # Y
  %582 = phi i64* [%506, %$68], [%571, %$74] ; # M
  %583 = phi i64 [%507, %$68], [%572, %$74] ; # N
  %584 = phi i64 [%508, %$68], [%573, %$74] ; # Nm
  %585 = phi i64 [%509, %$68], [%574, %$74] ; # L
  %586 = phi i64* [%510, %$68], [%575, %$74] ; # Q
  %587 = phi i64 [%511, %$68], [%576, %$74] ; # I
  %588 = phi i64 [%512, %$68], [%577, %$74] ; # OutC
  %589 = phi i64* [%513, %$68], [%578, %$74] ; # Z
  %590 = phi i64 [%514, %$68], [%579, %$74] ; # J
; # (? (=0 (dec 'J)))
; # (dec 'J)
  %591 = sub i64 %590, 1
; # (=0 (dec 'J))
  %592 = icmp eq i64 %591, 0
  br i1 %592, label %$76, label %$75
$75:
  %593 = phi i64 [%580, %$70] ; # X
  %594 = phi i64 [%581, %$70] ; # Y
  %595 = phi i64* [%582, %$70] ; # M
  %596 = phi i64 [%583, %$70] ; # N
  %597 = phi i64 [%584, %$70] ; # Nm
  %598 = phi i64 [%585, %$70] ; # L
  %599 = phi i64* [%586, %$70] ; # Q
  %600 = phi i64 [%587, %$70] ; # I
  %601 = phi i64 [%588, %$70] ; # OutC
  %602 = phi i64* [%589, %$70] ; # Z
  %603 = phi i64 [%591, %$70] ; # J
; # (val 2 Z)
  %604 = getelementptr i64, i64* %602, i32 1
  %605 = load i64, i64* %604
; # (i64* (val 2 Z))
  %606 = inttoptr i64 %605 to i64*
  br label %$68
$76:
  %607 = phi i64 [%580, %$70] ; # X
  %608 = phi i64 [%581, %$70] ; # Y
  %609 = phi i64* [%582, %$70] ; # M
  %610 = phi i64 [%583, %$70] ; # N
  %611 = phi i64 [%584, %$70] ; # Nm
  %612 = phi i64 [%585, %$70] ; # L
  %613 = phi i64* [%586, %$70] ; # Q
  %614 = phi i64 [%587, %$70] ; # I
  %615 = phi i64 [%588, %$70] ; # OutC
  %616 = phi i64* [%589, %$70] ; # Z
  %617 = phi i64 [%591, %$70] ; # J
  %618 = phi i64 [0, %$70] ; # ->
  br label %$67
$67:
  %619 = phi i64 [%482, %$64], [%607, %$76] ; # X
  %620 = phi i64 [%483, %$64], [%608, %$76] ; # Y
  %621 = phi i64* [%484, %$64], [%609, %$76] ; # M
  %622 = phi i64 [%485, %$64], [%610, %$76] ; # N
  %623 = phi i64 [%486, %$64], [%611, %$76] ; # Nm
  %624 = phi i64 [%487, %$64], [%612, %$76] ; # L
  %625 = phi i64* [%488, %$64], [%613, %$76] ; # Q
  %626 = phi i64 [%489, %$64], [%614, %$76] ; # I
  %627 = phi i64 [%490, %$64], [%615, %$76] ; # OutC
  br label %$46
$50:
  %628 = phi i64 [%328, %$55], [%415, %$48] ; # X
  %629 = phi i64 [%329, %$55], [%416, %$48] ; # Y
  %630 = phi i64* [%330, %$55], [%417, %$48] ; # M
  %631 = phi i64 [%331, %$55], [%418, %$48] ; # N
  %632 = phi i64 [%332, %$55], [%419, %$48] ; # Nm
  %633 = phi i64 [%333, %$55], [%420, %$48] ; # L
  %634 = phi i64* [%334, %$55], [%421, %$48] ; # Q
  %635 = phi i64 [%335, %$55], [%422, %$48] ; # I
  %636 = phi i64 [%336, %$55], [%423, %$48] ; # OutC
; # (? (=0 (dec 'I)))
; # (dec 'I)
  %637 = sub i64 %635, 1
; # (=0 (dec 'I))
  %638 = icmp eq i64 %637, 0
  br i1 %638, label %$78, label %$77
$77:
  %639 = phi i64 [%628, %$50] ; # X
  %640 = phi i64 [%629, %$50] ; # Y
  %641 = phi i64* [%630, %$50] ; # M
  %642 = phi i64 [%631, %$50] ; # N
  %643 = phi i64 [%632, %$50] ; # Nm
  %644 = phi i64 [%633, %$50] ; # L
  %645 = phi i64* [%634, %$50] ; # Q
  %646 = phi i64 [%637, %$50] ; # I
  %647 = phi i64 [%636, %$50] ; # OutC
; # (val 2 Q)
  %648 = getelementptr i64, i64* %645, i32 1
  %649 = load i64, i64* %648
; # (i64* (val 2 Q))
  %650 = inttoptr i64 %649 to i64*
  br label %$45
$78:
  %651 = phi i64 [%628, %$50] ; # X
  %652 = phi i64 [%629, %$50] ; # Y
  %653 = phi i64* [%630, %$50] ; # M
  %654 = phi i64 [%631, %$50] ; # N
  %655 = phi i64 [%632, %$50] ; # Nm
  %656 = phi i64 [%633, %$50] ; # L
  %657 = phi i64* [%634, %$50] ; # Q
  %658 = phi i64 [%637, %$50] ; # I
  %659 = phi i64 [%636, %$50] ; # OutC
  %660 = phi i64 [0, %$50] ; # ->
; # (cond ((=0 M) (when OutM (let (S (i8* (val 4 OutM)) C OutC) (loop...
; # (=0 M)
  %661 = icmp eq i64* %653, null
  br i1 %661, label %$81, label %$80
$81:
  %662 = phi i64 [%651, %$78] ; # X
  %663 = phi i64 [%652, %$78] ; # Y
  %664 = phi i64* [%653, %$78] ; # M
  %665 = phi i64 [%654, %$78] ; # N
  %666 = phi i64 [%655, %$78] ; # Nm
  %667 = phi i64 [%656, %$78] ; # L
  %668 = phi i64* [%657, %$78] ; # Q
  %669 = phi i64 [%658, %$78] ; # I
  %670 = phi i64 [%659, %$78] ; # OutC
; # (when OutM (let (S (i8* (val 4 OutM)) C OutC) (loop (call $Put (v...
  %671 = icmp ne i64* %204, null
  br i1 %671, label %$82, label %$83
$82:
  %672 = phi i64 [%662, %$81] ; # X
  %673 = phi i64 [%663, %$81] ; # Y
  %674 = phi i64* [%664, %$81] ; # M
  %675 = phi i64 [%665, %$81] ; # N
  %676 = phi i64 [%666, %$81] ; # Nm
  %677 = phi i64 [%667, %$81] ; # L
  %678 = phi i64* [%668, %$81] ; # Q
  %679 = phi i64 [%669, %$81] ; # I
  %680 = phi i64 [%670, %$81] ; # OutC
; # (let (S (i8* (val 4 OutM)) C OutC) (loop (call $Put (val S)) (inc...
; # (val 4 OutM)
  %681 = getelementptr i64, i64* %204, i32 3
  %682 = load i64, i64* %681
; # (i8* (val 4 OutM))
  %683 = inttoptr i64 %682 to i8*
; # (loop (call $Put (val S)) (inc 'S) (? (=0 (dec 'C))))
  br label %$84
$84:
  %684 = phi i64 [%672, %$82], [%700, %$85] ; # X
  %685 = phi i64 [%673, %$82], [%701, %$85] ; # Y
  %686 = phi i64* [%674, %$82], [%702, %$85] ; # M
  %687 = phi i64 [%675, %$82], [%703, %$85] ; # N
  %688 = phi i64 [%676, %$82], [%704, %$85] ; # Nm
  %689 = phi i64 [%677, %$82], [%705, %$85] ; # L
  %690 = phi i64* [%678, %$82], [%706, %$85] ; # Q
  %691 = phi i64 [%679, %$82], [%707, %$85] ; # I
  %692 = phi i64 [%680, %$82], [%708, %$85] ; # OutC
  %693 = phi i8* [%683, %$82], [%709, %$85] ; # S
  %694 = phi i64 [%680, %$82], [%710, %$85] ; # C
; # (val S)
  %695 = load i8, i8* %693
; # (call $Put (val S))
  %696 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %696(i8 %695)
; # (inc 'S)
  %697 = getelementptr i8, i8* %693, i32 1
; # (? (=0 (dec 'C)))
; # (dec 'C)
  %698 = sub i64 %694, 1
; # (=0 (dec 'C))
  %699 = icmp eq i64 %698, 0
  br i1 %699, label %$86, label %$85
$85:
  %700 = phi i64 [%684, %$84] ; # X
  %701 = phi i64 [%685, %$84] ; # Y
  %702 = phi i64* [%686, %$84] ; # M
  %703 = phi i64 [%687, %$84] ; # N
  %704 = phi i64 [%688, %$84] ; # Nm
  %705 = phi i64 [%689, %$84] ; # L
  %706 = phi i64* [%690, %$84] ; # Q
  %707 = phi i64 [%691, %$84] ; # I
  %708 = phi i64 [%692, %$84] ; # OutC
  %709 = phi i8* [%697, %$84] ; # S
  %710 = phi i64 [%698, %$84] ; # C
  br label %$84
$86:
  %711 = phi i64 [%684, %$84] ; # X
  %712 = phi i64 [%685, %$84] ; # Y
  %713 = phi i64* [%686, %$84] ; # M
  %714 = phi i64 [%687, %$84] ; # N
  %715 = phi i64 [%688, %$84] ; # Nm
  %716 = phi i64 [%689, %$84] ; # L
  %717 = phi i64* [%690, %$84] ; # Q
  %718 = phi i64 [%691, %$84] ; # I
  %719 = phi i64 [%692, %$84] ; # OutC
  %720 = phi i8* [%697, %$84] ; # S
  %721 = phi i64 [%698, %$84] ; # C
  %722 = phi i64 [0, %$84] ; # ->
  br label %$83
$83:
  %723 = phi i64 [%662, %$81], [%711, %$86] ; # X
  %724 = phi i64 [%663, %$81], [%712, %$86] ; # Y
  %725 = phi i64* [%664, %$81], [%713, %$86] ; # M
  %726 = phi i64 [%665, %$81], [%714, %$86] ; # N
  %727 = phi i64 [%666, %$81], [%715, %$86] ; # Nm
  %728 = phi i64 [%667, %$81], [%716, %$86] ; # L
  %729 = phi i64* [%668, %$81], [%717, %$86] ; # Q
  %730 = phi i64 [%669, %$81], [%718, %$86] ; # I
  %731 = phi i64 [%670, %$81], [%719, %$86] ; # OutC
; # (call $Put B)
  %732 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %732(i8 %208)
  br label %$79
$80:
  %733 = phi i64 [%651, %$78] ; # X
  %734 = phi i64 [%652, %$78] ; # Y
  %735 = phi i64* [%653, %$78] ; # M
  %736 = phi i64 [%654, %$78] ; # N
  %737 = phi i64 [%655, %$78] ; # Nm
  %738 = phi i64 [%656, %$78] ; # L
  %739 = phi i64* [%657, %$78] ; # Q
  %740 = phi i64 [%658, %$78] ; # I
  %741 = phi i64 [%659, %$78] ; # OutC
  %742 = icmp ne i64* %204, null
  br i1 %742, label %$88, label %$87
$88:
  %743 = phi i64 [%733, %$80] ; # X
  %744 = phi i64 [%734, %$80] ; # Y
  %745 = phi i64* [%735, %$80] ; # M
  %746 = phi i64 [%736, %$80] ; # N
  %747 = phi i64 [%737, %$80] ; # Nm
  %748 = phi i64 [%738, %$80] ; # L
  %749 = phi i64* [%739, %$80] ; # Q
  %750 = phi i64 [%740, %$80] ; # I
  %751 = phi i64 [%741, %$80] ; # OutC
; # (let S (i8* (val 4 OutM)) (dec 'OutC (val 3 M)) (until (lt0 OutC)...
; # (val 4 OutM)
  %752 = getelementptr i64, i64* %204, i32 3
  %753 = load i64, i64* %752
; # (i8* (val 4 OutM))
  %754 = inttoptr i64 %753 to i8*
; # (val 3 M)
  %755 = getelementptr i64, i64* %745, i32 2
  %756 = load i64, i64* %755
; # (dec 'OutC (val 3 M))
  %757 = sub i64 %751, %756
; # (until (lt0 OutC) (call $Put (val S)) (inc 'S) (dec 'OutC))
  br label %$89
$89:
  %758 = phi i64 [%743, %$88], [%769, %$90] ; # X
  %759 = phi i64 [%744, %$88], [%770, %$90] ; # Y
  %760 = phi i64* [%745, %$88], [%771, %$90] ; # M
  %761 = phi i64 [%746, %$88], [%772, %$90] ; # N
  %762 = phi i64 [%747, %$88], [%773, %$90] ; # Nm
  %763 = phi i64 [%748, %$88], [%774, %$90] ; # L
  %764 = phi i64* [%749, %$88], [%775, %$90] ; # Q
  %765 = phi i64 [%750, %$88], [%776, %$90] ; # I
  %766 = phi i64 [%757, %$88], [%782, %$90] ; # OutC
  %767 = phi i8* [%754, %$88], [%781, %$90] ; # S
; # (lt0 OutC)
  %768 = icmp slt i64 %766, 0
  br i1 %768, label %$91, label %$90
$90:
  %769 = phi i64 [%758, %$89] ; # X
  %770 = phi i64 [%759, %$89] ; # Y
  %771 = phi i64* [%760, %$89] ; # M
  %772 = phi i64 [%761, %$89] ; # N
  %773 = phi i64 [%762, %$89] ; # Nm
  %774 = phi i64 [%763, %$89] ; # L
  %775 = phi i64* [%764, %$89] ; # Q
  %776 = phi i64 [%765, %$89] ; # I
  %777 = phi i64 [%766, %$89] ; # OutC
  %778 = phi i8* [%767, %$89] ; # S
; # (val S)
  %779 = load i8, i8* %778
; # (call $Put (val S))
  %780 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %780(i8 %779)
; # (inc 'S)
  %781 = getelementptr i8, i8* %778, i32 1
; # (dec 'OutC)
  %782 = sub i64 %777, 1
  br label %$89
$91:
  %783 = phi i64 [%758, %$89] ; # X
  %784 = phi i64 [%759, %$89] ; # Y
  %785 = phi i64* [%760, %$89] ; # M
  %786 = phi i64 [%761, %$89] ; # N
  %787 = phi i64 [%762, %$89] ; # Nm
  %788 = phi i64 [%763, %$89] ; # L
  %789 = phi i64* [%764, %$89] ; # Q
  %790 = phi i64 [%765, %$89] ; # I
  %791 = phi i64 [%766, %$89] ; # OutC
  %792 = phi i8* [%767, %$89] ; # S
  br label %$79
$87:
  %793 = phi i64 [%733, %$80] ; # X
  %794 = phi i64 [%734, %$80] ; # Y
  %795 = phi i64* [%735, %$80] ; # M
  %796 = phi i64 [%736, %$80] ; # N
  %797 = phi i64 [%737, %$80] ; # Nm
  %798 = phi i64 [%738, %$80] ; # L
  %799 = phi i64* [%739, %$80] ; # Q
  %800 = phi i64 [%740, %$80] ; # I
  %801 = phi i64 [%741, %$80] ; # OutC
  br label %$79
$79:
  %802 = phi i64 [%723, %$83], [%783, %$91], [%793, %$87] ; # X
  %803 = phi i64 [%724, %$83], [%784, %$91], [%794, %$87] ; # Y
  %804 = phi i64* [%725, %$83], [%785, %$91], [%795, %$87] ; # M
  %805 = phi i64 [%726, %$83], [%786, %$91], [%796, %$87] ; # N
  %806 = phi i64 [%727, %$83], [%787, %$91], [%797, %$87] ; # Nm
  %807 = phi i64 [%728, %$83], [%788, %$91], [%798, %$87] ; # L
  %808 = phi i64* [%729, %$83], [%789, %$91], [%799, %$87] ; # Q
  %809 = phi i64 [%730, %$83], [%790, %$91], [%800, %$87] ; # I
  %810 = phi i64 [%731, %$83], [%791, %$91], [%801, %$87] ; # OutC
; # (call $Get)
  %811 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %812 = call i32 %811()
  br label %$39
$41:
  %813 = phi i64 [%194, %$39] ; # X
  %814 = phi i64 [%195, %$39] ; # Y
  %815 = phi i64* [%196, %$39] ; # M
  %816 = phi i64 [%197, %$39] ; # N
  %817 = phi i64 [%198, %$39] ; # Nm
  %818 = phi i64 [%199, %$39] ; # L
; # (drop P)
  %819 = inttoptr i64 %124 to i64*
  %820 = getelementptr i64, i64* %819, i32 1
  %821 = load i64, i64* %820
  %822 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %821, i64* %822
  br label %$7
$7:
  %823 = phi i64 [%48, %$17], [%106, %$29], [%813, %$41] ; # X
  %824 = phi i64 [%49, %$17], [%107, %$29], [%814, %$41] ; # Y
  %825 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$17], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$29], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$41] ; # ->
  ret i64 %825
}

define void @_putStdout(i8) align 8 {
$1:
; # (let Out: (outFile (val $OutFile)) (when (Out:) (let I (Out: ix) ...
; # (val $OutFile)
  %1 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 80) to i8**)
; # (when (Out:) (let I (Out: ix) (when (== I BUFSIZ) (Out: ix (setq ...
; # (Out:)
  %2 = icmp ne i8* %1, null
  br i1 %2, label %$2, label %$3
$2:
; # (let I (Out: ix) (when (== I BUFSIZ) (Out: ix (setq I 0)) (wrByte...
; # (Out: ix)
  %3 = getelementptr i8, i8* %1, i32 4
  %4 = bitcast i8* %3 to i32*
  %5 = load i32, i32* %4
; # (when (== I BUFSIZ) (Out: ix (setq I 0)) (wrBytes (Out: fd) (Out:...
; # (== I BUFSIZ)
  %6 = icmp eq i32 %5, 4096
  br i1 %6, label %$4, label %$5
$4:
  %7 = phi i32 [%5, %$2] ; # I
; # (Out: ix (setq I 0))
  %8 = getelementptr i8, i8* %1, i32 4
  %9 = bitcast i8* %8 to i32*
  store i32 0, i32* %9
; # (Out: fd)
  %10 = bitcast i8* %1 to i32*
  %11 = load i32, i32* %10
; # (Out: (buf))
  %12 = getelementptr i8, i8* %1, i32 8
; # (wrBytes (Out: fd) (Out: (buf)) BUFSIZ)
  %13 = call i1 @wrBytes(i32 %11, i8* %12, i32 4096)
  br label %$5
$5:
  %14 = phi i32 [%5, %$2], [0, %$4] ; # I
; # (set (ofs (Out: (buf)) I) B)
; # (Out: (buf))
  %15 = getelementptr i8, i8* %1, i32 8
; # (ofs (Out: (buf)) I)
  %16 = getelementptr i8, i8* %15, i32 %14
  store i8 %0, i8* %16
; # (Out: ix (inc 'I))
  %17 = getelementptr i8, i8* %1, i32 4
  %18 = bitcast i8* %17 to i32*
  %19 = add i32 %14, 1
  store i32 %19, i32* %18
; # (when (and (== B (char "^J")) (Out: tty)) (Out: ix 0) (wrBytes (O...
; # (and (== B (char "^J")) (Out: tty))
; # (== B (char "^J"))
  %20 = icmp eq i8 %0, 10
  br i1 %20, label %$7, label %$6
$7:
  %21 = phi i32 [%19, %$5] ; # I
; # (Out: tty)
  %22 = getelementptr i8, i8* %1, i32 4104
  %23 = bitcast i8* %22 to i1*
  %24 = load i1, i1* %23
  br label %$6
$6:
  %25 = phi i32 [%19, %$5], [%21, %$7] ; # I
  %26 = phi i1 [0, %$5], [%24, %$7] ; # ->
  br i1 %26, label %$8, label %$9
$8:
  %27 = phi i32 [%25, %$6] ; # I
; # (Out: ix 0)
  %28 = getelementptr i8, i8* %1, i32 4
  %29 = bitcast i8* %28 to i32*
  store i32 0, i32* %29
; # (Out: fd)
  %30 = bitcast i8* %1 to i32*
  %31 = load i32, i32* %30
; # (Out: (buf))
  %32 = getelementptr i8, i8* %1, i32 8
; # (wrBytes (Out: fd) (Out: (buf)) I)
  %33 = call i1 @wrBytes(i32 %31, i8* %32, i32 %27)
  br label %$9
$9:
  %34 = phi i32 [%25, %$6], [%27, %$8] ; # I
  br label %$3
$3:
  ret void
}

define void @newline() align 8 {
$1:
; # (call $Put (char "^J"))
  %0 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %0(i8 10)
  ret void
}

define void @space() align 8 {
$1:
; # (call $Put (char " "))
  %0 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %0(i8 32)
  ret void
}

define void @outWord(i64) align 8 {
$1:
; # (when (> N 9) (outWord (/ N 10)) (setq N (% N 10)))
; # (> N 9)
  %1 = icmp ugt i64 %0, 9
  br i1 %1, label %$2, label %$3
$2:
  %2 = phi i64 [%0, %$1] ; # N
; # (/ N 10)
  %3 = udiv i64 %2, 10
; # (outWord (/ N 10))
  call void @outWord(i64 %3)
; # (% N 10)
  %4 = urem i64 %2, 10
  br label %$3
$3:
  %5 = phi i64 [%0, %$1], [%4, %$2] ; # N
; # (i8 N)
  %6 = trunc i64 %5 to i8
; # (+ (i8 N) (char "0"))
  %7 = add i8 %6, 48
; # (call $Put (+ (i8 N) (char "0")))
  %8 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %8(i8 %7)
  ret void
}

define void @outNum(i64) align 8 {
$1:
; # (when (sign? X) (call $Put (char "-")))
; # (sign? X)
  %1 = and i64 %0, 8
  %2 = icmp ne i64 %1, 0
  br i1 %2, label %$2, label %$3
$2:
; # (call $Put (char "-"))
  %3 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %3(i8 45)
  br label %$3
$3:
; # (i64 X)
; # (shr (i64 X) 4)
  %4 = lshr i64 %0, 4
; # (outWord (shr (i64 X) 4))
  call void @outWord(i64 %4)
  ret void
}

define void @outOct(i64) align 8 {
$1:
; # (when (> N 7) (outOct (shr N 3)) (setq N (& N 7)))
; # (> N 7)
  %1 = icmp ugt i64 %0, 7
  br i1 %1, label %$2, label %$3
$2:
  %2 = phi i64 [%0, %$1] ; # N
; # (shr N 3)
  %3 = lshr i64 %2, 3
; # (outOct (shr N 3))
  call void @outOct(i64 %3)
; # (& N 7)
  %4 = and i64 %2, 7
  br label %$3
$3:
  %5 = phi i64 [%0, %$1], [%4, %$2] ; # N
; # (i8 N)
  %6 = trunc i64 %5 to i8
; # (+ (i8 N) (char "0"))
  %7 = add i8 %6, 48
; # (call $Put (+ (i8 N) (char "0")))
  %8 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %8(i8 %7)
  ret void
}

define void @outAo(i32) align 8 {
$1:
; # (when (> N 15) (outAo (shr N 4)) (setq N (& N 15)))
; # (> N 15)
  %1 = icmp sgt i32 %0, 15
  br i1 %1, label %$2, label %$3
$2:
  %2 = phi i32 [%0, %$1] ; # N
; # (shr N 4)
  %3 = lshr i32 %2, 4
; # (outAo (shr N 4))
  call void @outAo(i32 %3)
; # (& N 15)
  %4 = and i32 %2, 15
  br label %$3
$3:
  %5 = phi i32 [%0, %$1], [%4, %$2] ; # N
; # (i8 N)
  %6 = trunc i32 %5 to i8
; # (+ (i8 N) (char "@"))
  %7 = add i8 %6, 64
; # (call $Put (+ (i8 N) (char "@")))
  %8 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %8(i8 %7)
  ret void
}

define i8* @bufAo(i8*, i32) align 8 {
$1:
; # (when (> N 15) (setq P (bufAo P (shr N 4)) N (& N 15)))
; # (> N 15)
  %2 = icmp sgt i32 %1, 15
  br i1 %2, label %$2, label %$3
$2:
  %3 = phi i8* [%0, %$1] ; # P
  %4 = phi i32 [%1, %$1] ; # N
; # (shr N 4)
  %5 = lshr i32 %4, 4
; # (bufAo P (shr N 4))
  %6 = call i8* @bufAo(i8* %3, i32 %5)
; # (& N 15)
  %7 = and i32 %4, 15
  br label %$3
$3:
  %8 = phi i8* [%0, %$1], [%6, %$2] ; # P
  %9 = phi i32 [%1, %$1], [%7, %$2] ; # N
; # (set P (+ (i8 N) (char "@")))
; # (i8 N)
  %10 = trunc i32 %9 to i8
; # (+ (i8 N) (char "@"))
  %11 = add i8 %10, 64
  store i8 %11, i8* %8
; # (inc P)
  %12 = getelementptr i8, i8* %8, i32 1
  ret i8* %12
}

define void @prExt(i64) align 8 {
$1:
; # (when (objFile Nm) (outAo @))
; # (objFile Nm)
  %1 = call i32 @objFile(i64 %0)
  %2 = icmp ne i32 %1, 0
  br i1 %2, label %$2, label %$3
$2:
; # (outAo @)
  call void @outAo(i32 %1)
  br label %$3
$3:
; # (objId Nm)
  %3 = call i64 @objId(i64 %0)
; # (outOct (objId Nm))
  call void @outOct(i64 %3)
  ret void
}

define void @outString(i8*) align 8 {
$1:
; # (while (val S) (call $Put @) (inc 'S))
  br label %$2
$2:
  %1 = phi i8* [%0, %$1], [%6, %$3] ; # S
; # (val S)
  %2 = load i8, i8* %1
  %3 = icmp ne i8 %2, 0
  br i1 %3, label %$3, label %$4
$3:
  %4 = phi i8* [%1, %$2] ; # S
; # (call $Put @)
  %5 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %5(i8 %2)
; # (inc 'S)
  %6 = getelementptr i8, i8* %4, i32 1
  br label %$2
$4:
  %7 = phi i8* [%1, %$2] ; # S
  ret void
}

define void @prName(i64) align 8 {
$1:
; # (let P (push 0 Nm) (while (symByte P) (call $Put @)))
; # (push 0 Nm)
  %1 = alloca i64, i64 2, align 16
  store i64 0, i64* %1
  %2 = getelementptr i64, i64* %1, i32 1
  store i64 %0, i64* %2
; # (while (symByte P) (call $Put @))
  br label %$2
$2:
; # (symByte P)
  %3 = call i8 @symByte(i64* %1)
  %4 = icmp ne i8 %3, 0
  br i1 %4, label %$3, label %$4
$3:
; # (call $Put @)
  %5 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %5(i8 %3)
  br label %$2
$4:
  ret void
}

define void @prSym(i64) align 8 {
$1:
; # (tail Sym)
  %1 = add i64 %0, -8
; # (val (tail Sym))
  %2 = inttoptr i64 %1 to i64*
  %3 = load i64, i64* %2
; # (name (val (tail Sym)))
  br label %$2
$2:
  %4 = phi i64 [%3, %$1], [%10, %$3] ; # Tail
  %5 = and i64 %4, 6
  %6 = icmp ne i64 %5, 0
  br i1 %6, label %$4, label %$3
$3:
  %7 = phi i64 [%4, %$2] ; # Tail
  %8 = inttoptr i64 %7 to i64*
  %9 = getelementptr i64, i64* %8, i32 1
  %10 = load i64, i64* %9
  br label %$2
$4:
  %11 = phi i64 [%4, %$2] ; # Tail
; # (prName (name (val (tail Sym))))
  call void @prName(i64 %11)
  ret void
}

define void @printName(i64) align 8 {
$1:
; # (ifn (== Nm (hex "2E2")) (let (P (push 0 Nm) B (symByte P)) (when...
; # (== Nm (hex "2E2"))
  %1 = icmp eq i64 %0, 738
  br i1 %1, label %$3, label %$2
$2:
; # (let (P (push 0 Nm) B (symByte P)) (when (== B (char "#")) (call ...
; # (push 0 Nm)
  %2 = alloca i64, i64 2, align 16
  store i64 0, i64* %2
  %3 = getelementptr i64, i64* %2, i32 1
  store i64 %0, i64* %3
; # (symByte P)
  %4 = call i8 @symByte(i64* %2)
; # (when (== B (char "#")) (call $Put (char "\\")))
; # (== B (char "#"))
  %5 = icmp eq i8 %4, 35
  br i1 %5, label %$5, label %$6
$5:
  %6 = phi i8 [%4, %$2] ; # B
; # (call $Put (char "\\"))
  %7 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %7(i8 92)
  br label %$6
$6:
  %8 = phi i8 [%4, %$2], [%6, %$5] ; # B
; # (loop (if (or (== B 127) (> 32 B)) (prog (call $Put (char "\\")) ...
  br label %$7
$7:
  %9 = phi i8 [%8, %$6], [%34, %$17] ; # B
; # (if (or (== B 127) (> 32 B)) (prog (call $Put (char "\\")) (outWo...
; # (or (== B 127) (> 32 B))
; # (== B 127)
  %10 = icmp eq i8 %9, 127
  br i1 %10, label %$8, label %$9
$9:
  %11 = phi i8 [%9, %$7] ; # B
; # (> 32 B)
  %12 = icmp ugt i8 32, %11
  br label %$8
$8:
  %13 = phi i8 [%9, %$7], [%11, %$9] ; # B
  %14 = phi i1 [1, %$7], [%12, %$9] ; # ->
  br i1 %14, label %$10, label %$11
$10:
  %15 = phi i8 [%13, %$8] ; # B
; # (call $Put (char "\\"))
  %16 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %16(i8 92)
; # (i64 B)
  %17 = zext i8 %15 to i64
; # (outWord (i64 B))
  call void @outWord(i64 %17)
; # (call $Put (char "\\"))
  %18 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %18(i8 92)
  br label %$12
$11:
  %19 = phi i8 [%13, %$8] ; # B
; # (when (or (== B (char "\\")) (strchr $Delim (i32 B))) (call $Put ...
; # (or (== B (char "\\")) (strchr $Delim (i32 B)))
; # (== B (char "\\"))
  %20 = icmp eq i8 %19, 92
  br i1 %20, label %$13, label %$14
$14:
  %21 = phi i8 [%19, %$11] ; # B
; # (i32 B)
  %22 = zext i8 %21 to i32
; # (strchr $Delim (i32 B))
  %23 = call i8* @strchr(i8* bitcast ([16 x i8]* @$Delim to i8*), i32 %22)
  %24 = icmp ne i8* %23, null
  br label %$13
$13:
  %25 = phi i8 [%19, %$11], [%21, %$14] ; # B
  %26 = phi i1 [1, %$11], [%24, %$14] ; # ->
  br i1 %26, label %$15, label %$16
$15:
  %27 = phi i8 [%25, %$13] ; # B
; # (call $Put (char "\\"))
  %28 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %28(i8 92)
  br label %$16
$16:
  %29 = phi i8 [%25, %$13], [%27, %$15] ; # B
; # (call $Put B)
  %30 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %30(i8 %29)
  br label %$12
$12:
  %31 = phi i8 [%15, %$10], [%29, %$16] ; # B
; # (? (=0 (setq B (symByte P))))
; # (symByte P)
  %32 = call i8 @symByte(i64* %2)
; # (=0 (setq B (symByte P)))
  %33 = icmp eq i8 %32, 0
  br i1 %33, label %$18, label %$17
$17:
  %34 = phi i8 [%32, %$12] ; # B
  br label %$7
$18:
  %35 = phi i8 [%32, %$12] ; # B
  %36 = phi i64 [0, %$12] ; # ->
  br label %$4
$3:
; # (call $Put (char "\\"))
  %37 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %37(i8 92)
; # (call $Put (char "."))
  %38 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %38(i8 46)
  br label %$4
$4:
  ret void
}

define void @printSym(i64) align 8 {
$1:
; # (tail Sym)
  %1 = add i64 %0, -8
; # (val (tail Sym))
  %2 = inttoptr i64 %1 to i64*
  %3 = load i64, i64* %2
; # (name (val (tail Sym)))
  br label %$2
$2:
  %4 = phi i64 [%3, %$1], [%10, %$3] ; # Tail
  %5 = and i64 %4, 6
  %6 = icmp ne i64 %5, 0
  br i1 %6, label %$4, label %$3
$3:
  %7 = phi i64 [%4, %$2] ; # Tail
  %8 = inttoptr i64 %7 to i64*
  %9 = getelementptr i64, i64* %8, i32 1
  %10 = load i64, i64* %9
  br label %$2
$4:
  %11 = phi i64 [%4, %$2] ; # Tail
; # (printName (name (val (tail Sym))))
  call void @printName(i64 %11)
  ret void
}

define void @print(i64) align 8 {
$1:
; # (sigChk 0)
  %1 = load volatile i32, i32* bitcast ([16 x i32]* @$Signal to i32*)
  %2 = icmp ne i32 %1, 0
  br i1 %2, label %$2, label %$3
$2:
  call void @sighandler(i64 0)
  br label %$3
$3:
; # (cond ((cnt? X) (outNum X)) ((big? X) (fmtNum X 0 0 0 null)) ((sy...
; # (cnt? X)
  %3 = and i64 %0, 2
  %4 = icmp ne i64 %3, 0
  br i1 %4, label %$6, label %$5
$6:
  %5 = phi i64 [%0, %$3] ; # X
; # (outNum X)
  call void @outNum(i64 %5)
  br label %$4
$5:
  %6 = phi i64 [%0, %$3] ; # X
; # (big? X)
  %7 = and i64 %6, 4
  %8 = icmp ne i64 %7, 0
  br i1 %8, label %$8, label %$7
$8:
  %9 = phi i64 [%6, %$5] ; # X
; # (fmtNum X 0 0 0 null)
  %10 = call i64 @fmtNum(i64 %9, i64 0, i8 0, i8 0, i64* null)
  br label %$4
$7:
  %11 = phi i64 [%6, %$5] ; # X
; # (sym? X)
  %12 = and i64 %11, 8
  %13 = icmp ne i64 %12, 0
  br i1 %13, label %$10, label %$9
$10:
  %14 = phi i64 [%11, %$7] ; # X
; # (cond ((sym? (val (tail X))) (call $Put (char "{")) (prExt (name ...
; # (tail X)
  %15 = add i64 %14, -8
; # (val (tail X))
  %16 = inttoptr i64 %15 to i64*
  %17 = load i64, i64* %16
; # (sym? (val (tail X)))
  %18 = and i64 %17, 8
  %19 = icmp ne i64 %18, 0
  br i1 %19, label %$13, label %$12
$13:
  %20 = phi i64 [%14, %$10] ; # X
; # (call $Put (char "{"))
  %21 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %21(i8 123)
; # (& @ -9)
  %22 = and i64 %17, -9
; # (name (& @ -9))
  br label %$14
$14:
  %23 = phi i64 [%22, %$13], [%29, %$15] ; # Tail
  %24 = and i64 %23, 6
  %25 = icmp ne i64 %24, 0
  br i1 %25, label %$16, label %$15
$15:
  %26 = phi i64 [%23, %$14] ; # Tail
  %27 = inttoptr i64 %26 to i64*
  %28 = getelementptr i64, i64* %27, i32 1
  %29 = load i64, i64* %28
  br label %$14
$16:
  %30 = phi i64 [%23, %$14] ; # Tail
; # (prExt (name (& @ -9)))
  call void @prExt(i64 %30)
; # (call $Put (char "}"))
  %31 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %31(i8 125)
  br label %$11
$12:
  %32 = phi i64 [%14, %$10] ; # X
; # (name @)
  br label %$17
$17:
  %33 = phi i64 [%17, %$12], [%39, %$18] ; # Tail
  %34 = and i64 %33, 6
  %35 = icmp ne i64 %34, 0
  br i1 %35, label %$19, label %$18
$18:
  %36 = phi i64 [%33, %$17] ; # Tail
  %37 = inttoptr i64 %36 to i64*
  %38 = getelementptr i64, i64* %37, i32 1
  %39 = load i64, i64* %38
  br label %$17
$19:
  %40 = phi i64 [%33, %$17] ; # Tail
; # (== (name @) ZERO)
  %41 = icmp eq i64 %40, 2
  br i1 %41, label %$21, label %$20
$21:
  %42 = phi i64 [%32, %$19] ; # X
; # (call $Put (char "$"))
  %43 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %43(i8 36)
; # (int X)
  %44 = lshr i64 %42, 4
; # (outOct (int X))
  call void @outOct(i64 %44)
  br label %$11
$20:
  %45 = phi i64 [%32, %$19] ; # X
; # (let (Nm @ Prv (isIntern Nm $PrivT)) (ifn (== X Prv) (let (Lst (v...
; # (isIntern Nm $PrivT)
  %46 = call i64 @isIntern(i64 %40, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 112) to i64))
; # (ifn (== X Prv) (let (Lst (val $Intern) F NO) (loop (? (atom Lst)...
; # (== X Prv)
  %47 = icmp eq i64 %45, %46
  br i1 %47, label %$23, label %$22
$22:
  %48 = phi i64 [%45, %$20] ; # X
; # (let (Lst (val $Intern) F NO) (loop (? (atom Lst) (call $Put (cha...
; # (val $Intern)
  %49 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 0) to i64) to i64*
  %50 = load i64, i64* %49
; # (loop (? (atom Lst) (call $Put (char "\"")) (let (P (push 0 Nm) B...
  br label %$25
$25:
  %51 = phi i64 [%48, %$22], [%167, %$43] ; # X
  %52 = phi i64 [%50, %$22], [%172, %$43] ; # Lst
  %53 = phi i1 [0, %$22], [%169, %$43] ; # F
; # (? (atom Lst) (call $Put (char "\"")) (let (P (push 0 Nm) B (symB...
; # (atom Lst)
  %54 = and i64 %52, 15
  %55 = icmp ne i64 %54, 0
  br i1 %55, label %$28, label %$26
$28:
  %56 = phi i64 [%51, %$25] ; # X
  %57 = phi i64 [%52, %$25] ; # Lst
  %58 = phi i1 [%53, %$25] ; # F
; # (call $Put (char "\""))
  %59 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %59(i8 34)
; # (let (P (push 0 Nm) B (symByte P)) (loop (cond ((or (== B (char "...
; # (push 0 Nm)
  %60 = alloca i64, i64 2, align 16
  store i64 0, i64* %60
  %61 = getelementptr i64, i64* %60, i32 1
  store i64 %40, i64* %61
; # (symByte P)
  %62 = call i8 @symByte(i64* %60)
; # (loop (cond ((or (== B (char "\\")) (== B (char "\^")) (== B (cha...
  br label %$29
$29:
  %63 = phi i64 [%56, %$28], [%120, %$40] ; # X
  %64 = phi i64 [%57, %$28], [%121, %$40] ; # Lst
  %65 = phi i1 [%58, %$28], [%122, %$40] ; # F
  %66 = phi i8 [%62, %$28], [%123, %$40] ; # B
; # (cond ((or (== B (char "\\")) (== B (char "\^")) (== B (char "\""...
; # (or (== B (char "\\")) (== B (char "\^")) (== B (char "\"")))
; # (== B (char "\\"))
  %67 = icmp eq i8 %66, 92
  br i1 %67, label %$31, label %$32
$32:
  %68 = phi i64 [%63, %$29] ; # X
  %69 = phi i64 [%64, %$29] ; # Lst
  %70 = phi i1 [%65, %$29] ; # F
  %71 = phi i8 [%66, %$29] ; # B
; # (== B (char "\^"))
  %72 = icmp eq i8 %71, 94
  br i1 %72, label %$31, label %$33
$33:
  %73 = phi i64 [%68, %$32] ; # X
  %74 = phi i64 [%69, %$32] ; # Lst
  %75 = phi i1 [%70, %$32] ; # F
  %76 = phi i8 [%71, %$32] ; # B
; # (== B (char "\""))
  %77 = icmp eq i8 %76, 34
  br label %$31
$31:
  %78 = phi i64 [%63, %$29], [%68, %$32], [%73, %$33] ; # X
  %79 = phi i64 [%64, %$29], [%69, %$32], [%74, %$33] ; # Lst
  %80 = phi i1 [%65, %$29], [%70, %$32], [%75, %$33] ; # F
  %81 = phi i8 [%66, %$29], [%71, %$32], [%76, %$33] ; # B
  %82 = phi i1 [1, %$29], [1, %$32], [%77, %$33] ; # ->
  br i1 %82, label %$35, label %$34
$35:
  %83 = phi i64 [%78, %$31] ; # X
  %84 = phi i64 [%79, %$31] ; # Lst
  %85 = phi i1 [%80, %$31] ; # F
  %86 = phi i8 [%81, %$31] ; # B
; # (call $Put (char "\\"))
  %87 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %87(i8 92)
  br label %$30
$34:
  %88 = phi i64 [%78, %$31] ; # X
  %89 = phi i64 [%79, %$31] ; # Lst
  %90 = phi i1 [%80, %$31] ; # F
  %91 = phi i8 [%81, %$31] ; # B
; # (== B 127)
  %92 = icmp eq i8 %91, 127
  br i1 %92, label %$37, label %$36
$37:
  %93 = phi i64 [%88, %$34] ; # X
  %94 = phi i64 [%89, %$34] ; # Lst
  %95 = phi i1 [%90, %$34] ; # F
  %96 = phi i8 [%91, %$34] ; # B
; # (call $Put (char "\^"))
  %97 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %97(i8 94)
  br label %$30
$36:
  %98 = phi i64 [%88, %$34] ; # X
  %99 = phi i64 [%89, %$34] ; # Lst
  %100 = phi i1 [%90, %$34] ; # F
  %101 = phi i8 [%91, %$34] ; # B
; # (> 32 B)
  %102 = icmp ugt i8 32, %101
  br i1 %102, label %$39, label %$38
$39:
  %103 = phi i64 [%98, %$36] ; # X
  %104 = phi i64 [%99, %$36] ; # Lst
  %105 = phi i1 [%100, %$36] ; # F
  %106 = phi i8 [%101, %$36] ; # B
; # (call $Put (char "\^"))
  %107 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %107(i8 94)
; # (| B 64)
  %108 = or i8 %106, 64
  br label %$30
$38:
  %109 = phi i64 [%98, %$36] ; # X
  %110 = phi i64 [%99, %$36] ; # Lst
  %111 = phi i1 [%100, %$36] ; # F
  %112 = phi i8 [%101, %$36] ; # B
  br label %$30
$30:
  %113 = phi i64 [%83, %$35], [%93, %$37], [%103, %$39], [%109, %$38] ; # X
  %114 = phi i64 [%84, %$35], [%94, %$37], [%104, %$39], [%110, %$38] ; # Lst
  %115 = phi i1 [%85, %$35], [%95, %$37], [%105, %$39], [%111, %$38] ; # F
  %116 = phi i8 [%86, %$35], [63, %$37], [%108, %$39], [%112, %$38] ; # B
; # (call $Put B)
  %117 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %117(i8 %116)
; # (? (=0 (setq B (symByte P))))
; # (symByte P)
  %118 = call i8 @symByte(i64* %60)
; # (=0 (setq B (symByte P)))
  %119 = icmp eq i8 %118, 0
  br i1 %119, label %$41, label %$40
$40:
  %120 = phi i64 [%113, %$30] ; # X
  %121 = phi i64 [%114, %$30] ; # Lst
  %122 = phi i1 [%115, %$30] ; # F
  %123 = phi i8 [%118, %$30] ; # B
  br label %$29
$41:
  %124 = phi i64 [%113, %$30] ; # X
  %125 = phi i64 [%114, %$30] ; # Lst
  %126 = phi i1 [%115, %$30] ; # F
  %127 = phi i8 [%118, %$30] ; # B
  %128 = phi i64 [0, %$30] ; # ->
; # (call $Put (char "\""))
  %129 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %129(i8 34)
  br label %$27
$26:
  %130 = phi i64 [%51, %$25] ; # X
  %131 = phi i64 [%52, %$25] ; # Lst
  %132 = phi i1 [%53, %$25] ; # F
; # (let Nsp (car Lst) (when (isIntern Nm (cdar Nsp)) (? (== @ X) (wh...
; # (car Lst)
  %133 = inttoptr i64 %131 to i64*
  %134 = load i64, i64* %133
; # (when (isIntern Nm (cdar Nsp)) (? (== @ X) (when (or Prv F) (prin...
; # (cdar Nsp)
  %135 = inttoptr i64 %134 to i64*
  %136 = load i64, i64* %135
  %137 = inttoptr i64 %136 to i64*
  %138 = getelementptr i64, i64* %137, i32 1
  %139 = load i64, i64* %138
; # (isIntern Nm (cdar Nsp))
  %140 = call i64 @isIntern(i64 %40, i64 %139)
  %141 = icmp ne i64 %140, 0
  br i1 %141, label %$42, label %$43
$42:
  %142 = phi i64 [%130, %$26] ; # X
  %143 = phi i64 [%131, %$26] ; # Lst
  %144 = phi i1 [%132, %$26] ; # F
; # (? (== @ X) (when (or Prv F) (printSym Nsp) (call $Put (char "~")...
; # (== @ X)
  %145 = icmp eq i64 %140, %142
  br i1 %145, label %$45, label %$44
$45:
  %146 = phi i64 [%142, %$42] ; # X
  %147 = phi i64 [%143, %$42] ; # Lst
  %148 = phi i1 [%144, %$42] ; # F
; # (when (or Prv F) (printSym Nsp) (call $Put (char "~")))
; # (or Prv F)
  %149 = icmp ne i64 %46, 0
  br i1 %149, label %$46, label %$47
$47:
  %150 = phi i64 [%146, %$45] ; # X
  %151 = phi i64 [%147, %$45] ; # Lst
  %152 = phi i1 [%148, %$45] ; # F
  br label %$46
$46:
  %153 = phi i64 [%146, %$45], [%150, %$47] ; # X
  %154 = phi i64 [%147, %$45], [%151, %$47] ; # Lst
  %155 = phi i1 [%148, %$45], [%152, %$47] ; # F
  %156 = phi i1 [1, %$45], [%152, %$47] ; # ->
  br i1 %156, label %$48, label %$49
$48:
  %157 = phi i64 [%153, %$46] ; # X
  %158 = phi i64 [%154, %$46] ; # Lst
  %159 = phi i1 [%155, %$46] ; # F
; # (printSym Nsp)
  call void @printSym(i64 %134)
; # (call $Put (char "~"))
  %160 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %160(i8 126)
  br label %$49
$49:
  %161 = phi i64 [%153, %$46], [%157, %$48] ; # X
  %162 = phi i64 [%154, %$46], [%158, %$48] ; # Lst
  %163 = phi i1 [%155, %$46], [%159, %$48] ; # F
; # (printName Nm)
  call void @printName(i64 %40)
  br label %$27
$44:
  %164 = phi i64 [%142, %$42] ; # X
  %165 = phi i64 [%143, %$42] ; # Lst
  %166 = phi i1 [%144, %$42] ; # F
  br label %$43
$43:
  %167 = phi i64 [%130, %$26], [%164, %$44] ; # X
  %168 = phi i64 [%131, %$26], [%165, %$44] ; # Lst
  %169 = phi i1 [%132, %$26], [1, %$44] ; # F
; # (shift Lst)
  %170 = inttoptr i64 %168 to i64*
  %171 = getelementptr i64, i64* %170, i32 1
  %172 = load i64, i64* %171
  br label %$25
$27:
  %173 = phi i64 [%124, %$41], [%161, %$49] ; # X
  %174 = phi i64 [%125, %$41], [%162, %$49] ; # Lst
  %175 = phi i1 [%126, %$41], [%163, %$49] ; # F
  br label %$24
$23:
  %176 = phi i64 [%45, %$20] ; # X
; # (outString ($ "priv~"))
  call void @outString(i8* bitcast ([6 x i8]* @$46 to i8*))
; # (printName Nm)
  call void @printName(i64 %40)
  br label %$24
$24:
  %177 = phi i64 [%173, %$27], [%176, %$23] ; # X
  br label %$11
$11:
  %178 = phi i64 [%20, %$16], [%42, %$21], [%177, %$24] ; # X
  br label %$4
$9:
  %179 = phi i64 [%11, %$7] ; # X
; # (and (== (car X) $Quote) (<> X (cdr X)))
; # (car X)
  %180 = inttoptr i64 %179 to i64*
  %181 = load i64, i64* %180
; # (== (car X) $Quote)
  %182 = icmp eq i64 %181, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 264) to i64)
  br i1 %182, label %$51, label %$50
$51:
  %183 = phi i64 [%179, %$9] ; # X
; # (cdr X)
  %184 = inttoptr i64 %183 to i64*
  %185 = getelementptr i64, i64* %184, i32 1
  %186 = load i64, i64* %185
; # (<> X (cdr X))
  %187 = icmp ne i64 %183, %186
  br label %$50
$50:
  %188 = phi i64 [%179, %$9], [%183, %$51] ; # X
  %189 = phi i1 [0, %$9], [%187, %$51] ; # ->
  br i1 %189, label %$53, label %$52
$53:
  %190 = phi i64 [%188, %$50] ; # X
; # (call $Put (char "'"))
  %191 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %191(i8 39)
; # (cdr X)
  %192 = inttoptr i64 %190 to i64*
  %193 = getelementptr i64, i64* %192, i32 1
  %194 = load i64, i64* %193
; # (print (cdr X))
  call void @print(i64 %194)
  br label %$4
$52:
  %195 = phi i64 [%188, %$50] ; # X
; # (stkChk 0)
  %196 = load i8*, i8** @$StkLimit
  %197 = call i8* @llvm.stacksave()
  %198 = icmp ugt i8* %196, %197
  br i1 %198, label %$54, label %$55
$54:
  call void @stkErr(i64 0)
  unreachable
$55:
; # (call $Put (char "("))
  %199 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %199(i8 40)
; # (let (P (circ X) Z X) (loop (print (car X)) (? (nil? (shift X))) ...
; # (circ X)
  %200 = call i64 @circ(i64 %195)
; # (loop (print (car X)) (? (nil? (shift X))) (? (atom X) (outString...
  br label %$56
$56:
  %201 = phi i64 [%195, %$55], [%241, %$66] ; # X
  %202 = phi i64 [%200, %$55], [%242, %$66] ; # P
  %203 = phi i64 [%195, %$55], [%243, %$66] ; # Z
; # (car X)
  %204 = inttoptr i64 %201 to i64*
  %205 = load i64, i64* %204
; # (print (car X))
  call void @print(i64 %205)
; # (? (nil? (shift X)))
; # (shift X)
  %206 = inttoptr i64 %201 to i64*
  %207 = getelementptr i64, i64* %206, i32 1
  %208 = load i64, i64* %207
; # (nil? (shift X))
  %209 = icmp eq i64 %208, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %209, label %$58, label %$57
$57:
  %210 = phi i64 [%208, %$56] ; # X
  %211 = phi i64 [%202, %$56] ; # P
  %212 = phi i64 [%203, %$56] ; # Z
; # (? (atom X) (outString ($ " . ")) (print X))
; # (atom X)
  %213 = and i64 %210, 15
  %214 = icmp ne i64 %213, 0
  br i1 %214, label %$60, label %$59
$60:
  %215 = phi i64 [%210, %$57] ; # X
  %216 = phi i64 [%211, %$57] ; # P
  %217 = phi i64 [%212, %$57] ; # Z
; # (outString ($ " . "))
  call void @outString(i8* bitcast ([4 x i8]* @$47 to i8*))
; # (print X)
  call void @print(i64 %215)
  br label %$58
$59:
  %218 = phi i64 [%210, %$57] ; # X
  %219 = phi i64 [%211, %$57] ; # P
  %220 = phi i64 [%212, %$57] ; # Z
; # (space)
  call void @space()
; # (? (== Z X) (call $Put (char ".")) (unless P (call $Put (char ")"...
; # (== Z X)
  %221 = icmp eq i64 %220, %218
  br i1 %221, label %$62, label %$61
$62:
  %222 = phi i64 [%218, %$59] ; # X
  %223 = phi i64 [%219, %$59] ; # P
  %224 = phi i64 [%220, %$59] ; # Z
; # (call $Put (char "."))
  %225 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %225(i8 46)
; # (unless P (call $Put (char ")")))
  %226 = icmp ne i64 %223, 0
  br i1 %226, label %$64, label %$63
$63:
  %227 = phi i64 [%222, %$62] ; # X
  %228 = phi i64 [%223, %$62] ; # P
  %229 = phi i64 [%224, %$62] ; # Z
; # (call $Put (char ")"))
  %230 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %230(i8 41)
  br label %$64
$64:
  %231 = phi i64 [%222, %$62], [%227, %$63] ; # X
  %232 = phi i64 [%223, %$62], [%228, %$63] ; # P
  %233 = phi i64 [%224, %$62], [%229, %$63] ; # Z
  br label %$58
$61:
  %234 = phi i64 [%218, %$59] ; # X
  %235 = phi i64 [%219, %$59] ; # P
  %236 = phi i64 [%220, %$59] ; # Z
; # (when (== P X) (outString ($ ". (")) (setq Z P P 0))
; # (== P X)
  %237 = icmp eq i64 %235, %234
  br i1 %237, label %$65, label %$66
$65:
  %238 = phi i64 [%234, %$61] ; # X
  %239 = phi i64 [%235, %$61] ; # P
  %240 = phi i64 [%236, %$61] ; # Z
; # (outString ($ ". ("))
  call void @outString(i8* bitcast ([4 x i8]* @$48 to i8*))
  br label %$66
$66:
  %241 = phi i64 [%234, %$61], [%238, %$65] ; # X
  %242 = phi i64 [%235, %$61], [0, %$65] ; # P
  %243 = phi i64 [%236, %$61], [%239, %$65] ; # Z
  br label %$56
$58:
  %244 = phi i64 [%208, %$56], [%215, %$60], [%231, %$64] ; # X
  %245 = phi i64 [%202, %$56], [%216, %$60], [%232, %$64] ; # P
  %246 = phi i64 [%203, %$56], [%217, %$60], [%233, %$64] ; # Z
; # (call $Put (char ")"))
  %247 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %247(i8 41)
  br label %$4
$4:
  %248 = phi i64 [%5, %$6], [%9, %$8], [%178, %$11], [%190, %$53], [%244, %$58] ; # X
  ret void
}

define void @prin(i64) align 8 {
$1:
; # (sigChk 0)
  %1 = load volatile i32, i32* bitcast ([16 x i32]* @$Signal to i32*)
  %2 = icmp ne i32 %1, 0
  br i1 %2, label %$2, label %$3
$2:
  call void @sighandler(i64 0)
  br label %$3
$3:
; # (unless (nil? X) (cond ((cnt? X) (outNum X)) ((big? X) (fmtNum X ...
; # (nil? X)
  %3 = icmp eq i64 %0, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %3, label %$5, label %$4
$4:
  %4 = phi i64 [%0, %$3] ; # X
; # (cond ((cnt? X) (outNum X)) ((big? X) (fmtNum X 0 0 0 null)) ((pa...
; # (cnt? X)
  %5 = and i64 %4, 2
  %6 = icmp ne i64 %5, 0
  br i1 %6, label %$8, label %$7
$8:
  %7 = phi i64 [%4, %$4] ; # X
; # (outNum X)
  call void @outNum(i64 %7)
  br label %$6
$7:
  %8 = phi i64 [%4, %$4] ; # X
; # (big? X)
  %9 = and i64 %8, 4
  %10 = icmp ne i64 %9, 0
  br i1 %10, label %$10, label %$9
$10:
  %11 = phi i64 [%8, %$7] ; # X
; # (fmtNum X 0 0 0 null)
  %12 = call i64 @fmtNum(i64 %11, i64 0, i8 0, i8 0, i64* null)
  br label %$6
$9:
  %13 = phi i64 [%8, %$7] ; # X
; # (pair X)
  %14 = and i64 %13, 15
  %15 = icmp eq i64 %14, 0
  br i1 %15, label %$12, label %$11
$12:
  %16 = phi i64 [%13, %$9] ; # X
; # (stkChk 0)
  %17 = load i8*, i8** @$StkLimit
  %18 = call i8* @llvm.stacksave()
  %19 = icmp ugt i8* %17, %18
  br i1 %19, label %$13, label %$14
$13:
  call void @stkErr(i64 0)
  unreachable
$14:
; # (loop (prin (car X)) (? (nil? (shift X))) (? (atom X) (prin X)))
  br label %$15
$15:
  %20 = phi i64 [%16, %$14], [%31, %$18] ; # X
; # (car X)
  %21 = inttoptr i64 %20 to i64*
  %22 = load i64, i64* %21
; # (prin (car X))
  call void @prin(i64 %22)
; # (? (nil? (shift X)))
; # (shift X)
  %23 = inttoptr i64 %20 to i64*
  %24 = getelementptr i64, i64* %23, i32 1
  %25 = load i64, i64* %24
; # (nil? (shift X))
  %26 = icmp eq i64 %25, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %26, label %$17, label %$16
$16:
  %27 = phi i64 [%25, %$15] ; # X
; # (? (atom X) (prin X))
; # (atom X)
  %28 = and i64 %27, 15
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %$19, label %$18
$19:
  %30 = phi i64 [%27, %$16] ; # X
; # (prin X)
  call void @prin(i64 %30)
  br label %$17
$18:
  %31 = phi i64 [%27, %$16] ; # X
  br label %$15
$17:
  %32 = phi i64 [%25, %$15], [%30, %$19] ; # X
  br label %$6
$11:
  %33 = phi i64 [%13, %$9] ; # X
; # (tail X)
  %34 = add i64 %33, -8
; # (val (tail X))
  %35 = inttoptr i64 %34 to i64*
  %36 = load i64, i64* %35
; # (sym? (val (tail X)))
  %37 = and i64 %36, 8
  %38 = icmp ne i64 %37, 0
  br i1 %38, label %$21, label %$20
$21:
  %39 = phi i64 [%33, %$11] ; # X
; # (call $Put (char "{"))
  %40 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %40(i8 123)
; # (& @ -9)
  %41 = and i64 %36, -9
; # (name (& @ -9))
  br label %$22
$22:
  %42 = phi i64 [%41, %$21], [%48, %$23] ; # Tail
  %43 = and i64 %42, 6
  %44 = icmp ne i64 %43, 0
  br i1 %44, label %$24, label %$23
$23:
  %45 = phi i64 [%42, %$22] ; # Tail
  %46 = inttoptr i64 %45 to i64*
  %47 = getelementptr i64, i64* %46, i32 1
  %48 = load i64, i64* %47
  br label %$22
$24:
  %49 = phi i64 [%42, %$22] ; # Tail
; # (prExt (name (& @ -9)))
  call void @prExt(i64 %49)
; # (call $Put (char "}"))
  %50 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %50(i8 125)
  br label %$6
$20:
  %51 = phi i64 [%33, %$11] ; # X
; # (name @)
  br label %$25
$25:
  %52 = phi i64 [%36, %$20], [%58, %$26] ; # Tail
  %53 = and i64 %52, 6
  %54 = icmp ne i64 %53, 0
  br i1 %54, label %$27, label %$26
$26:
  %55 = phi i64 [%52, %$25] ; # Tail
  %56 = inttoptr i64 %55 to i64*
  %57 = getelementptr i64, i64* %56, i32 1
  %58 = load i64, i64* %57
  br label %$25
$27:
  %59 = phi i64 [%52, %$25] ; # Tail
; # (prName (name @))
  call void @prName(i64 %59)
  br label %$6
$6:
  %60 = phi i64 [%7, %$8], [%11, %$10], [%32, %$17], [%39, %$24], [%51, %$27] ; # X
  br label %$5
$5:
  %61 = phi i64 [%0, %$3], [%60, %$6] ; # X
  ret void
}

define i64 @_Prin(i64) align 8 {
$1:
; # (let X (cdr Exe) (loop (let Y (eval (++ X)) (prin Y) (? (atom X) ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (loop (let Y (eval (++ X)) (prin Y) (? (atom X) Y)))
  br label %$2
$2:
  %4 = phi i64 [%3, %$1], [%20, %$8] ; # X
; # (let Y (eval (++ X)) (prin Y) (? (atom X) Y))
; # (++ X)
  %5 = inttoptr i64 %4 to i64*
  %6 = load i64, i64* %5
  %7 = getelementptr i64, i64* %5, i32 1
  %8 = load i64, i64* %7
; # (eval (++ X))
  %9 = and i64 %6, 6
  %10 = icmp ne i64 %9, 0
  br i1 %10, label %$5, label %$4
$5:
  br label %$3
$4:
  %11 = and i64 %6, 8
  %12 = icmp ne i64 %11, 0
  br i1 %12, label %$7, label %$6
$7:
  %13 = inttoptr i64 %6 to i64*
  %14 = load i64, i64* %13
  br label %$3
$6:
  %15 = call i64 @evList(i64 %6)
  br label %$3
$3:
  %16 = phi i64 [%6, %$5], [%14, %$7], [%15, %$6] ; # ->
; # (prin Y)
  call void @prin(i64 %16)
; # (? (atom X) Y)
; # (atom X)
  %17 = and i64 %8, 15
  %18 = icmp ne i64 %17, 0
  br i1 %18, label %$10, label %$8
$10:
  %19 = phi i64 [%8, %$3] ; # X
  br label %$9
$8:
  %20 = phi i64 [%8, %$3] ; # X
  br label %$2
$9:
  %21 = phi i64 [%19, %$10] ; # X
  %22 = phi i64 [%16, %$10] ; # ->
  ret i64 %22
}

define i64 @_Prinl(i64) align 8 {
$1:
; # (prog1 (_Prin Exe) (newline))
; # (_Prin Exe)
  %1 = call i64 @_Prin(i64 %0)
; # (newline)
  call void @newline()
  ret i64 %1
}

define i64 @_Space(i64) align 8 {
$1:
; # (let X (eval (cadr Exe)) (ifn (nil? X) (let N (xCnt Exe X) (while...
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (ifn (nil? X) (let N (xCnt Exe X) (while (ge0 (dec 'N)) (space)) ...
; # (nil? X)
  %14 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %14, label %$8, label %$7
$7:
; # (let N (xCnt Exe X) (while (ge0 (dec 'N)) (space)) X)
; # (xCnt Exe X)
  %15 = call i64 @xCnt(i64 %0, i64 %13)
; # (while (ge0 (dec 'N)) (space))
  br label %$10
$10:
  %16 = phi i64 [%15, %$7], [%19, %$11] ; # N
; # (dec 'N)
  %17 = sub i64 %16, 1
; # (ge0 (dec 'N))
  %18 = icmp sge i64 %17, 0
  br i1 %18, label %$11, label %$12
$11:
  %19 = phi i64 [%17, %$10] ; # N
; # (space)
  call void @space()
  br label %$10
$12:
  %20 = phi i64 [%17, %$10] ; # N
  br label %$9
$8:
; # (space)
  call void @space()
  br label %$9
$9:
  %21 = phi i64 [%13, %$12], [18, %$8] ; # ->
  ret i64 %21
}

define i64 @_Print(i64) align 8 {
$1:
; # (let X (cdr Exe) (loop (let Y (eval (++ X)) (print Y) (? (atom X)...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (loop (let Y (eval (++ X)) (print Y) (? (atom X) Y) (space)))
  br label %$2
$2:
  %4 = phi i64 [%3, %$1], [%20, %$8] ; # X
; # (let Y (eval (++ X)) (print Y) (? (atom X) Y) (space))
; # (++ X)
  %5 = inttoptr i64 %4 to i64*
  %6 = load i64, i64* %5
  %7 = getelementptr i64, i64* %5, i32 1
  %8 = load i64, i64* %7
; # (eval (++ X))
  %9 = and i64 %6, 6
  %10 = icmp ne i64 %9, 0
  br i1 %10, label %$5, label %$4
$5:
  br label %$3
$4:
  %11 = and i64 %6, 8
  %12 = icmp ne i64 %11, 0
  br i1 %12, label %$7, label %$6
$7:
  %13 = inttoptr i64 %6 to i64*
  %14 = load i64, i64* %13
  br label %$3
$6:
  %15 = call i64 @evList(i64 %6)
  br label %$3
$3:
  %16 = phi i64 [%6, %$5], [%14, %$7], [%15, %$6] ; # ->
; # (print Y)
  call void @print(i64 %16)
; # (? (atom X) Y)
; # (atom X)
  %17 = and i64 %8, 15
  %18 = icmp ne i64 %17, 0
  br i1 %18, label %$10, label %$8
$10:
  %19 = phi i64 [%8, %$3] ; # X
  br label %$9
$8:
  %20 = phi i64 [%8, %$3] ; # X
; # (space)
  call void @space()
  br label %$2
$9:
  %21 = phi i64 [%19, %$10] ; # X
  %22 = phi i64 [%16, %$10] ; # ->
  ret i64 %22
}

define i64 @_Printsp(i64) align 8 {
$1:
; # (prog1 (_Print Exe) (space))
; # (_Print Exe)
  %1 = call i64 @_Print(i64 %0)
; # (space)
  call void @space()
  ret i64 %1
}

define i64 @_Println(i64) align 8 {
$1:
; # (prog1 (_Print Exe) (newline))
; # (_Print Exe)
  %1 = call i64 @_Print(i64 %0)
; # (newline)
  call void @newline()
  ret i64 %1
}

define i64 @_Flush(i64) align 8 {
$1:
; # (if (flush (val $OutFile)) $T $Nil)
; # (val $OutFile)
  %1 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 80) to i8**)
; # (flush (val $OutFile))
  %2 = call i1 @flush(i8* %1)
  br i1 %2, label %$2, label %$3
$2:
  br label %$4
$3:
  br label %$4
$4:
  %3 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$2], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$3] ; # ->
  ret i64 %3
}

define i64 @_Rewind(i64) align 8 {
$1:
; # (let Out: (outFile (val $OutFile)) (if (and (Out:) (let Fd (Out: ...
; # (val $OutFile)
  %1 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 80) to i8**)
; # (if (and (Out:) (let Fd (Out: fd) (Out: ix 0) (and (seek0 Fd) (tr...
; # (and (Out:) (let Fd (Out: fd) (Out: ix 0) (and (seek0 Fd) (trunca...
; # (Out:)
  %2 = icmp ne i8* %1, null
  br i1 %2, label %$3, label %$2
$3:
; # (let Fd (Out: fd) (Out: ix 0) (and (seek0 Fd) (truncate0 Fd)))
; # (Out: fd)
  %3 = bitcast i8* %1 to i32*
  %4 = load i32, i32* %3
; # (Out: ix 0)
  %5 = getelementptr i8, i8* %1, i32 4
  %6 = bitcast i8* %5 to i32*
  store i32 0, i32* %6
; # (and (seek0 Fd) (truncate0 Fd))
; # (seek0 Fd)
  %7 = call i1 @seek0(i32 %4)
  br i1 %7, label %$5, label %$4
$5:
; # (truncate0 Fd)
  %8 = call i1 @truncate0(i32 %4)
  br label %$4
$4:
  %9 = phi i1 [0, %$3], [%8, %$5] ; # ->
  br label %$2
$2:
  %10 = phi i1 [0, %$1], [%9, %$4] ; # ->
  br i1 %10, label %$6, label %$7
$6:
  br label %$8
$7:
  br label %$8
$8:
  %11 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$6], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$7] ; # ->
  ret i64 %11
}

define i64 @_Ext(i64) align 8 {
$1:
; # (let (X (cdr Exe) N (evCnt Exe X) Old (val $ExtN)) (set $ExtN (i3...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (evCnt Exe X)
  %4 = call i64 @evCnt(i64 %0, i64 %3)
; # (val $ExtN)
  %5 = load i32, i32* @$ExtN
; # (set $ExtN (i32 N))
; # (i32 N)
  %6 = trunc i64 %4 to i32
  store i32 %6, i32* @$ExtN
; # (prog1 (run (cdr X)) (set $ExtN Old))
; # (cdr X)
  %7 = inttoptr i64 %3 to i64*
  %8 = getelementptr i64, i64* %7, i32 1
  %9 = load i64, i64* %8
; # (run (cdr X))
  br label %$2
$2:
  %10 = phi i64 [%9, %$1], [%32, %$11] ; # Prg
  %11 = inttoptr i64 %10 to i64*
  %12 = load i64, i64* %11
  %13 = getelementptr i64, i64* %11, i32 1
  %14 = load i64, i64* %13
  %15 = and i64 %14, 15
  %16 = icmp ne i64 %15, 0
  br i1 %16, label %$5, label %$3
$5:
  %17 = phi i64 [%14, %$2] ; # Prg
  %18 = and i64 %12, 6
  %19 = icmp ne i64 %18, 0
  br i1 %19, label %$8, label %$7
$8:
  br label %$6
$7:
  %20 = and i64 %12, 8
  %21 = icmp ne i64 %20, 0
  br i1 %21, label %$10, label %$9
$10:
  %22 = inttoptr i64 %12 to i64*
  %23 = load i64, i64* %22
  br label %$6
$9:
  %24 = call i64 @evList(i64 %12)
  br label %$6
$6:
  %25 = phi i64 [%12, %$8], [%23, %$10], [%24, %$9] ; # ->
  br label %$4
$3:
  %26 = phi i64 [%14, %$2] ; # Prg
  %27 = and i64 %12, 15
  %28 = icmp eq i64 %27, 0
  br i1 %28, label %$12, label %$11
$12:
  %29 = phi i64 [%26, %$3] ; # Prg
  %30 = call i64 @evList(i64 %12)
  %31 = icmp ne i64 %30, 0
  br label %$11
$11:
  %32 = phi i64 [%26, %$3], [%29, %$12] ; # Prg
  %33 = phi i1 [0, %$3], [%31, %$12] ; # ->
  br label %$2
$4:
  %34 = phi i64 [%17, %$6] ; # Prg
  %35 = phi i64 [%25, %$6] ; # ->
; # (set $ExtN Old)
  store i32 %5, i32* @$ExtN
  ret i64 %35
}

define i32 @getPlio() align 8 {
$1:
; # (let P (val $Ptr) (set $Ptr (inc P)) (i32 (val P)))
; # (val $Ptr)
  %0 = load i8*, i8** @$Ptr
; # (set $Ptr (inc P))
; # (inc P)
  %1 = getelementptr i8, i8* %0, i32 1
  store i8* %1, i8** @$Ptr
; # (val P)
  %2 = load i8, i8* %0
; # (i32 (val P))
  %3 = zext i8 %2 to i32
  ret i32 %3
}

define void @putPlio(i8) align 8 {
$1:
; # (let P (val $Ptr) (set P B) (when (== (set $Ptr (inc P)) (val $En...
; # (val $Ptr)
  %1 = load i8*, i8** @$Ptr
; # (set P B)
  store i8 %0, i8* %1
; # (when (== (set $Ptr (inc P)) (val $End)) (sizeErr 0))
; # (set $Ptr (inc P))
; # (inc P)
  %2 = getelementptr i8, i8* %1, i32 1
  store i8* %2, i8** @$Ptr
; # (val $End)
  %3 = load i8*, i8** @$End
; # (== (set $Ptr (inc P)) (val $End))
  %4 = icmp eq i8* %2, %3
  br i1 %4, label %$2, label %$3
$2:
; # (sizeErr 0)
  call void @sizeErr(i64 0)
  unreachable
$3:
  ret void
}

define i64 @_Plio(i64) align 8 {
$1:
; # (let (X (cdr Exe) P (i8* (if (cnt? (needNum Exe (eval (++ X)))) (...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (if (cnt? (needNum Exe (eval (++ X)))) (int @) (val (dig @)))
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (needNum Exe (eval (++ X)))
  %16 = and i64 %15, 6
  %17 = icmp ne i64 %16, 0
  br i1 %17, label %$8, label %$7
$7:
  call void @numErr(i64 %0, i64 %15)
  unreachable
$8:
; # (cnt? (needNum Exe (eval (++ X))))
  %18 = and i64 %15, 2
  %19 = icmp ne i64 %18, 0
  br i1 %19, label %$9, label %$10
$9:
  %20 = phi i64 [%7, %$8] ; # X
; # (int @)
  %21 = lshr i64 %15, 4
  br label %$11
$10:
  %22 = phi i64 [%7, %$8] ; # X
; # (dig @)
  %23 = add i64 %15, -4
; # (val (dig @))
  %24 = inttoptr i64 %23 to i64*
  %25 = load i64, i64* %24
  br label %$11
$11:
  %26 = phi i64 [%20, %$9], [%22, %$10] ; # X
  %27 = phi i64 [%21, %$9], [%25, %$10] ; # ->
; # (i8* (if (cnt? (needNum Exe (eval (++ X)))) (int @) (val (dig @))...
  %28 = inttoptr i64 %27 to i8*
; # (let (Ptr (val $Ptr) End (val $End)) (set $Extn (val $ExtN) $Ptr ...
; # (val $Ptr)
  %29 = load i8*, i8** @$Ptr
; # (val $End)
  %30 = load i8*, i8** @$End
; # (set $Extn (val $ExtN) $Ptr P)
; # (val $ExtN)
  %31 = load i32, i32* @$ExtN
  store i32 %31, i32* @$Extn
  store i8* %28, i8** @$Ptr
; # (prog1 (if (pair X) (let (N (evCnt Exe X) Y (eval (car (shift X))...
; # (if (pair X) (let (N (evCnt Exe X) Y (eval (car (shift X)))) (set...
; # (pair X)
  %32 = and i64 %26, 15
  %33 = icmp eq i64 %32, 0
  br i1 %33, label %$12, label %$13
$12:
  %34 = phi i64 [%26, %$11] ; # X
; # (let (N (evCnt Exe X) Y (eval (car (shift X)))) (set $PutBin (fun...
; # (evCnt Exe X)
  %35 = call i64 @evCnt(i64 %0, i64 %34)
; # (shift X)
  %36 = inttoptr i64 %34 to i64*
  %37 = getelementptr i64, i64* %36, i32 1
  %38 = load i64, i64* %37
; # (car (shift X))
  %39 = inttoptr i64 %38 to i64*
  %40 = load i64, i64* %39
; # (eval (car (shift X)))
  %41 = and i64 %40, 6
  %42 = icmp ne i64 %41, 0
  br i1 %42, label %$17, label %$16
$17:
  br label %$15
$16:
  %43 = and i64 %40, 8
  %44 = icmp ne i64 %43, 0
  br i1 %44, label %$19, label %$18
$19:
  %45 = inttoptr i64 %40 to i64*
  %46 = load i64, i64* %45
  br label %$15
$18:
  %47 = call i64 @evList(i64 %40)
  br label %$15
$15:
  %48 = phi i64 [%40, %$17], [%46, %$19], [%47, %$18] ; # ->
; # (set $PutBin (fun (void i8) putPlio) $End (ofs P N))
; # (fun (void i8) putPlio)
  store void(i8)* @putPlio, void(i8)** @$PutBin
; # (ofs P N)
  %49 = getelementptr i8, i8* %28, i64 %35
  store i8* %49, i8** @$End
; # (binPrint Y)
  call void @binPrint(i64 %48)
; # (val $Ptr)
  %50 = load i8*, i8** @$Ptr
; # (- (val $Ptr) P)
  %51 = ptrtoint i8* %50 to i64
  %52 = ptrtoint i8* %28 to i64
  %53 = sub i64 %51, %52
; # (cnt (- (val $Ptr) P))
  %54 = shl i64 %53, 4
  %55 = or i64 %54, 2
  br label %$14
$13:
  %56 = phi i64 [%26, %$11] ; # X
; # (set $GetBin (fun (i32) getPlio))
; # (fun (i32) getPlio)
  store i32()* @getPlio, i32()** @$GetBin
; # (if (binRead) @ $Nil)
; # (binRead)
  %57 = call i64 @binRead()
  %58 = icmp ne i64 %57, 0
  br i1 %58, label %$20, label %$21
$20:
  %59 = phi i64 [%56, %$13] ; # X
  br label %$22
$21:
  %60 = phi i64 [%56, %$13] ; # X
  br label %$22
$22:
  %61 = phi i64 [%59, %$20], [%60, %$21] ; # X
  %62 = phi i64 [%57, %$20], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$21] ; # ->
  br label %$14
$14:
  %63 = phi i64 [%38, %$15], [%61, %$22] ; # X
  %64 = phi i64 [%55, %$15], [%62, %$22] ; # ->
; # (set $Ptr Ptr $End End)
  store i8* %29, i8** @$Ptr
  store i8* %30, i8** @$End
  ret i64 %64
}

define i64 @_Rd(i64) align 8 {
$1:
; # (let X (save (eval (cadr Exe))) (cond ((lt0 ((inFile (val $InFile...
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (save (eval (cadr Exe)))
  %14 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %15 = load i64, i64* %14
  %16 = alloca i64, i64 2, align 16
  %17 = ptrtoint i64* %16 to i64
  %18 = inttoptr i64 %17 to i64*
  store i64 %13, i64* %18
  %19 = add i64 %17, 8
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %17, i64* %21
; # (cond ((lt0 ((inFile (val $InFile)) fd)) $Nil) ((num? X) (let (P ...
; # (val $InFile)
  %22 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 72) to i8**)
; # ((inFile (val $InFile)) fd)
  %23 = getelementptr i8, i8* %22, i32 8
  %24 = bitcast i8* %23 to i32*
  %25 = load i32, i32* %24
; # (lt0 ((inFile (val $InFile)) fd))
  %26 = icmp slt i32 %25, 0
  br i1 %26, label %$9, label %$8
$9:
  br label %$7
$8:
; # (num? X)
  %27 = and i64 %13, 6
  %28 = icmp ne i64 %27, 0
  br i1 %28, label %$11, label %$10
$11:
; # (let (P (push 3 NIL ZERO NIL) Q (link (ofs P 2)) Cnt (int X)) (co...
; # (push 3 NIL ZERO NIL)
  %29 = alloca i64, i64 4, align 16
  store i64 3, i64* %29
  %30 = getelementptr i64, i64* %29, i32 2
  store i64 2, i64* %30
; # (ofs P 2)
  %31 = getelementptr i64, i64* %29, i32 2
; # (link (ofs P 2))
  %32 = ptrtoint i64* %31 to i64
  %33 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %34 = load i64, i64* %33
  %35 = inttoptr i64 %32 to i64*
  %36 = getelementptr i64, i64* %35, i32 1
  store i64 %34, i64* %36
  %37 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %32, i64* %37
; # (int X)
  %38 = lshr i64 %13, 4
; # (cond ((=0 Cnt) $Nil) ((sign? X) (loop (when (lt0 (getBinary)) (:...
; # (=0 Cnt)
  %39 = icmp eq i64 %38, 0
  br i1 %39, label %$14, label %$13
$14:
  %40 = phi i64 [%38, %$11] ; # Cnt
  br label %$12
$13:
  %41 = phi i64 [%38, %$11] ; # Cnt
; # (sign? X)
  %42 = and i64 %13, 8
  %43 = icmp ne i64 %42, 0
  br i1 %43, label %$16, label %$15
$16:
  %44 = phi i64 [%41, %$13] ; # Cnt
; # (loop (when (lt0 (getBinary)) (: 1 (ret $Nil))) (byteNum (i8 @) P...
  br label %$17
$17:
  %45 = phi i64 [%44, %$16], [%58, %$20] ; # Cnt
; # (when (lt0 (getBinary)) (: 1 (ret $Nil)))
; # (getBinary)
  %46 = call i32 @getBinary()
; # (lt0 (getBinary))
  %47 = icmp slt i32 %46, 0
  br i1 %47, label %$18, label %$19
$18:
  %48 = phi i64 [%45, %$17] ; # Cnt
; # (: 1 (ret $Nil))
  br label %$-1
$-1:
  %49 = phi i64 [%48, %$18], [%75, %$26] ; # Cnt
; # (ret $Nil)
; # (drop *Safe)
  %50 = inttoptr i64 %17 to i64*
  %51 = getelementptr i64, i64* %50, i32 1
  %52 = load i64, i64* %51
  %53 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %52, i64* %53
  ret i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
$19:
  %54 = phi i64 [%45, %$17] ; # Cnt
; # (i8 @)
  %55 = trunc i32 %46 to i8
; # (byteNum (i8 @) P)
  call void @byteNum(i8 %55, i64* %29)
; # (? (=0 (dec 'Cnt)))
; # (dec 'Cnt)
  %56 = sub i64 %54, 1
; # (=0 (dec 'Cnt))
  %57 = icmp eq i64 %56, 0
  br i1 %57, label %$21, label %$20
$20:
  %58 = phi i64 [%56, %$19] ; # Cnt
  br label %$17
$21:
  %59 = phi i64 [%56, %$19] ; # Cnt
  %60 = phi i64 [0, %$19] ; # ->
; # (if (cnt? (val Q)) (twice @) (zapZero @))
; # (val Q)
  %61 = inttoptr i64 %32 to i64*
  %62 = load i64, i64* %61
; # (cnt? (val Q))
  %63 = and i64 %62, 2
  %64 = icmp ne i64 %63, 0
  br i1 %64, label %$22, label %$23
$22:
  %65 = phi i64 [%59, %$21] ; # Cnt
; # (twice @)
  %66 = call i64 @twice(i64 %62)
  br label %$24
$23:
  %67 = phi i64 [%59, %$21] ; # Cnt
; # (zapZero @)
  %68 = call i64 @zapZero(i64 %62)
  br label %$24
$24:
  %69 = phi i64 [%65, %$22], [%67, %$23] ; # Cnt
  %70 = phi i64 [%66, %$22], [%68, %$23] ; # ->
  br label %$12
$15:
  %71 = phi i64 [%41, %$13] ; # Cnt
; # (loop (when (lt0 (getBinary)) (goto 1)) (set Q (addu (cnt (i64 @)...
  br label %$25
$25:
  %72 = phi i64 [%71, %$15], [%88, %$28] ; # Cnt
; # (when (lt0 (getBinary)) (goto 1))
; # (getBinary)
  %73 = call i32 @getBinary()
; # (lt0 (getBinary))
  %74 = icmp slt i32 %73, 0
  br i1 %74, label %$26, label %$27
$26:
  %75 = phi i64 [%72, %$25] ; # Cnt
; # (goto 1)
  br label %$-1
$27:
  %76 = phi i64 [%72, %$25] ; # Cnt
; # (set Q (addu (cnt (i64 @)) (set Q (mulu (val Q) (hex "1002")))))
; # (i64 @)
  %77 = sext i32 %73 to i64
; # (cnt (i64 @))
  %78 = shl i64 %77, 4
  %79 = or i64 %78, 2
; # (set Q (mulu (val Q) (hex "1002")))
; # (val Q)
  %80 = inttoptr i64 %32 to i64*
  %81 = load i64, i64* %80
; # (mulu (val Q) (hex "1002"))
  %82 = call i64 @mulu(i64 %81, i64 4098)
  %83 = inttoptr i64 %32 to i64*
  store i64 %82, i64* %83
; # (addu (cnt (i64 @)) (set Q (mulu (val Q) (hex "1002"))))
  %84 = call i64 @addu(i64 %79, i64 %82)
  %85 = inttoptr i64 %32 to i64*
  store i64 %84, i64* %85
; # (? (=0 (dec 'Cnt)))
; # (dec 'Cnt)
  %86 = sub i64 %76, 1
; # (=0 (dec 'Cnt))
  %87 = icmp eq i64 %86, 0
  br i1 %87, label %$29, label %$28
$28:
  %88 = phi i64 [%86, %$27] ; # Cnt
  br label %$25
$29:
  %89 = phi i64 [%86, %$27] ; # Cnt
  %90 = phi i64 [0, %$27] ; # ->
; # (if (cnt? (val Q)) @ (zapZero @))
; # (val Q)
  %91 = inttoptr i64 %32 to i64*
  %92 = load i64, i64* %91
; # (cnt? (val Q))
  %93 = and i64 %92, 2
  %94 = icmp ne i64 %93, 0
  br i1 %94, label %$30, label %$31
$30:
  %95 = phi i64 [%89, %$29] ; # Cnt
  br label %$32
$31:
  %96 = phi i64 [%89, %$29] ; # Cnt
; # (zapZero @)
  %97 = call i64 @zapZero(i64 %92)
  br label %$32
$32:
  %98 = phi i64 [%95, %$30], [%96, %$31] ; # Cnt
  %99 = phi i64 [%92, %$30], [%97, %$31] ; # ->
  br label %$12
$12:
  %100 = phi i64 [%40, %$14], [%69, %$24], [%98, %$32] ; # Cnt
  %101 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$14], [%70, %$24], [%99, %$32] ; # ->
  br label %$7
$10:
; # (set $GetBin (fun (i32) getBinary) $Extn (val $ExtN))
; # (fun (i32) getBinary)
  store i32()* @getBinary, i32()** @$GetBin
; # (val $ExtN)
  %102 = load i32, i32* @$ExtN
  store i32 %102, i32* @$Extn
; # (if (binRead) @ X)
; # (binRead)
  %103 = call i64 @binRead()
  %104 = icmp ne i64 %103, 0
  br i1 %104, label %$33, label %$34
$33:
  br label %$35
$34:
  br label %$35
$35:
  %105 = phi i64 [%103, %$33], [%13, %$34] ; # ->
  br label %$7
$7:
  %106 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$9], [%101, %$12], [%105, %$35] ; # ->
; # (drop *Safe)
  %107 = inttoptr i64 %17 to i64*
  %108 = getelementptr i64, i64* %107, i32 1
  %109 = load i64, i64* %108
  %110 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %109, i64* %110
  ret i64 %106
}

define i64 @_Pr(i64) align 8 {
$1:
; # (let X (cdr Exe) (loop (let Y (eval (++ X)) (set $Extn (val $ExtN...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (loop (let Y (eval (++ X)) (set $Extn (val $ExtN)) (pr Y) (? (ato...
  br label %$2
$2:
  %4 = phi i64 [%3, %$1], [%21, %$8] ; # X
; # (let Y (eval (++ X)) (set $Extn (val $ExtN)) (pr Y) (? (atom X) Y...
; # (++ X)
  %5 = inttoptr i64 %4 to i64*
  %6 = load i64, i64* %5
  %7 = getelementptr i64, i64* %5, i32 1
  %8 = load i64, i64* %7
; # (eval (++ X))
  %9 = and i64 %6, 6
  %10 = icmp ne i64 %9, 0
  br i1 %10, label %$5, label %$4
$5:
  br label %$3
$4:
  %11 = and i64 %6, 8
  %12 = icmp ne i64 %11, 0
  br i1 %12, label %$7, label %$6
$7:
  %13 = inttoptr i64 %6 to i64*
  %14 = load i64, i64* %13
  br label %$3
$6:
  %15 = call i64 @evList(i64 %6)
  br label %$3
$3:
  %16 = phi i64 [%6, %$5], [%14, %$7], [%15, %$6] ; # ->
; # (set $Extn (val $ExtN))
; # (val $ExtN)
  %17 = load i32, i32* @$ExtN
  store i32 %17, i32* @$Extn
; # (pr Y)
  call void @pr(i64 %16)
; # (? (atom X) Y)
; # (atom X)
  %18 = and i64 %8, 15
  %19 = icmp ne i64 %18, 0
  br i1 %19, label %$10, label %$8
$10:
  %20 = phi i64 [%8, %$3] ; # X
  br label %$9
$8:
  %21 = phi i64 [%8, %$3] ; # X
  br label %$2
$9:
  %22 = phi i64 [%20, %$10] ; # X
  %23 = phi i64 [%16, %$10] ; # ->
  ret i64 %23
}

define i64 @_Wr(i64) align 8 {
$1:
; # (let X (cdr Exe) (loop (let N (eval (++ X)) (_putStdout (i8 (int ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (loop (let N (eval (++ X)) (_putStdout (i8 (int N))) (? (atom X) ...
  br label %$2
$2:
  %4 = phi i64 [%3, %$1], [%22, %$8] ; # X
; # (let N (eval (++ X)) (_putStdout (i8 (int N))) (? (atom X) N))
; # (++ X)
  %5 = inttoptr i64 %4 to i64*
  %6 = load i64, i64* %5
  %7 = getelementptr i64, i64* %5, i32 1
  %8 = load i64, i64* %7
; # (eval (++ X))
  %9 = and i64 %6, 6
  %10 = icmp ne i64 %9, 0
  br i1 %10, label %$5, label %$4
$5:
  br label %$3
$4:
  %11 = and i64 %6, 8
  %12 = icmp ne i64 %11, 0
  br i1 %12, label %$7, label %$6
$7:
  %13 = inttoptr i64 %6 to i64*
  %14 = load i64, i64* %13
  br label %$3
$6:
  %15 = call i64 @evList(i64 %6)
  br label %$3
$3:
  %16 = phi i64 [%6, %$5], [%14, %$7], [%15, %$6] ; # ->
; # (int N)
  %17 = lshr i64 %16, 4
; # (i8 (int N))
  %18 = trunc i64 %17 to i8
; # (_putStdout (i8 (int N)))
  call void @_putStdout(i8 %18)
; # (? (atom X) N)
; # (atom X)
  %19 = and i64 %8, 15
  %20 = icmp ne i64 %19, 0
  br i1 %20, label %$10, label %$8
$10:
  %21 = phi i64 [%8, %$3] ; # X
  br label %$9
$8:
  %22 = phi i64 [%8, %$3] ; # X
  br label %$2
$9:
  %23 = phi i64 [%21, %$10] ; # X
  %24 = phi i64 [%16, %$10] ; # ->
  ret i64 %24
}

define i32 @getParse() align 8 {
$1:
; # (let P (val $Parser) (set $Chr (if (i32 (symByte P)) @ (let C (va...
; # (val $Parser)
  %0 = load i64*, i64** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 104) to i64**)
; # (set $Chr (if (i32 (symByte P)) @ (let C (val 3 P) (set 3 P (shr ...
; # (if (i32 (symByte P)) @ (let C (val 3 P) (set 3 P (shr C 8)) (if ...
; # (symByte P)
  %1 = call i8 @symByte(i64* %0)
; # (i32 (symByte P))
  %2 = zext i8 %1 to i32
  %3 = icmp ne i32 %2, 0
  br i1 %3, label %$2, label %$3
$2:
  br label %$4
$3:
; # (let C (val 3 P) (set 3 P (shr C 8)) (if C (i32 (i8 C)) -1))
; # (val 3 P)
  %4 = getelementptr i64, i64* %0, i32 2
  %5 = load i64, i64* %4
; # (set 3 P (shr C 8))
; # (shr C 8)
  %6 = lshr i64 %5, 8
  %7 = getelementptr i64, i64* %0, i32 2
  store i64 %6, i64* %7
; # (if C (i32 (i8 C)) -1)
  %8 = icmp ne i64 %5, 0
  br i1 %8, label %$5, label %$6
$5:
; # (i8 C)
  %9 = trunc i64 %5 to i8
; # (i32 (i8 C))
  %10 = zext i8 %9 to i32
  br label %$7
$6:
  br label %$7
$7:
  %11 = phi i32 [%10, %$5], [-1, %$6] ; # ->
  br label %$4
$4:
  %12 = phi i32 [%2, %$2], [%11, %$7] ; # ->
  store i32 %12, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
  ret i32 %12
}

define i64 @parse(i64, i1, i64, i64) align 8 {
$1:
; # (let (Chr (val $Chr) Get (val (i8** $Get)) Pars (val $Parser)) (s...
; # (val $Chr)
  %4 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
; # (i8** $Get)
  %5 = bitcast i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**) to i8**
; # (val (i8** $Get))
  %6 = load i8*, i8** %5
; # (val $Parser)
  %7 = load i64*, i64** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 104) to i64**)
; # (set $Chr 0 $Get (fun (i32) getParse) $Parser (push 0 (save Nm) E...
  store i32 0, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
; # (fun (i32) getParse)
  store i32()* @getParse, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
; # (save Nm)
  %8 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %9 = load i64, i64* %8
  %10 = alloca i64, i64 2, align 16
  %11 = ptrtoint i64* %10 to i64
  %12 = inttoptr i64 %11 to i64*
  store i64 %0, i64* %12
  %13 = add i64 %11, 8
  %14 = inttoptr i64 %13 to i64*
  store i64 %9, i64* %14
  %15 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %11, i64* %15
; # (push 0 (save Nm) Eof)
  %16 = alloca i64, i64 3, align 16
  store i64 0, i64* %16
  %17 = getelementptr i64, i64* %16, i32 1
  store i64 %0, i64* %17
  %18 = getelementptr i64, i64* %16, i32 2
  store i64 %2, i64* %18
  store i64* %16, i64** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 104) to i64**)
; # (when Skip (getParse))
  br i1 %1, label %$2, label %$3
$2:
; # (getParse)
  %19 = call i32 @getParse()
  br label %$3
$3:
; # (prog1 (cond ((=0 Set) (rdList)) ((== 1 Set) (read0 YES)) ((=0 (t...
; # (cond ((=0 Set) (rdList)) ((== 1 Set) (read0 YES)) ((=0 (token Se...
; # (=0 Set)
  %20 = icmp eq i64 %3, 0
  br i1 %20, label %$6, label %$5
$6:
; # (rdList)
  %21 = call i64 @rdList()
  br label %$4
$5:
; # (== 1 Set)
  %22 = icmp eq i64 1, %3
  br i1 %22, label %$8, label %$7
$8:
; # (read0 YES)
  %23 = call i64 @read0(i1 1)
  br label %$4
$7:
; # (token Set 0)
  %24 = call i64 @token(i64 %3, i32 0)
; # (=0 (token Set 0))
  %25 = icmp eq i64 %24, 0
  br i1 %25, label %$10, label %$9
$10:
  br label %$4
$9:
; # (let (R (save (cons @ $Nil)) P R) (while (token Set 0) (setq P (s...
; # (cons @ $Nil)
  %26 = call i64 @cons(i64 %24, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (save (cons @ $Nil))
  %27 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %28 = load i64, i64* %27
  %29 = alloca i64, i64 2, align 16
  %30 = ptrtoint i64* %29 to i64
  %31 = inttoptr i64 %30 to i64*
  store i64 %26, i64* %31
  %32 = add i64 %30, 8
  %33 = inttoptr i64 %32 to i64*
  store i64 %28, i64* %33
  %34 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %30, i64* %34
; # (while (token Set 0) (setq P (set 2 P (cons @ $Nil))))
  br label %$11
$11:
  %35 = phi i64 [%26, %$9], [%39, %$12] ; # P
; # (token Set 0)
  %36 = call i64 @token(i64 %3, i32 0)
  %37 = icmp ne i64 %36, 0
  br i1 %37, label %$12, label %$13
$12:
  %38 = phi i64 [%35, %$11] ; # P
; # (set 2 P (cons @ $Nil))
; # (cons @ $Nil)
  %39 = call i64 @cons(i64 %36, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %40 = inttoptr i64 %38 to i64*
  %41 = getelementptr i64, i64* %40, i32 1
  store i64 %39, i64* %41
  br label %$11
$13:
  %42 = phi i64 [%35, %$11] ; # P
  br label %$4
$4:
  %43 = phi i64 [%21, %$6], [%23, %$8], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$10], [%26, %$13] ; # ->
; # (set $Parser Pars (i8** $Get) Get $Chr Chr)
  store i64* %7, i64** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 104) to i64**)
; # (i8** $Get)
  %44 = bitcast i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**) to i8**
  store i8* %6, i8** %44
  store i32 %4, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
; # (drop *Safe)
  %45 = inttoptr i64 %11 to i64*
  %46 = getelementptr i64, i64* %45, i32 1
  %47 = load i64, i64* %46
  %48 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %47, i64* %48
  ret i64 %43
}

define void @putString(i8) align 8 {
$1:
; # (val $StrP)
  %1 = load i64*, i64** @$StrP
; # (byteSym B (val $StrP))
  call void @byteSym(i8 %0, i64* %1)
  ret void
}

define void @begString(i64*) align 8 {
$1:
; # (set 6 P (i64 (val $StrP)))
; # (val $StrP)
  %1 = load i64*, i64** @$StrP
; # (i64 (val $StrP))
  %2 = ptrtoint i64* %1 to i64
  %3 = getelementptr i64, i64* %0, i32 5
  store i64 %2, i64* %3
; # (set $StrP P)
  store i64* %0, i64** @$StrP
; # (ofs (set $StrP P) 2)
  %4 = getelementptr i64, i64* %0, i32 2
; # (link (ofs (set $StrP P) 2))
  %5 = ptrtoint i64* %4 to i64
  %6 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %7 = load i64, i64* %6
  %8 = inttoptr i64 %5 to i64*
  %9 = getelementptr i64, i64* %8, i32 1
  store i64 %7, i64* %9
  %10 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %5, i64* %10
; # (set 5 P (val (i64* $Put)) $Put (fun (void i8) putString))
; # (i64* $Put)
  %11 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**) to i64*
; # (val (i64* $Put))
  %12 = load i64, i64* %11
  %13 = getelementptr i64, i64* %0, i32 4
  store i64 %12, i64* %13
; # (fun (void i8) putString)
  store void(i8)* @putString, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  ret void
}

define void @tglString(i64*) align 8 {
$1:
; # (ofs P 4)
  %1 = getelementptr i64, i64* %0, i32 4
; # (any (ofs P 4))
  %2 = ptrtoint i64* %1 to i64
; # (i64* $Put)
  %3 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**) to i64*
; # (any (i64* $Put))
  %4 = ptrtoint i64* %3 to i64
; # (xchg (any (ofs P 4)) (any (i64* $Put)))
  %5 = inttoptr i64 %2 to i64*
  %6 = load i64, i64* %5
  %7 = inttoptr i64 %4 to i64*
  %8 = load i64, i64* %7
  store i64 %8, i64* %5
  store i64 %6, i64* %7
  ret void
}

define i64 @endString() align 8 {
$1:
; # (let (P (val $StrP) Q (ofs P 2)) (set (i64* $Put) (val 5 P) $StrP...
; # (val $StrP)
  %0 = load i64*, i64** @$StrP
; # (ofs P 2)
  %1 = getelementptr i64, i64* %0, i32 2
; # (set (i64* $Put) (val 5 P) $StrP (i64* (val 6 P)))
; # (i64* $Put)
  %2 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**) to i64*
; # (val 5 P)
  %3 = getelementptr i64, i64* %0, i32 4
  %4 = load i64, i64* %3
  store i64 %4, i64* %2
; # (val 6 P)
  %5 = getelementptr i64, i64* %0, i32 5
  %6 = load i64, i64* %5
; # (i64* (val 6 P))
  %7 = inttoptr i64 %6 to i64*
  store i64* %7, i64** @$StrP
; # (drop Q (consStr (val Q)))
  %8 = ptrtoint i64* %1 to i64
; # (val Q)
  %9 = load i64, i64* %1
; # (consStr (val Q))
  %10 = call i64 @consStr(i64 %9)
  %11 = inttoptr i64 %8 to i64*
  %12 = getelementptr i64, i64* %11, i32 1
  %13 = load i64, i64* %12
  %14 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %13, i64* %14
  ret i64 %10
}

define i64 @_Any(i64) align 8 {
$1:
; # (if (sym? (val (tail (save (evSym (cdr Exe)))))) $Nil (parse (nam...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (evSym (cdr Exe))
  %4 = call i64 @evSym(i64 %3)
; # (save (evSym (cdr Exe)))
  %5 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %6 = load i64, i64* %5
  %7 = alloca i64, i64 2, align 16
  %8 = ptrtoint i64* %7 to i64
  %9 = inttoptr i64 %8 to i64*
  store i64 %4, i64* %9
  %10 = add i64 %8, 8
  %11 = inttoptr i64 %10 to i64*
  store i64 %6, i64* %11
  %12 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %8, i64* %12
; # (tail (save (evSym (cdr Exe))))
  %13 = add i64 %4, -8
; # (val (tail (save (evSym (cdr Exe)))))
  %14 = inttoptr i64 %13 to i64*
  %15 = load i64, i64* %14
; # (sym? (val (tail (save (evSym (cdr Exe))))))
  %16 = and i64 %15, 8
  %17 = icmp ne i64 %16, 0
  br i1 %17, label %$2, label %$3
$2:
  br label %$4
$3:
; # (name @)
  br label %$5
$5:
  %18 = phi i64 [%15, %$3], [%24, %$6] ; # Tail
  %19 = and i64 %18, 6
  %20 = icmp ne i64 %19, 0
  br i1 %20, label %$7, label %$6
$6:
  %21 = phi i64 [%18, %$5] ; # Tail
  %22 = inttoptr i64 %21 to i64*
  %23 = getelementptr i64, i64* %22, i32 1
  %24 = load i64, i64* %23
  br label %$5
$7:
  %25 = phi i64 [%18, %$5] ; # Tail
; # (parse (name @) YES (hex "20") 1)
  %26 = call i64 @parse(i64 %25, i1 1, i64 32, i64 1)
  br label %$4
$4:
  %27 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%26, %$7] ; # ->
; # (drop *Safe)
  %28 = inttoptr i64 %8 to i64*
  %29 = getelementptr i64, i64* %28, i32 1
  %30 = load i64, i64* %29
  %31 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %30, i64* %31
  ret i64 %27
}

define i64 @_Sym(i64) align 8 {
$1:
; # (let X (eval (cadr Exe)) (begString (push 4 NIL ZERO NIL NIL NIL)...
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (push 4 NIL ZERO NIL NIL NIL)
  %14 = alloca i64, i64 6, align 16
  store i64 4, i64* %14
  %15 = getelementptr i64, i64* %14, i32 2
  store i64 2, i64* %15
; # (begString (push 4 NIL ZERO NIL NIL NIL))
  call void @begString(i64* %14)
; # (print X)
  call void @print(i64 %13)
; # (endString)
  %16 = call i64 @endString()
  ret i64 %16
}

define i64 @_Str(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (eval (car X))) (cond ((nil? Y) Y) ((num? Y) ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (car X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (car X))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (cond ((nil? Y) Y) ((num? Y) (argErr Exe Y)) ((pair Y) (begString...
; # (nil? Y)
  %14 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %14, label %$9, label %$8
$9:
  %15 = phi i64 [%3, %$2] ; # X
  %16 = phi i64 [%13, %$2] ; # Y
  br label %$7
$8:
  %17 = phi i64 [%3, %$2] ; # X
  %18 = phi i64 [%13, %$2] ; # Y
; # (num? Y)
  %19 = and i64 %18, 6
  %20 = icmp ne i64 %19, 0
  br i1 %20, label %$11, label %$10
$11:
  %21 = phi i64 [%17, %$8] ; # X
  %22 = phi i64 [%18, %$8] ; # Y
; # (argErr Exe Y)
  call void @argErr(i64 %0, i64 %22)
  unreachable
$10:
  %23 = phi i64 [%17, %$8] ; # X
  %24 = phi i64 [%18, %$8] ; # Y
; # (pair Y)
  %25 = and i64 %24, 15
  %26 = icmp eq i64 %25, 0
  br i1 %26, label %$13, label %$12
$13:
  %27 = phi i64 [%23, %$10] ; # X
  %28 = phi i64 [%24, %$10] ; # Y
; # (push 4 NIL ZERO NIL NIL NIL)
  %29 = alloca i64, i64 6, align 16
  store i64 4, i64* %29
  %30 = getelementptr i64, i64* %29, i32 2
  store i64 2, i64* %30
; # (begString (push 4 NIL ZERO NIL NIL NIL))
  call void @begString(i64* %29)
; # (loop (print (++ Y)) (? (atom Y)) (space))
  br label %$14
$14:
  %31 = phi i64 [%27, %$13], [%39, %$15] ; # X
  %32 = phi i64 [%28, %$13], [%40, %$15] ; # Y
; # (++ Y)
  %33 = inttoptr i64 %32 to i64*
  %34 = load i64, i64* %33
  %35 = getelementptr i64, i64* %33, i32 1
  %36 = load i64, i64* %35
; # (print (++ Y))
  call void @print(i64 %34)
; # (? (atom Y))
; # (atom Y)
  %37 = and i64 %36, 15
  %38 = icmp ne i64 %37, 0
  br i1 %38, label %$16, label %$15
$15:
  %39 = phi i64 [%31, %$14] ; # X
  %40 = phi i64 [%36, %$14] ; # Y
; # (space)
  call void @space()
  br label %$14
$16:
  %41 = phi i64 [%31, %$14] ; # X
  %42 = phi i64 [%36, %$14] ; # Y
  %43 = phi i64 [0, %$14] ; # ->
; # (endString)
  %44 = call i64 @endString()
  br label %$7
$12:
  %45 = phi i64 [%23, %$10] ; # X
  %46 = phi i64 [%24, %$10] ; # Y
; # (tail @)
  %47 = add i64 %24, -8
; # (val (tail @))
  %48 = inttoptr i64 %47 to i64*
  %49 = load i64, i64* %48
; # (sym? (setq Y (val (tail @))))
  %50 = and i64 %49, 8
  %51 = icmp ne i64 %50, 0
  br i1 %51, label %$18, label %$17
$18:
  %52 = phi i64 [%45, %$12] ; # X
  %53 = phi i64 [%49, %$12] ; # Y
  br label %$7
$17:
  %54 = phi i64 [%45, %$12] ; # X
  %55 = phi i64 [%49, %$12] ; # Y
; # (shift X)
  %56 = inttoptr i64 %54 to i64*
  %57 = getelementptr i64, i64* %56, i32 1
  %58 = load i64, i64* %57
; # (atom (shift X))
  %59 = and i64 %58, 15
  %60 = icmp ne i64 %59, 0
  br i1 %60, label %$20, label %$19
$20:
  %61 = phi i64 [%58, %$17] ; # X
  %62 = phi i64 [%55, %$17] ; # Y
; # (name Y)
  br label %$21
$21:
  %63 = phi i64 [%62, %$20], [%69, %$22] ; # Tail
  %64 = and i64 %63, 6
  %65 = icmp ne i64 %64, 0
  br i1 %65, label %$23, label %$22
$22:
  %66 = phi i64 [%63, %$21] ; # Tail
  %67 = inttoptr i64 %66 to i64*
  %68 = getelementptr i64, i64* %67, i32 1
  %69 = load i64, i64* %68
  br label %$21
$23:
  %70 = phi i64 [%63, %$21] ; # Tail
; # (parse (name Y) NO (hex "5D0A") 0)
  %71 = call i64 @parse(i64 %70, i1 0, i64 23818, i64 0)
  br label %$7
$19:
  %72 = phi i64 [%58, %$17] ; # X
  %73 = phi i64 [%55, %$17] ; # Y
; # (save Y (parse (name Y) NO 0 (save (evSym X))))
  %74 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %75 = load i64, i64* %74
  %76 = alloca i64, i64 2, align 16
  %77 = ptrtoint i64* %76 to i64
  %78 = inttoptr i64 %77 to i64*
  store i64 %73, i64* %78
  %79 = add i64 %77, 8
  %80 = inttoptr i64 %79 to i64*
  store i64 %75, i64* %80
  %81 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %77, i64* %81
; # (name Y)
  br label %$24
$24:
  %82 = phi i64 [%73, %$19], [%88, %$25] ; # Tail
  %83 = and i64 %82, 6
  %84 = icmp ne i64 %83, 0
  br i1 %84, label %$26, label %$25
$25:
  %85 = phi i64 [%82, %$24] ; # Tail
  %86 = inttoptr i64 %85 to i64*
  %87 = getelementptr i64, i64* %86, i32 1
  %88 = load i64, i64* %87
  br label %$24
$26:
  %89 = phi i64 [%82, %$24] ; # Tail
; # (evSym X)
  %90 = call i64 @evSym(i64 %72)
; # (save (evSym X))
  %91 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %92 = load i64, i64* %91
  %93 = alloca i64, i64 2, align 16
  %94 = ptrtoint i64* %93 to i64
  %95 = inttoptr i64 %94 to i64*
  store i64 %90, i64* %95
  %96 = add i64 %94, 8
  %97 = inttoptr i64 %96 to i64*
  store i64 %92, i64* %97
  %98 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %94, i64* %98
; # (parse (name Y) NO 0 (save (evSym X)))
  %99 = call i64 @parse(i64 %89, i1 0, i64 0, i64 %90)
; # drop
  %100 = inttoptr i64 %77 to i64*
  %101 = getelementptr i64, i64* %100, i32 1
  %102 = load i64, i64* %101
  %103 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %102, i64* %103
  br label %$7
$7:
  %104 = phi i64 [%15, %$9], [%41, %$16], [%52, %$18], [%61, %$23], [%72, %$26] ; # X
  %105 = phi i64 [%16, %$9], [%42, %$16], [%53, %$18], [%62, %$23], [%73, %$26] ; # Y
  %106 = phi i64 [%16, %$9], [%44, %$16], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$18], [%71, %$23], [%99, %$26] ; # ->
  ret i64 %106
}

define i64 @stdRead(i8*) align 8 {
$1:
; # (prog2 (set $LinePrmt (if (or (nil? (runAt (val $Prompt))) (not (...
; # (set $LinePrmt (if (or (nil? (runAt (val $Prompt))) (not (symb? @...
; # (if (or (nil? (runAt (val $Prompt))) (not (symb? @))) Prmt (let (...
; # (or (nil? (runAt (val $Prompt))) (not (symb? @)))
; # (val $Prompt)
  %1 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 504) to i64) to i64*
  %2 = load i64, i64* %1
; # (runAt (val $Prompt))
  %3 = call i64 @runAt(i64 %2)
; # (nil? (runAt (val $Prompt)))
  %4 = icmp eq i64 %3, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %4, label %$2, label %$3
$3:
; # (symb? @)
  %5 = xor i64 %3, 8
  %6 = and i64 %5, 14
  %7 = icmp eq i64 %6, 0
; # (not (symb? @))
  %8 = icmp eq i1 %7, 0
  br label %$2
$2:
  %9 = phi i1 [1, %$1], [%8, %$3] ; # ->
  br i1 %9, label %$4, label %$5
$4:
  br label %$6
$5:
; # (let (Nm (name (val (tail @))) N (bufSize Nm) P (set $ReplPrmt (a...
; # (tail @)
  %10 = add i64 %3, -8
; # (val (tail @))
  %11 = inttoptr i64 %10 to i64*
  %12 = load i64, i64* %11
; # (name (val (tail @)))
  br label %$7
$7:
  %13 = phi i64 [%12, %$5], [%19, %$8] ; # Tail
  %14 = and i64 %13, 6
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$9, label %$8
$8:
  %16 = phi i64 [%13, %$7] ; # Tail
  %17 = inttoptr i64 %16 to i64*
  %18 = getelementptr i64, i64* %17, i32 1
  %19 = load i64, i64* %18
  br label %$7
$9:
  %20 = phi i64 [%13, %$7] ; # Tail
; # (bufSize Nm)
  %21 = call i64 @bufSize(i64 %20)
; # (set $ReplPrmt (alloc (val $ReplPrmt) (+ N (strlen Prmt))))
; # (val $ReplPrmt)
  %22 = load i8*, i8** @$ReplPrmt
; # (strlen Prmt)
  %23 = call i64 @strlen(i8* %0)
; # (+ N (strlen Prmt))
  %24 = add i64 %21, %23
; # (alloc (val $ReplPrmt) (+ N (strlen Prmt)))
  %25 = call i8* @alloc(i8* %22, i64 %24)
  store i8* %25, i8** @$ReplPrmt
; # (bufString Nm P)
  %26 = call i8* @bufString(i64 %20, i8* %25)
; # (dec N)
  %27 = sub i64 %21, 1
; # (ofs P (dec N))
  %28 = getelementptr i8, i8* %25, i64 %27
; # (strcpy (ofs P (dec N)) Prmt)
  %29 = call i8* @strcpy(i8* %28, i8* %0)
  br label %$6
$6:
  %30 = phi i8* [%0, %$4], [%25, %$9] ; # ->
  store i8* %30, i8** @$LinePrmt
  store i8* bitcast ([4 x i8]* @$49 to i8*), i8** @$ContPrmt
; # (if ((inFile (val $InFile)) tty) (char "^J") (i32 0))
; # (val $InFile)
  %31 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 72) to i8**)
; # ((inFile (val $InFile)) tty)
  %32 = getelementptr i8, i8* %31, i32 4128
  %33 = bitcast i8* %32 to i1*
  %34 = load i1, i1* %33
  br i1 %34, label %$10, label %$11
$10:
  br label %$12
$11:
; # (i32 0)
  br label %$12
$12:
  %35 = phi i32 [10, %$10], [0, %$11] ; # ->
; # (read1 (if ((inFile (val $InFile)) tty) (char "^J") (i32 0)))
  %36 = call i64 @read1(i32 %35)
; # (set $LinePrmt (set $ContPrmt null))
; # (set $ContPrmt null)
  store i8* null, i8** @$ContPrmt
  store i8* null, i8** @$LinePrmt
; # (while (gt0 (val $Chr)) (? (== (val $Chr) (char "^J")) (set $Chr ...
  br label %$13
$13:
; # (val $Chr)
  %37 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
; # (gt0 (val $Chr))
  %38 = icmp sgt i32 %37, 0
  br i1 %38, label %$14, label %$15
$14:
; # (? (== (val $Chr) (char "^J")) (set $Chr 0))
; # (val $Chr)
  %39 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
; # (== (val $Chr) (char "^J"))
  %40 = icmp eq i32 %39, 10
  br i1 %40, label %$17, label %$16
$17:
; # (set $Chr 0)
  store i32 0, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
  br label %$15
$16:
; # (if (== (val $Chr) (char "#")) (comment) (? (> (val $Chr) (char "...
; # (val $Chr)
  %41 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
; # (== (val $Chr) (char "#"))
  %42 = icmp eq i32 %41, 35
  br i1 %42, label %$18, label %$19
$18:
; # (comment)
  call void @comment()
  br label %$20
$19:
; # (? (> (val $Chr) (char " ")))
; # (val $Chr)
  %43 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
; # (> (val $Chr) (char " "))
  %44 = icmp sgt i32 %43, 32
  br i1 %44, label %$15, label %$21
$21:
; # (call $Get)
  %45 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %46 = call i32 %45()
  br label %$20
$20:
  br label %$13
$15:
  ret i64 %36
}

define i64 @stdEval(i64) align 8 {
$1:
; # (flushAll)
  call void @flushAll()
; # (let (At (save (val $At)) At2 (save (val $At2)) X (save (eval Exe...
; # (val $At)
  %1 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  %2 = load i64, i64* %1
; # (save (val $At))
  %3 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %4 = load i64, i64* %3
  %5 = alloca i64, i64 2, align 16
  %6 = ptrtoint i64* %5 to i64
  %7 = inttoptr i64 %6 to i64*
  store i64 %2, i64* %7
  %8 = add i64 %6, 8
  %9 = inttoptr i64 %8 to i64*
  store i64 %4, i64* %9
  %10 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %6, i64* %10
; # (val $At2)
  %11 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 456) to i64) to i64*
  %12 = load i64, i64* %11
; # (save (val $At2))
  %13 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %14 = load i64, i64* %13
  %15 = alloca i64, i64 2, align 16
  %16 = ptrtoint i64* %15 to i64
  %17 = inttoptr i64 %16 to i64*
  store i64 %12, i64* %17
  %18 = add i64 %16, 8
  %19 = inttoptr i64 %18 to i64*
  store i64 %14, i64* %19
  %20 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %16, i64* %20
; # (eval Exe)
  %21 = and i64 %0, 6
  %22 = icmp ne i64 %21, 0
  br i1 %22, label %$4, label %$3
$4:
  br label %$2
$3:
  %23 = and i64 %0, 8
  %24 = icmp ne i64 %23, 0
  br i1 %24, label %$6, label %$5
$6:
  %25 = inttoptr i64 %0 to i64*
  %26 = load i64, i64* %25
  br label %$2
$5:
  %27 = call i64 @evList(i64 %0)
  br label %$2
$2:
  %28 = phi i64 [%0, %$4], [%26, %$6], [%27, %$5] ; # ->
; # (save (eval Exe))
  %29 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %30 = load i64, i64* %29
  %31 = alloca i64, i64 2, align 16
  %32 = ptrtoint i64* %31 to i64
  %33 = inttoptr i64 %32 to i64*
  store i64 %28, i64* %33
  %34 = add i64 %32, 8
  %35 = inttoptr i64 %34 to i64*
  store i64 %30, i64* %35
  %36 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %32, i64* %36
; # (outString ($ "-> "))
  call void @outString(i8* bitcast ([4 x i8]* @$50 to i8*))
; # (flushAll)
  call void @flushAll()
; # (print X)
  call void @print(i64 %28)
; # (unless (nil? (val $Remark)) (let (V (push NIL $Nil ZERO NIL NIL)...
; # (val $Remark)
  %37 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 872) to i64) to i64*
  %38 = load i64, i64* %37
; # (nil? (val $Remark))
  %39 = icmp eq i64 %38, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %39, label %$8, label %$7
$7:
; # (let (V (push NIL $Nil ZERO NIL NIL) E (push NIL V ZERO @ NIL)) (...
; # (push NIL $Nil ZERO NIL NIL)
  %40 = alloca i64, i64 5, align 16
  %41 = ptrtoint i64* %40 to i64
  %42 = add i64 %41, 8
  %43 = inttoptr i64 %42 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %43
  %44 = add i64 %41, 16
  %45 = inttoptr i64 %44 to i64*
  store i64 2, i64* %45
; # (push NIL V ZERO @ NIL)
  %46 = alloca i64, i64 5, align 16
  %47 = ptrtoint i64* %46 to i64
  %48 = add i64 %47, 8
  %49 = inttoptr i64 %48 to i64*
  store i64 %41, i64* %49
  %50 = add i64 %47, 16
  %51 = inttoptr i64 %50 to i64*
  store i64 2, i64* %51
  %52 = add i64 %47, 24
  %53 = inttoptr i64 %52 to i64*
  store i64 %38, i64* %53
; # (set 4 V X)
  %54 = inttoptr i64 %41 to i64*
  %55 = getelementptr i64, i64* %54, i32 3
  store i64 %28, i64* %55
; # (set V (link (ofs V 3) T) E (link (ofs E 3)))
; # (ofs V 3)
  %56 = add i64 %41, 24
; # (link (ofs V 3) T)
  %57 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %58 = load i64, i64* %57
  %59 = inttoptr i64 %56 to i64*
  %60 = getelementptr i64, i64* %59, i32 1
  store i64 %58, i64* %60
  %61 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %56, i64* %61
  %62 = inttoptr i64 %41 to i64*
  store i64 %56, i64* %62
; # (ofs E 3)
  %63 = add i64 %47, 24
; # (link (ofs E 3))
  %64 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %65 = load i64, i64* %64
  %66 = inttoptr i64 %63 to i64*
  %67 = getelementptr i64, i64* %66, i32 1
  store i64 %65, i64* %67
  %68 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %63, i64* %68
  %69 = inttoptr i64 %47 to i64*
  store i64 %63, i64* %69
; # (evList E)
  %70 = call i64 @evList(i64 %47)
  br label %$8
$8:
; # (newline)
  call void @newline()
; # (set $At3 At2 $At2 At $At X)
  %71 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 472) to i64) to i64*
  store i64 %12, i64* %71
  %72 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 456) to i64) to i64*
  store i64 %2, i64* %72
  %73 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  store i64 %28, i64* %73
; # (drop *Safe)
  %74 = inttoptr i64 %6 to i64*
  %75 = getelementptr i64, i64* %74, i32 1
  %76 = load i64, i64* %75
  %77 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %76, i64* %77
  ret i64 %28
}

define i64 @repl(i64, i8*, i64) align 8 {
$1:
; # (if (and (symb? X) (== (firstByte X) (char "-"))) (let E (save (p...
; # (and (symb? X) (== (firstByte X) (char "-")))
; # (symb? X)
  %3 = xor i64 %2, 8
  %4 = and i64 %3, 14
  %5 = icmp eq i64 %4, 0
  br i1 %5, label %$3, label %$2
$3:
  %6 = phi i64 [%2, %$1] ; # X
; # (firstByte X)
  %7 = call i8 @firstByte(i64 %6)
; # (== (firstByte X) (char "-"))
  %8 = icmp eq i8 %7, 45
  br label %$2
$2:
  %9 = phi i64 [%2, %$1], [%6, %$3] ; # X
  %10 = phi i1 [0, %$1], [%8, %$3] ; # ->
  br i1 %10, label %$4, label %$5
$4:
  %11 = phi i64 [%9, %$2] ; # X
; # (let E (save (parse (xName X) YES (hex "5D0A") 0)) (evList E))
; # (xName X)
  %12 = call i64 @xName(i64 %11)
; # (parse (xName X) YES (hex "5D0A") 0)
  %13 = call i64 @parse(i64 %12, i1 1, i64 23818, i64 0)
; # (save (parse (xName X) YES (hex "5D0A") 0))
  %14 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %15 = load i64, i64* %14
  %16 = alloca i64, i64 2, align 16
  %17 = ptrtoint i64* %16 to i64
  %18 = inttoptr i64 %17 to i64*
  store i64 %13, i64* %18
  %19 = add i64 %17, 8
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %17, i64* %21
; # (evList E)
  %22 = call i64 @evList(i64 %13)
; # (drop *Safe)
  %23 = inttoptr i64 %17 to i64*
  %24 = getelementptr i64, i64* %23, i32 1
  %25 = load i64, i64* %24
  %26 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %25, i64* %26
  br label %$6
$5:
  %27 = phi i64 [%9, %$2] ; # X
; # (let (Lnk (val $NsLink) Tr1 (save (val $Transient)) Tr2 (save (va...
; # (val $NsLink)
  %28 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 24) to i64) to i64*
  %29 = load i64, i64* %28
; # (val $Transient)
  %30 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 8) to i64) to i64*
  %31 = load i64, i64* %30
; # (save (val $Transient))
  %32 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %33 = load i64, i64* %32
  %34 = alloca i64, i64 2, align 16
  %35 = ptrtoint i64* %34 to i64
  %36 = inttoptr i64 %35 to i64*
  store i64 %31, i64* %36
  %37 = add i64 %35, 8
  %38 = inttoptr i64 %37 to i64*
  store i64 %33, i64* %38
  %39 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %35, i64* %39
; # (val 2 $Transient)
  %40 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 8) to i64) to i64*
  %41 = getelementptr i64, i64* %40, i32 1
  %42 = load i64, i64* %41
; # (save (val 2 $Transient))
  %43 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %44 = load i64, i64* %43
  %45 = alloca i64, i64 2, align 16
  %46 = ptrtoint i64* %45 to i64
  %47 = inttoptr i64 %46 to i64*
  store i64 %42, i64* %47
  %48 = add i64 %46, 8
  %49 = inttoptr i64 %48 to i64*
  store i64 %44, i64* %49
  %50 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %46, i64* %50
; # (val $PrivT)
  %51 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 112) to i64) to i64*
  %52 = load i64, i64* %51
; # (save (val $PrivT))
  %53 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %54 = load i64, i64* %53
  %55 = alloca i64, i64 2, align 16
  %56 = ptrtoint i64* %55 to i64
  %57 = inttoptr i64 %56 to i64*
  store i64 %52, i64* %57
  %58 = add i64 %56, 8
  %59 = inttoptr i64 %58 to i64*
  store i64 %54, i64* %59
  %60 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %56, i64* %60
; # (val 2 $PrivT)
  %61 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 112) to i64) to i64*
  %62 = getelementptr i64, i64* %61, i32 1
  %63 = load i64, i64* %62
; # (save (val 2 $PrivT))
  %64 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %65 = load i64, i64* %64
  %66 = alloca i64, i64 2, align 16
  %67 = ptrtoint i64* %66 to i64
  %68 = inttoptr i64 %67 to i64*
  store i64 %63, i64* %68
  %69 = add i64 %67, 8
  %70 = inttoptr i64 %69 to i64*
  store i64 %65, i64* %70
  %71 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %67, i64* %71
; # (push -ZERO NIL)
  %72 = alloca i64, i64 2, align 16
  %73 = ptrtoint i64* %72 to i64
  %74 = inttoptr i64 %73 to i64*
  store i64 10, i64* %74
; # (link (push -ZERO NIL))
  %75 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %76 = load i64, i64* %75
  %77 = inttoptr i64 %73 to i64*
  %78 = getelementptr i64, i64* %77, i32 1
  store i64 %76, i64* %78
  %79 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %73, i64* %79
; # (val Termio)
  %80 = load i8*, i8** @Termio
; # (val $Intern)
  %81 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 0) to i64) to i64*
  %82 = load i64, i64* %81
; # (save (val $Intern))
  %83 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %84 = load i64, i64* %83
  %85 = alloca i64, i64 2, align 16
  %86 = ptrtoint i64* %85 to i64
  %87 = inttoptr i64 %86 to i64*
  store i64 %82, i64* %87
  %88 = add i64 %86, 8
  %89 = inttoptr i64 %88 to i64*
  store i64 %84, i64* %89
  %90 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %86, i64* %90
; # (set $NsLink (val $Link))
; # (val $Link)
  %91 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %92 = load i64, i64* %91
  %93 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 24) to i64) to i64*
  store i64 %92, i64* %93
; # (when (nil? X) (setCooked) (unless (val $Repl) (set $Repl YES) (i...
; # (nil? X)
  %94 = icmp eq i64 %27, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %94, label %$7, label %$8
$7:
  %95 = phi i64 [%27, %$5] ; # X
; # (setCooked)
  call void @setCooked()
; # (unless (val $Repl) (set $Repl YES) (iSignal (val SIGINT Sig) (fu...
; # (val $Repl)
  %96 = load i1, i1* @$Repl
  br i1 %96, label %$10, label %$9
$9:
  %97 = phi i64 [%95, %$7] ; # X
; # (set $Repl YES)
  store i1 1, i1* @$Repl
; # (val SIGINT Sig)
  %98 = getelementptr i32, i32* @Sig, i32 1
  %99 = load i32, i32* %98
; # (fun sig)
; # (i8* (def (pico~pack "@" (pico~car cross~Args)) (func (; cross~Ar...
  %100 = bitcast void(i32)* @sig to i8*
; # (iSignal (val SIGINT Sig) (fun sig))
  call void @iSignal(i32 %99, i8* %100)
  br label %$10
$10:
  %101 = phi i64 [%95, %$7], [%97, %$9] ; # X
  br label %$8
$8:
  %102 = phi i64 [%27, %$5], [%101, %$10] ; # X
; # (b8+ (ioFrame T))
  %103 = alloca i8, i64 28, align 8
; # (rdOpen Exe X (b8+ (ioFrame T)))
  call void @rdOpen(i64 %0, i64 %102, i8* %103)
; # (set $PrivT (set 2 $PrivT $Nil))
; # (set 2 $PrivT $Nil)
  %104 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 112) to i64) to i64*
  %105 = getelementptr i64, i64* %104, i32 1
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %105
  %106 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 112) to i64) to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %106
; # (set $Rule (set $Transient (set 2 $Transient $Nil)))
; # (set $Transient (set 2 $Transient $Nil))
; # (set 2 $Transient $Nil)
  %107 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 8) to i64) to i64*
  %108 = getelementptr i64, i64* %107, i32 1
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %108
  %109 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 8) to i64) to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %109
  %110 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 568) to i64) to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %110
; # (if (== (val $InFile) (val (val $InFiles))) (until (nil? (stdRead...
; # (val $InFile)
  %111 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 72) to i8**)
; # (val $InFiles)
  %112 = load i8**, i8*** @$InFiles
; # (val (val $InFiles))
  %113 = load i8*, i8** %112
; # (== (val $InFile) (val (val $InFiles)))
  %114 = icmp eq i8* %111, %113
  br i1 %114, label %$11, label %$12
$11:
  %115 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # X
; # (until (nil? (stdRead Prmt)) (let Y (set V @) (setq X (if (and (=...
  br label %$14
$14:
  %116 = phi i64 [%115, %$11], [%139, %$21] ; # X
; # (stdRead Prmt)
  %117 = call i64 @stdRead(i8* %1)
; # (nil? (stdRead Prmt))
  %118 = icmp eq i64 %117, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %118, label %$16, label %$15
$15:
  %119 = phi i64 [%116, %$14] ; # X
; # (let Y (set V @) (setq X (if (and (=0 (val $Chr)) Prmt) (stdEval ...
; # (set V @)
  %120 = inttoptr i64 %73 to i64*
  store i64 %117, i64* %120
; # (if (and (=0 (val $Chr)) Prmt) (stdEval Y) (eval Y))
; # (and (=0 (val $Chr)) Prmt)
; # (val $Chr)
  %121 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
; # (=0 (val $Chr))
  %122 = icmp eq i32 %121, 0
  br i1 %122, label %$18, label %$17
$18:
  %123 = phi i64 [%119, %$15] ; # X
  %124 = icmp ne i8* %1, null
  br label %$17
$17:
  %125 = phi i64 [%119, %$15], [%123, %$18] ; # X
  %126 = phi i1 [0, %$15], [%124, %$18] ; # ->
  br i1 %126, label %$19, label %$20
$19:
  %127 = phi i64 [%125, %$17] ; # X
; # (stdEval Y)
  %128 = call i64 @stdEval(i64 %117)
  br label %$21
$20:
  %129 = phi i64 [%125, %$17] ; # X
; # (eval Y)
  %130 = and i64 %117, 6
  %131 = icmp ne i64 %130, 0
  br i1 %131, label %$24, label %$23
$24:
  br label %$22
$23:
  %132 = and i64 %117, 8
  %133 = icmp ne i64 %132, 0
  br i1 %133, label %$26, label %$25
$26:
  %134 = inttoptr i64 %117 to i64*
  %135 = load i64, i64* %134
  br label %$22
$25:
  %136 = call i64 @evList(i64 %117)
  br label %$22
$22:
  %137 = phi i64 [%117, %$24], [%135, %$26], [%136, %$25] ; # ->
  br label %$21
$21:
  %138 = phi i64 [%127, %$19], [%129, %$22] ; # X
  %139 = phi i64 [%128, %$19], [%137, %$22] ; # ->
  br label %$14
$16:
  %140 = phi i64 [%116, %$14] ; # X
  br label %$13
$12:
  %141 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # X
; # (until (nil? (read1 0)) (setq X (eval (set V @))))
  br label %$27
$27:
  %142 = phi i64 [%141, %$12], [%154, %$30] ; # X
; # (read1 0)
  %143 = call i64 @read1(i32 0)
; # (nil? (read1 0))
  %144 = icmp eq i64 %143, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %144, label %$29, label %$28
$28:
  %145 = phi i64 [%142, %$27] ; # X
; # (set V @)
  %146 = inttoptr i64 %73 to i64*
  store i64 %143, i64* %146
; # (eval (set V @))
  %147 = and i64 %143, 6
  %148 = icmp ne i64 %147, 0
  br i1 %148, label %$32, label %$31
$32:
  br label %$30
$31:
  %149 = and i64 %143, 8
  %150 = icmp ne i64 %149, 0
  br i1 %150, label %$34, label %$33
$34:
  %151 = inttoptr i64 %143 to i64*
  %152 = load i64, i64* %151
  br label %$30
$33:
  %153 = call i64 @evList(i64 %143)
  br label %$30
$30:
  %154 = phi i64 [%143, %$32], [%152, %$34], [%153, %$33] ; # ->
  br label %$27
$29:
  %155 = phi i64 [%142, %$27] ; # X
  br label %$13
$13:
  %156 = phi i64 [%140, %$16], [%155, %$29] ; # X
; # (popInFiles)
  call void @popInFiles()
; # (set $Intern (val (val $NsLink)))
; # (val $NsLink)
  %157 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 24) to i64) to i64*
  %158 = load i64, i64* %157
; # (val (val $NsLink))
  %159 = inttoptr i64 %158 to i64*
  %160 = load i64, i64* %159
  %161 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 0) to i64) to i64*
  store i64 %160, i64* %161
; # (when Raw (setRaw))
  %162 = icmp ne i8* %80, null
  br i1 %162, label %$35, label %$36
$35:
  %163 = phi i64 [%156, %$13] ; # X
; # (setRaw)
  call void @setRaw()
  br label %$36
$36:
  %164 = phi i64 [%156, %$13], [%163, %$35] ; # X
; # (set 2 $PrivT Pr2)
  %165 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 112) to i64) to i64*
  %166 = getelementptr i64, i64* %165, i32 1
  store i64 %63, i64* %166
; # (set $PrivT Pr1)
  %167 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 112) to i64) to i64*
  store i64 %52, i64* %167
; # (set 2 $Transient Tr2)
  %168 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 8) to i64) to i64*
  %169 = getelementptr i64, i64* %168, i32 1
  store i64 %42, i64* %169
; # (set $Transient Tr1)
  %170 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 8) to i64) to i64*
  store i64 %31, i64* %170
; # (set $NsLink Lnk)
  %171 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 24) to i64) to i64*
  store i64 %29, i64* %171
; # (drop *Safe)
  %172 = inttoptr i64 %35 to i64*
  %173 = getelementptr i64, i64* %172, i32 1
  %174 = load i64, i64* %173
  %175 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %174, i64* %175
  br label %$6
$6:
  %176 = phi i64 [%11, %$4], [%164, %$36] ; # X
  %177 = phi i64 [%22, %$4], [%164, %$36] ; # ->
  ret i64 %177
}

define i64 @loadAll(i64) align 8 {
$1:
; # (let X $Nil (loop (let (A (val $AV) P (val A)) (? (or (=0 P) (and...
; # (loop (let (A (val $AV) P (val A)) (? (or (=0 P) (and (== (val P)...
  br label %$2
$2:
  %1 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$1], [%19, %$7] ; # X
; # (let (A (val $AV) P (val A)) (? (or (=0 P) (and (== (val P) (char...
; # (val $AV)
  %2 = load i8**, i8*** @$AV
; # (val A)
  %3 = load i8*, i8** %2
; # (? (or (=0 P) (and (== (val P) (char "-")) (=0 (val 2 P)))))
; # (or (=0 P) (and (== (val P) (char "-")) (=0 (val 2 P))))
; # (=0 P)
  %4 = icmp eq i8* %3, null
  br i1 %4, label %$3, label %$4
$4:
  %5 = phi i64 [%1, %$2] ; # X
; # (and (== (val P) (char "-")) (=0 (val 2 P)))
; # (val P)
  %6 = load i8, i8* %3
; # (== (val P) (char "-"))
  %7 = icmp eq i8 %6, 45
  br i1 %7, label %$6, label %$5
$6:
  %8 = phi i64 [%5, %$4] ; # X
; # (val 2 P)
  %9 = getelementptr i8, i8* %3, i32 1
  %10 = load i8, i8* %9
; # (=0 (val 2 P))
  %11 = icmp eq i8 %10, 0
  br label %$5
$5:
  %12 = phi i64 [%5, %$4], [%8, %$6] ; # X
  %13 = phi i1 [0, %$4], [%11, %$6] ; # ->
  br label %$3
$3:
  %14 = phi i64 [%1, %$2], [%12, %$5] ; # X
  %15 = phi i1 [1, %$2], [%13, %$5] ; # ->
  br i1 %15, label %$8, label %$7
$7:
  %16 = phi i64 [%14, %$3] ; # X
; # (set $AV (inc A))
; # (inc A)
  %17 = getelementptr i8*, i8** %2, i32 1
  store i8** %17, i8*** @$AV
; # (mkStr P)
  %18 = call i64 @mkStr(i8* %3)
; # (repl Exe null (mkStr P))
  %19 = call i64 @repl(i64 %0, i8* null, i64 %18)
  br label %$2
$8:
  %20 = phi i64 [%14, %$3] ; # X
  %21 = phi i64 [0, %$3] ; # ->
  ret i64 %20
}

define i64 @_Load(i64) align 8 {
$1:
; # (let X (cdr Exe) (loop (let Y (if (t? (eval (++ X))) (loadAll Exe...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (loop (let Y (if (t? (eval (++ X))) (loadAll Exe) (repl Exe ($ ">...
  br label %$2
$2:
  %4 = phi i64 [%3, %$1], [%27, %$11] ; # X
; # (let Y (if (t? (eval (++ X))) (loadAll Exe) (repl Exe ($ "> ") @)...
; # (if (t? (eval (++ X))) (loadAll Exe) (repl Exe ($ "> ") @))
; # (++ X)
  %5 = inttoptr i64 %4 to i64*
  %6 = load i64, i64* %5
  %7 = getelementptr i64, i64* %5, i32 1
  %8 = load i64, i64* %7
; # (eval (++ X))
  %9 = and i64 %6, 6
  %10 = icmp ne i64 %9, 0
  br i1 %10, label %$5, label %$4
$5:
  br label %$3
$4:
  %11 = and i64 %6, 8
  %12 = icmp ne i64 %11, 0
  br i1 %12, label %$7, label %$6
$7:
  %13 = inttoptr i64 %6 to i64*
  %14 = load i64, i64* %13
  br label %$3
$6:
  %15 = call i64 @evList(i64 %6)
  br label %$3
$3:
  %16 = phi i64 [%6, %$5], [%14, %$7], [%15, %$6] ; # ->
; # (t? (eval (++ X)))
  %17 = icmp eq i64 %16, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %17, label %$8, label %$9
$8:
  %18 = phi i64 [%8, %$3] ; # X
; # (loadAll Exe)
  %19 = call i64 @loadAll(i64 %0)
  br label %$10
$9:
  %20 = phi i64 [%8, %$3] ; # X
; # (repl Exe ($ "> ") @)
  %21 = call i64 @repl(i64 %0, i8* bitcast ([3 x i8]* @$51 to i8*), i64 %16)
  br label %$10
$10:
  %22 = phi i64 [%18, %$8], [%20, %$9] ; # X
  %23 = phi i64 [%19, %$8], [%21, %$9] ; # ->
; # (? (atom X) Y)
; # (atom X)
  %24 = and i64 %22, 15
  %25 = icmp ne i64 %24, 0
  br i1 %25, label %$13, label %$11
$13:
  %26 = phi i64 [%22, %$10] ; # X
  br label %$12
$11:
  %27 = phi i64 [%22, %$10] ; # X
  br label %$2
$12:
  %28 = phi i64 [%26, %$13] ; # X
  %29 = phi i64 [%23, %$13] ; # ->
  ret i64 %29
}

define void @dbfErr(i64) align 8 {
$1:
; # (err Exe 0 ($ "Bad DB file") null)
  call void @err(i64 %0, i64 0, i8* bitcast ([12 x i8]* @$52 to i8*), i8* null)
  unreachable
}

define void @dbRdErr() align 8 {
$1:
; # (strErrno)
  %0 = call i8* @strErrno()
; # (err 0 0 ($ "DB read: %s") (strErrno))
  call void @err(i64 0, i64 0, i8* bitcast ([12 x i8]* @$53 to i8*), i8* %0)
  unreachable
}

define void @dbWrErr() align 8 {
$1:
; # (strErrno)
  %0 = call i8* @strErrno()
; # (err 0 0 ($ "DB write: %s") (strErrno))
  call void @err(i64 0, i64 0, i8* bitcast ([13 x i8]* @$54 to i8*), i8* %0)
  unreachable
}

define void @jnlErr(i64) align 8 {
$1:
; # (err Exe 0 ($ "Bad Journal") null)
  call void @err(i64 %0, i64 0, i8* bitcast ([12 x i8]* @$55 to i8*), i8* null)
  unreachable
}

define void @dbSyncErr(i64) align 8 {
$1:
; # (strErrno)
  %1 = call i8* @strErrno()
; # (err Exe 0 ($ "DB fsync error: %s") (strErrno))
  call void @err(i64 %0, i64 0, i8* bitcast ([19 x i8]* @$56 to i8*), i8* %1)
  unreachable
}

define i64 @getAdr(i8*) align 8 {
$1:
; # (val 6 P)
  %1 = getelementptr i8, i8* %0, i32 5
  %2 = load i8, i8* %1
; # (i64 (val 6 P))
  %3 = zext i8 %2 to i64
; # (shl (i64 (val 6 P)) 8)
  %4 = shl i64 %3, 8
; # (val 5 P)
  %5 = getelementptr i8, i8* %0, i32 4
  %6 = load i8, i8* %5
; # (i64 (val 5 P))
  %7 = zext i8 %6 to i64
; # (| (shl (i64 (val 6 P)) 8) (i64 (val 5 P)))
  %8 = or i64 %4, %7
; # (shl (| (shl (i64 (val 6 P)) 8) (i64 (val 5 P))) 8)
  %9 = shl i64 %8, 8
; # (val 4 P)
  %10 = getelementptr i8, i8* %0, i32 3
  %11 = load i8, i8* %10
; # (i64 (val 4 P))
  %12 = zext i8 %11 to i64
; # (| (shl (| (shl (i64 (val 6 P)) 8) (i64 (val 5 P))) 8) (i64 (val ...
  %13 = or i64 %9, %12
; # (shl (| (shl (| (shl (i64 (val 6 P)) 8) (i64 (val 5 P))) 8) (i64 ...
  %14 = shl i64 %13, 8
; # (val 3 P)
  %15 = getelementptr i8, i8* %0, i32 2
  %16 = load i8, i8* %15
; # (i64 (val 3 P))
  %17 = zext i8 %16 to i64
; # (| (shl (| (shl (| (shl (i64 (val 6 P)) 8) (i64 (val 5 P))) 8) (i...
  %18 = or i64 %14, %17
; # (shl (| (shl (| (shl (| (shl (i64 (val 6 P)) 8) (i64 (val 5 P))) ...
  %19 = shl i64 %18, 8
; # (val 2 P)
  %20 = getelementptr i8, i8* %0, i32 1
  %21 = load i8, i8* %20
; # (i64 (val 2 P))
  %22 = zext i8 %21 to i64
; # (| (shl (| (shl (| (shl (| (shl (i64 (val 6 P)) 8) (i64 (val 5 P)...
  %23 = or i64 %19, %22
; # (shl (| (shl (| (shl (| (shl (| (shl (i64 (val 6 P)) 8) (i64 (val...
  %24 = shl i64 %23, 8
; # (val P)
  %25 = load i8, i8* %0
; # (i64 (val P))
  %26 = zext i8 %25 to i64
; # (| (shl (| (shl (| (shl (| (shl (| (shl (i64 (val 6 P)) 8) (i64 (...
  %27 = or i64 %24, %26
  ret i64 %27
}

define void @setAdr(i64, i8*) align 8 {
$1:
; # (set P (i8 N))
; # (i8 N)
  %2 = trunc i64 %0 to i8
  store i8 %2, i8* %1
; # (set 2 P (i8 (setq N (shr N 8))))
; # (shr N 8)
  %3 = lshr i64 %0, 8
; # (i8 (setq N (shr N 8)))
  %4 = trunc i64 %3 to i8
  %5 = getelementptr i8, i8* %1, i32 1
  store i8 %4, i8* %5
; # (set 3 P (i8 (setq N (shr N 8))))
; # (shr N 8)
  %6 = lshr i64 %3, 8
; # (i8 (setq N (shr N 8)))
  %7 = trunc i64 %6 to i8
  %8 = getelementptr i8, i8* %1, i32 2
  store i8 %7, i8* %8
; # (set 4 P (i8 (setq N (shr N 8))))
; # (shr N 8)
  %9 = lshr i64 %6, 8
; # (i8 (setq N (shr N 8)))
  %10 = trunc i64 %9 to i8
  %11 = getelementptr i8, i8* %1, i32 3
  store i8 %10, i8* %11
; # (set 5 P (i8 (setq N (shr N 8))))
; # (shr N 8)
  %12 = lshr i64 %9, 8
; # (i8 (setq N (shr N 8)))
  %13 = trunc i64 %12 to i8
  %14 = getelementptr i8, i8* %1, i32 4
  store i8 %13, i8* %14
; # (set 6 P (i8 (shr N 8)))
; # (shr N 8)
  %15 = lshr i64 %12, 8
; # (i8 (shr N 8))
  %16 = trunc i64 %15 to i8
  %17 = getelementptr i8, i8* %1, i32 5
  store i8 %16, i8* %17
  ret void
}

define i8* @dbfBuf(i8*) align 8 {
$1:
; # (let N (| (shl (i32 (val 2 P)) 8) (i32 (val P))) (if (> (val $DBs...
; # (val 2 P)
  %1 = getelementptr i8, i8* %0, i32 1
  %2 = load i8, i8* %1
; # (i32 (val 2 P))
  %3 = zext i8 %2 to i32
; # (shl (i32 (val 2 P)) 8)
  %4 = shl i32 %3, 8
; # (val P)
  %5 = load i8, i8* %0
; # (i32 (val P))
  %6 = zext i8 %5 to i32
; # (| (shl (i32 (val 2 P)) 8) (i32 (val P)))
  %7 = or i32 %4, %6
; # (if (> (val $DBs) N) (set $DbFile (ofs (val $DbFiles) (* N (dbFil...
; # (val $DBs)
  %8 = load i32, i32* @$DBs
; # (> (val $DBs) N)
  %9 = icmp sgt i32 %8, %7
  br i1 %9, label %$2, label %$3
$2:
; # (set $DbFile (ofs (val $DbFiles) (* N (dbFile T))))
; # (val $DbFiles)
  %10 = load i8*, i8** @$DbFiles
; # (* N (dbFile T))
  %11 = mul i32 %7, 48
; # (ofs (val $DbFiles) (* N (dbFile T)))
  %12 = getelementptr i8, i8* %10, i32 %11
  store i8* %12, i8** @$DbFile
  br label %$4
$3:
  br label %$4
$4:
  %13 = phi i8* [%12, %$2], [null, %$3] ; # ->
  ret i8* %13
}

define void @rdLockDb() align 8 {
$1:
; # (unless (t? (val $Solo)) (rdLockWait ((dbFile (val $DbFiles)) fd)...
; # (val $Solo)
  %0 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 424) to i64) to i64*
  %1 = load i64, i64* %0
; # (t? (val $Solo))
  %2 = icmp eq i64 %1, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %2, label %$3, label %$2
$2:
; # (val $DbFiles)
  %3 = load i8*, i8** @$DbFiles
; # ((dbFile (val $DbFiles)) fd)
  %4 = bitcast i8* %3 to i32*
  %5 = load i32, i32* %4
; # (rdLockWait ((dbFile (val $DbFiles)) fd) 1)
  call void @rdLockWait(i32 %5, i64 1)
  br label %$3
$3:
  ret void
}

define void @wrLockDb() align 8 {
$1:
; # (unless (t? (val $Solo)) (wrLockWait ((dbFile (val $DbFiles)) fd)...
; # (val $Solo)
  %0 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 424) to i64) to i64*
  %1 = load i64, i64* %0
; # (t? (val $Solo))
  %2 = icmp eq i64 %1, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %2, label %$3, label %$2
$2:
; # (val $DbFiles)
  %3 = load i8*, i8** @$DbFiles
; # ((dbFile (val $DbFiles)) fd)
  %4 = bitcast i8* %3 to i32*
  %5 = load i32, i32* %4
; # (wrLockWait ((dbFile (val $DbFiles)) fd) 1)
  call void @wrLockWait(i32 %5, i64 1)
  br label %$3
$3:
  ret void
}

define void @unLockDb(i64) align 8 {
$1:
; # (unless (t? (val $Solo)) (unless Len (let (Db (val $DbFiles) C (v...
; # (val $Solo)
  %1 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 424) to i64) to i64*
  %2 = load i64, i64* %1
; # (t? (val $Solo))
  %3 = icmp eq i64 %2, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %3, label %$3, label %$2
$2:
; # (unless Len (let (Db (val $DbFiles) C (val $DBs)) (while (dec 'C)...
  %4 = icmp ne i64 %0, 0
  br i1 %4, label %$5, label %$4
$4:
; # (let (Db (val $DbFiles) C (val $DBs)) (while (dec 'C) (let Db: (d...
; # (val $DbFiles)
  %5 = load i8*, i8** @$DbFiles
; # (val $DBs)
  %6 = load i32, i32* @$DBs
; # (while (dec 'C) (let Db: (dbFile (setq Db (ofs Db (dbFile T)))) (...
  br label %$6
$6:
  %7 = phi i8* [%5, %$4], [%24, %$10] ; # Db
  %8 = phi i32 [%6, %$4], [%25, %$10] ; # C
; # (dec 'C)
  %9 = sub i32 %8, 1
  %10 = icmp ne i32 %9, 0
  br i1 %10, label %$7, label %$8
$7:
  %11 = phi i8* [%7, %$6] ; # Db
  %12 = phi i32 [%9, %$6] ; # C
; # (let Db: (dbFile (setq Db (ofs Db (dbFile T)))) (when (Db: lck) (...
; # (ofs Db (dbFile T))
  %13 = getelementptr i8, i8* %11, i32 48
; # (when (Db: lck) (unLock (Db: fd) 0 0) (Db: lck NO))
; # (Db: lck)
  %14 = getelementptr i8, i8* %13, i32 40
  %15 = bitcast i8* %14 to i1*
  %16 = load i1, i1* %15
  br i1 %16, label %$9, label %$10
$9:
  %17 = phi i8* [%13, %$7] ; # Db
  %18 = phi i32 [%12, %$7] ; # C
; # (Db: fd)
  %19 = bitcast i8* %13 to i32*
  %20 = load i32, i32* %19
; # (unLock (Db: fd) 0 0)
  %21 = call i32 @unLock(i32 %20, i64 0, i64 0)
; # (Db: lck NO)
  %22 = getelementptr i8, i8* %13, i32 40
  %23 = bitcast i8* %22 to i1*
  store i1 0, i1* %23
  br label %$10
$10:
  %24 = phi i8* [%13, %$7], [%17, %$9] ; # Db
  %25 = phi i32 [%12, %$7], [%18, %$9] ; # C
  br label %$6
$8:
  %26 = phi i8* [%7, %$6] ; # Db
  %27 = phi i32 [%9, %$6] ; # C
; # (set $Solo ZERO)
  %28 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 424) to i64) to i64*
  store i64 2, i64* %28
  br label %$5
$5:
; # (val $DbFiles)
  %29 = load i8*, i8** @$DbFiles
; # ((dbFile (val $DbFiles)) fd)
  %30 = bitcast i8* %29 to i32*
  %31 = load i32, i32* %30
; # (unLock ((dbFile (val $DbFiles)) fd) 0 Len)
  %32 = call i32 @unLock(i32 %31, i64 0, i64 %0)
  br label %$3
$3:
  ret void
}

define i32 @tryLock(i8*, i64, i64) align 8 {
$1:
; # (let Db: (dbFile DbFile) (loop (? (ge0 (wrLock (Db: fd) N Len NO)...
; # (loop (? (ge0 (wrLock (Db: fd) N Len NO)) (Db: lck YES) (nond (N ...
  br label %$2
$2:
; # (? (ge0 (wrLock (Db: fd) N Len NO)) (Db: lck YES) (nond (N (set $...
; # (Db: fd)
  %3 = bitcast i8* %0 to i32*
  %4 = load i32, i32* %3
; # (wrLock (Db: fd) N Len NO)
  %5 = call i32 @wrLock(i32 %4, i64 %1, i64 %2, i1 0)
; # (ge0 (wrLock (Db: fd) N Len NO))
  %6 = icmp sge i32 %5, 0
  br i1 %6, label %$5, label %$3
$5:
; # (Db: lck YES)
  %7 = getelementptr i8, i8* %0, i32 40
  %8 = bitcast i8* %7 to i1*
  store i1 1, i1* %8
; # (nond (N (set $Solo $T)) ((t? (val $Solo)) (set $Solo $Nil)))
  %9 = icmp ne i64 %1, 0
  br i1 %9, label %$7, label %$8
$8:
; # (set $Solo $T)
  %10 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 424) to i64) to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), i64* %10
  br label %$6
$7:
; # (val $Solo)
  %11 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 424) to i64) to i64*
  %12 = load i64, i64* %11
; # (t? (val $Solo))
  %13 = icmp eq i64 %12, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %13, label %$9, label %$10
$10:
; # (set $Solo $Nil)
  %14 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 424) to i64) to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %14
  br label %$6
$9:
  br label %$6
$6:
  %15 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$8], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$10], [0, %$9] ; # ->
  br label %$4
$3:
; # (unless (or (== (gErrno) EINTR) (== @ EACCES) (== @ EAGAIN)) (loc...
; # (or (== (gErrno) EINTR) (== @ EACCES) (== @ EAGAIN))
; # (gErrno)
  %16 = call i32 @gErrno()
; # (== (gErrno) EINTR)
  %17 = icmp eq i32 %16, 2
  br i1 %17, label %$11, label %$12
$12:
; # (== @ EACCES)
  %18 = icmp eq i32 %16, 5
  br i1 %18, label %$11, label %$13
$13:
; # (== @ EAGAIN)
  %19 = icmp eq i32 %16, 4
  br label %$11
$11:
  %20 = phi i1 [1, %$3], [1, %$12], [%19, %$13] ; # ->
  br i1 %20, label %$15, label %$14
$14:
; # (lockErr)
  call void @lockErr()
  unreachable
$15:
; # (while (lt0 (getLock (Db: fd) N Len)) (unless (== (gErrno) EINTR)...
  br label %$16
$16:
; # (Db: fd)
  %21 = bitcast i8* %0 to i32*
  %22 = load i32, i32* %21
; # (getLock (Db: fd) N Len)
  %23 = call i32 @getLock(i32 %22, i64 %1, i64 %2)
; # (lt0 (getLock (Db: fd) N Len))
  %24 = icmp slt i32 %23, 0
  br i1 %24, label %$17, label %$18
$17:
; # (unless (== (gErrno) EINTR) (lockErr))
; # (gErrno)
  %25 = call i32 @gErrno()
; # (== (gErrno) EINTR)
  %26 = icmp eq i32 %25, 2
  br i1 %26, label %$20, label %$19
$19:
; # (lockErr)
  call void @lockErr()
  unreachable
$20:
  br label %$16
$18:
; # (? (gt0 @) @)
; # (gt0 @)
  %27 = icmp sgt i32 %23, 0
  br i1 %27, label %$22, label %$21
$22:
  br label %$4
$21:
  br label %$2
$4:
  %28 = phi i32 [0, %$6], [%23, %$22] ; # ->
  ret i32 %28
}

define void @lockJnl() align 8 {
$1:
; # (val $DbJnl)
  %0 = load i8*, i8** @$DbJnl
; # (fileno (val $DbJnl))
  %1 = call i32 @fileno(i8* %0)
; # (wrLockWait (fileno (val $DbJnl)) 0)
  call void @wrLockWait(i32 %1, i64 0)
  ret void
}

define void @unLockJnl() align 8 {
$1:
; # (let Jnl (val $DbJnl) (fflush Jnl) (unLock (fileno Jnl) 0 0))
; # (val $DbJnl)
  %0 = load i8*, i8** @$DbJnl
; # (fflush Jnl)
  %1 = call i32 @fflush(i8* %0)
; # (fileno Jnl)
  %2 = call i32 @fileno(i8* %0)
; # (unLock (fileno Jnl) 0 0)
  %3 = call i32 @unLock(i32 %2, i64 0, i64 0)
  ret void
}

define void @blkPeek(i64, i8*, i32) align 8 {
$1:
; # (let (S (i64 Siz) Db: (dbFile (val $DbFile))) (unless (== S (prea...
; # (i64 Siz)
  %3 = sext i32 %2 to i64
; # (val $DbFile)
  %4 = load i8*, i8** @$DbFile
; # (unless (== S (pread (Db: fd) Buf S Pos)) (dbRdErr))
; # (Db: fd)
  %5 = bitcast i8* %4 to i32*
  %6 = load i32, i32* %5
; # (pread (Db: fd) Buf S Pos)
  %7 = call i64 @pread(i32 %6, i8* %1, i64 %3, i64 %0)
; # (== S (pread (Db: fd) Buf S Pos))
  %8 = icmp eq i64 %3, %7
  br i1 %8, label %$3, label %$2
$2:
; # (dbRdErr)
  call void @dbRdErr()
  unreachable
$3:
  ret void
}

define i8* @rdBlock(i64) align 8 {
$1:
; # (let (Db: (dbFile (val $DbFile)) Blk (val $DbBlock)) (blkPeek (sh...
; # (val $DbFile)
  %1 = load i8*, i8** @$DbFile
; # (val $DbBlock)
  %2 = load i8*, i8** @$DbBlock
; # (set $BlkIndex N)
  store i64 %0, i64* @$BlkIndex
; # (Db: sh)
  %3 = getelementptr i8, i8* %1, i32 8
  %4 = bitcast i8* %3 to i32*
  %5 = load i32, i32* %4
; # (i64 (Db: sh))
  %6 = sext i32 %5 to i64
; # (shl (set $BlkIndex N) (i64 (Db: sh)))
  %7 = shl i64 %0, %6
; # (Db: siz)
  %8 = getelementptr i8, i8* %1, i32 12
  %9 = bitcast i8* %8 to i32*
  %10 = load i32, i32* %9
; # (blkPeek (shl (set $BlkIndex N) (i64 (Db: sh))) Blk (Db: siz))
  call void @blkPeek(i64 %7, i8* %2, i32 %10)
; # (set $BlkLink (& (getAdr Blk) BLKMASK) $BlkEnd (ofs Blk (Db: siz)...
; # (getAdr Blk)
  %11 = call i64 @getAdr(i8* %2)
; # (& (getAdr Blk) BLKMASK)
  %12 = and i64 %11, -64
  store i64 %12, i64* @$BlkLink
; # (Db: siz)
  %13 = getelementptr i8, i8* %1, i32 12
  %14 = bitcast i8* %13 to i32*
  %15 = load i32, i32* %14
; # (ofs Blk (Db: siz))
  %16 = getelementptr i8, i8* %2, i32 %15
  store i8* %16, i8** @$BlkEnd
; # (ofs Blk BLK)
  %17 = getelementptr i8, i8* %2, i32 6
  store i8* %17, i8** @$BlkPtr
  ret i8* %2
}

define void @blkPoke(i64, i8*, i32) align 8 {
$1:
; # (let Db: (dbFile (val $DbFile)) (unless (== Siz (i32 (pwrite (Db:...
; # (val $DbFile)
  %3 = load i8*, i8** @$DbFile
; # (unless (== Siz (i32 (pwrite (Db: fd) Buf (i64 Siz) Pos))) (dbWrE...
; # (Db: fd)
  %4 = bitcast i8* %3 to i32*
  %5 = load i32, i32* %4
; # (i64 Siz)
  %6 = sext i32 %2 to i64
; # (pwrite (Db: fd) Buf (i64 Siz) Pos)
  %7 = call i64 @pwrite(i32 %5, i8* %1, i64 %6, i64 %0)
; # (i32 (pwrite (Db: fd) Buf (i64 Siz) Pos))
  %8 = trunc i64 %7 to i32
; # (== Siz (i32 (pwrite (Db: fd) Buf (i64 Siz) Pos)))
  %9 = icmp eq i32 %2, %8
  br i1 %9, label %$3, label %$2
$2:
; # (dbWrErr)
  call void @dbWrErr()
  unreachable
$3:
; # (when (val $DbJnl) (let Jnl @ (putc_unlocked (if (== Siz (Db: siz...
; # (val $DbJnl)
  %10 = load i8*, i8** @$DbJnl
  %11 = icmp ne i8* %10, null
  br i1 %11, label %$4, label %$5
$4:
; # (let Jnl @ (putc_unlocked (if (== Siz (Db: siz)) 0 Siz) Jnl) (let...
; # (if (== Siz (Db: siz)) 0 Siz)
; # (Db: siz)
  %12 = getelementptr i8, i8* %3, i32 12
  %13 = bitcast i8* %12 to i32*
  %14 = load i32, i32* %13
; # (== Siz (Db: siz))
  %15 = icmp eq i32 %2, %14
  br i1 %15, label %$6, label %$7
$6:
  br label %$8
$7:
  br label %$8
$8:
  %16 = phi i32 [0, %$6], [%2, %$7] ; # ->
; # (putc_unlocked (if (== Siz (Db: siz)) 0 Siz) Jnl)
  %17 = call i32 @putc_unlocked(i32 %16, i8* %10)
; # (let P (b8 (+ BLK 2)) (set P (i8 (Db: db))) (set 2 P (i8 (shr (Db...
; # (+ BLK 2)
; # (b8 (+ BLK 2))
  %18 = alloca i8, i64 8
; # (set P (i8 (Db: db)))
; # (Db: db)
  %19 = getelementptr i8, i8* %3, i32 4
  %20 = bitcast i8* %19 to i32*
  %21 = load i32, i32* %20
; # (i8 (Db: db))
  %22 = trunc i32 %21 to i8
  store i8 %22, i8* %18
; # (set 2 P (i8 (shr (Db: db) 8)))
; # (Db: db)
  %23 = getelementptr i8, i8* %3, i32 4
  %24 = bitcast i8* %23 to i32*
  %25 = load i32, i32* %24
; # (shr (Db: db) 8)
  %26 = lshr i32 %25, 8
; # (i8 (shr (Db: db) 8))
  %27 = trunc i32 %26 to i8
  %28 = getelementptr i8, i8* %18, i32 1
  store i8 %27, i8* %28
; # (Db: sh)
  %29 = getelementptr i8, i8* %3, i32 8
  %30 = bitcast i8* %29 to i32*
  %31 = load i32, i32* %30
; # (i64 (Db: sh))
  %32 = sext i32 %31 to i64
; # (shr Pos (i64 (Db: sh)))
  %33 = lshr i64 %0, %32
; # (ofs P 2)
  %34 = getelementptr i8, i8* %18, i32 2
; # (setAdr (shr Pos (i64 (Db: sh))) (ofs P 2))
  call void @setAdr(i64 %33, i8* %34)
; # (unless (and (== 1 (fwrite P (+ BLK 2) 1 Jnl)) (== 1 (fwrite Buf ...
; # (and (== 1 (fwrite P (+ BLK 2) 1 Jnl)) (== 1 (fwrite Buf (i64 Siz...
; # (+ BLK 2)
; # (fwrite P (+ BLK 2) 1 Jnl)
  %35 = call i32 @fwrite(i8* %18, i64 8, i64 1, i8* %10)
; # (== 1 (fwrite P (+ BLK 2) 1 Jnl))
  %36 = icmp eq i32 1, %35
  br i1 %36, label %$10, label %$9
$10:
; # (i64 Siz)
  %37 = sext i32 %2 to i64
; # (fwrite Buf (i64 Siz) 1 Jnl)
  %38 = call i32 @fwrite(i8* %1, i64 %37, i64 1, i8* %10)
; # (== 1 (fwrite Buf (i64 Siz) 1 Jnl))
  %39 = icmp eq i32 1, %38
  br label %$9
$9:
  %40 = phi i1 [0, %$8], [%39, %$10] ; # ->
  br i1 %40, label %$12, label %$11
$11:
; # (strErrno)
  %41 = call i8* @strErrno()
; # (err 0 0 ($ "Journal write: %s") (strErrno))
  call void @err(i64 0, i64 0, i8* bitcast ([18 x i8]* @$57 to i8*), i8* %41)
  unreachable
$12:
  br label %$5
$5:
  ret void
}

define void @wrBlock() align 8 {
$1:
; # (let Db: (dbFile (val $DbFile)) (blkPoke (shl (val $BlkIndex) (i6...
; # (val $DbFile)
  %0 = load i8*, i8** @$DbFile
; # (val $BlkIndex)
  %1 = load i64, i64* @$BlkIndex
; # (Db: sh)
  %2 = getelementptr i8, i8* %0, i32 8
  %3 = bitcast i8* %2 to i32*
  %4 = load i32, i32* %3
; # (i64 (Db: sh))
  %5 = sext i32 %4 to i64
; # (shl (val $BlkIndex) (i64 (Db: sh)))
  %6 = shl i64 %1, %5
; # (val $DbBlock)
  %7 = load i8*, i8** @$DbBlock
; # (Db: siz)
  %8 = getelementptr i8, i8* %0, i32 12
  %9 = bitcast i8* %8 to i32*
  %10 = load i32, i32* %9
; # (blkPoke (shl (val $BlkIndex) (i64 (Db: sh))) (val $DbBlock) (Db:...
  call void @blkPoke(i64 %6, i8* %7, i32 %10)
  ret void
}

define void @logBlock() align 8 {
$1:
; # (let (Db: (dbFile (val $DbFile)) Log (val $DbLog) P (b8 (+ BLK 2)...
; # (val $DbFile)
  %0 = load i8*, i8** @$DbFile
; # (val $DbLog)
  %1 = load i8*, i8** @$DbLog
; # (+ BLK 2)
; # (b8 (+ BLK 2))
  %2 = alloca i8, i64 8
; # (set P (i8 (Db: db)))
; # (Db: db)
  %3 = getelementptr i8, i8* %0, i32 4
  %4 = bitcast i8* %3 to i32*
  %5 = load i32, i32* %4
; # (i8 (Db: db))
  %6 = trunc i32 %5 to i8
  store i8 %6, i8* %2
; # (set 2 P (i8 (shr (Db: db) 8)))
; # (Db: db)
  %7 = getelementptr i8, i8* %0, i32 4
  %8 = bitcast i8* %7 to i32*
  %9 = load i32, i32* %8
; # (shr (Db: db) 8)
  %10 = lshr i32 %9, 8
; # (i8 (shr (Db: db) 8))
  %11 = trunc i32 %10 to i8
  %12 = getelementptr i8, i8* %2, i32 1
  store i8 %11, i8* %12
; # (val $BlkIndex)
  %13 = load i64, i64* @$BlkIndex
; # (ofs P 2)
  %14 = getelementptr i8, i8* %2, i32 2
; # (setAdr (val $BlkIndex) (ofs P 2))
  call void @setAdr(i64 %13, i8* %14)
; # (unless (and (== 1 (fwrite P (+ BLK 2) 1 Log)) (== 1 (fwrite (val...
; # (and (== 1 (fwrite P (+ BLK 2) 1 Log)) (== 1 (fwrite (val $DbBloc...
; # (+ BLK 2)
; # (fwrite P (+ BLK 2) 1 Log)
  %15 = call i32 @fwrite(i8* %2, i64 8, i64 1, i8* %1)
; # (== 1 (fwrite P (+ BLK 2) 1 Log))
  %16 = icmp eq i32 1, %15
  br i1 %16, label %$3, label %$2
$3:
; # (val $DbBlock)
  %17 = load i8*, i8** @$DbBlock
; # (Db: siz)
  %18 = getelementptr i8, i8* %0, i32 12
  %19 = bitcast i8* %18 to i32*
  %20 = load i32, i32* %19
; # (i64 (Db: siz))
  %21 = sext i32 %20 to i64
; # (fwrite (val $DbBlock) (i64 (Db: siz)) 1 Log)
  %22 = call i32 @fwrite(i8* %17, i64 %21, i64 1, i8* %1)
; # (== 1 (fwrite (val $DbBlock) (i64 (Db: siz)) 1 Log))
  %23 = icmp eq i32 1, %22
  br label %$2
$2:
  %24 = phi i1 [0, %$1], [%23, %$3] ; # ->
  br i1 %24, label %$5, label %$4
$4:
; # (strErrno)
  %25 = call i8* @strErrno()
; # (err 0 0 ($ "Log write: %s") (strErrno))
  call void @err(i64 0, i64 0, i8* bitcast ([14 x i8]* @$58 to i8*), i8* %25)
  unreachable
$5:
  ret void
}

define i64 @newBlock() align 8 {
$1:
; # (let (Db: (dbFile (val $DbFile)) Siz (Db: siz) P (b8 Siz)) (blkPe...
; # (val $DbFile)
  %0 = load i8*, i8** @$DbFile
; # (Db: siz)
  %1 = getelementptr i8, i8* %0, i32 12
  %2 = bitcast i8* %1 to i32*
  %3 = load i32, i32* %2
; # (b8 Siz)
  %4 = alloca i8, i32 %3
; # (* 2 BLK)
; # (blkPeek 0 P (* 2 BLK))
  call void @blkPeek(i64 0, i8* %4, i32 12)
; # (let N (getAdr P) (cond ((and N (Db: flu)) (blkPeek (shl N (i64 (...
; # (getAdr P)
  %5 = call i64 @getAdr(i8* %4)
; # (cond ((and N (Db: flu)) (blkPeek (shl N (i64 (Db: sh))) P BLK) (...
; # (and N (Db: flu))
  %6 = icmp ne i64 %5, 0
  br i1 %6, label %$4, label %$3
$4:
  %7 = phi i64 [%5, %$1] ; # N
; # (Db: flu)
  %8 = getelementptr i8, i8* %0, i32 32
  %9 = bitcast i8* %8 to i64*
  %10 = load i64, i64* %9
  %11 = icmp ne i64 %10, 0
  br label %$3
$3:
  %12 = phi i64 [%5, %$1], [%7, %$4] ; # N
  %13 = phi i1 [0, %$1], [%11, %$4] ; # ->
  br i1 %13, label %$6, label %$5
$6:
  %14 = phi i64 [%12, %$3] ; # N
; # (Db: sh)
  %15 = getelementptr i8, i8* %0, i32 8
  %16 = bitcast i8* %15 to i32*
  %17 = load i32, i32* %16
; # (i64 (Db: sh))
  %18 = sext i32 %17 to i64
; # (shl N (i64 (Db: sh)))
  %19 = shl i64 %14, %18
; # (blkPeek (shl N (i64 (Db: sh))) P BLK)
  call void @blkPeek(i64 %19, i8* %4, i32 6)
; # (Db: flu (dec (Db: flu)))
  %20 = getelementptr i8, i8* %0, i32 32
  %21 = bitcast i8* %20 to i64*
  %22 = getelementptr i8, i8* %0, i32 32
  %23 = bitcast i8* %22 to i64*
  %24 = load i64, i64* %23
  %25 = sub i64 %24, 1
  store i64 %25, i64* %21
  br label %$2
$5:
  %26 = phi i64 [%12, %$3] ; # N
; # (ofs P BLK)
  %27 = getelementptr i8, i8* %4, i32 6
; # (getAdr (ofs P BLK))
  %28 = call i64 @getAdr(i8* %27)
; # (== (setq N (getAdr (ofs P BLK))) (hex "FFFFFFFFFFC0"))
  %29 = icmp eq i64 %28, 281474976710592
  br i1 %29, label %$8, label %$7
$8:
  %30 = phi i64 [%28, %$5] ; # N
; # (err 0 0 ($ "DB Oversize") null)
  call void @err(i64 0, i64 0, i8* bitcast ([12 x i8]* @$59 to i8*), i8* null)
  unreachable
$7:
  %31 = phi i64 [%28, %$5] ; # N
; # (+ N BLKSIZE)
  %32 = add i64 %31, 64
; # (ofs P BLK)
  %33 = getelementptr i8, i8* %4, i32 6
; # (setAdr (+ N BLKSIZE) (ofs P BLK))
  call void @setAdr(i64 %32, i8* %33)
  br label %$2
$2:
  %34 = phi i64 [%14, %$6], [%31, %$7] ; # N
; # (* 2 BLK)
; # (blkPoke 0 P (* 2 BLK))
  call void @blkPoke(i64 0, i8* %4, i32 12)
; # (i64 Siz)
  %35 = sext i32 %3 to i64
; # (memset P 0 (i64 Siz) T)
  call void @llvm.memset.p0i8.i64(i8* align 8 %4, i8 0, i64 %35, i1 0)
; # (Db: sh)
  %36 = getelementptr i8, i8* %0, i32 8
  %37 = bitcast i8* %36 to i32*
  %38 = load i32, i32* %37
; # (i64 (Db: sh))
  %39 = sext i32 %38 to i64
; # (shl N (i64 (Db: sh)))
  %40 = shl i64 %34, %39
; # (blkPoke (shl N (i64 (Db: sh))) P Siz)
  call void @blkPoke(i64 %40, i8* %4, i32 %3)
  ret i64 %34
}

define i64 @newId(i64, i32) align 8 {
$1:
; # (when (>= (dec 'N) (val $DBs)) (dbfErr Exe))
; # (dec 'N)
  %2 = sub i32 %1, 1
; # (val $DBs)
  %3 = load i32, i32* @$DBs
; # (>= (dec 'N) (val $DBs))
  %4 = icmp sge i32 %2, %3
  br i1 %4, label %$2, label %$3
$2:
  %5 = phi i32 [%2, %$1] ; # N
; # (dbfErr Exe)
  call void @dbfErr(i64 %0)
  unreachable
$3:
  %6 = phi i32 [%2, %$1] ; # N
; # (set $DbFile (ofs (val $DbFiles) (* N (dbFile T))))
; # (val $DbFiles)
  %7 = load i8*, i8** @$DbFiles
; # (* N (dbFile T))
  %8 = mul i32 %6, 48
; # (ofs (val $DbFiles) (* N (dbFile T)))
  %9 = getelementptr i8, i8* %7, i32 %8
  store i8* %9, i8** @$DbFile
; # (set $Protect (inc (val $Protect)))
; # (val $Protect)
  %10 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 176) to i32*)
; # (inc (val $Protect))
  %11 = add i32 %10, 1
  store i32 %11, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 176) to i32*)
; # (wrLockDb)
  call void @wrLockDb()
; # (when (val $DbJnl) (lockJnl))
; # (val $DbJnl)
  %12 = load i8*, i8** @$DbJnl
  %13 = icmp ne i8* %12, null
  br i1 %13, label %$4, label %$5
$4:
  %14 = phi i32 [%6, %$3] ; # N
; # (lockJnl)
  call void @lockJnl()
  br label %$5
$5:
  %15 = phi i32 [%6, %$3], [%14, %$4] ; # N
; # (prog1 (extNm ((dbFile (val $DbFile)) db) (shr (newBlock) 6)) (wh...
; # (val $DbFile)
  %16 = load i8*, i8** @$DbFile
; # ((dbFile (val $DbFile)) db)
  %17 = getelementptr i8, i8* %16, i32 4
  %18 = bitcast i8* %17 to i32*
  %19 = load i32, i32* %18
; # (newBlock)
  %20 = call i64 @newBlock()
; # (shr (newBlock) 6)
  %21 = lshr i64 %20, 6
; # (extNm ((dbFile (val $DbFile)) db) (shr (newBlock) 6))
  %22 = call i64 @extNm(i32 %19, i64 %21)
; # (when (val $DbJnl) (unLockJnl))
; # (val $DbJnl)
  %23 = load i8*, i8** @$DbJnl
  %24 = icmp ne i8* %23, null
  br i1 %24, label %$6, label %$7
$6:
  %25 = phi i32 [%15, %$5] ; # N
; # (unLockJnl)
  call void @unLockJnl()
  br label %$7
$7:
  %26 = phi i32 [%15, %$5], [%25, %$6] ; # N
; # (unLockDb 1)
  call void @unLockDb(i64 1)
; # (set $Protect (dec (val $Protect)))
; # (val $Protect)
  %27 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 176) to i32*)
; # (dec (val $Protect))
  %28 = sub i32 %27, 1
  store i32 %28, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 176) to i32*)
  ret i64 %22
}

define i1 @isLife(i64) align 8 {
$1:
; # (let (Nm (name (& (val (tail Sym)) -9)) F (objFile Nm) N (shl (ob...
; # (tail Sym)
  %1 = add i64 %0, -8
; # (val (tail Sym))
  %2 = inttoptr i64 %1 to i64*
  %3 = load i64, i64* %2
; # (& (val (tail Sym)) -9)
  %4 = and i64 %3, -9
; # (name (& (val (tail Sym)) -9))
  br label %$2
$2:
  %5 = phi i64 [%4, %$1], [%11, %$3] ; # Tail
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$3:
  %8 = phi i64 [%5, %$2] ; # Tail
  %9 = inttoptr i64 %8 to i64*
  %10 = getelementptr i64, i64* %9, i32 1
  %11 = load i64, i64* %10
  br label %$2
$4:
  %12 = phi i64 [%5, %$2] ; # Tail
; # (objFile Nm)
  %13 = call i32 @objFile(i64 %12)
; # (objId Nm)
  %14 = call i64 @objId(i64 %12)
; # (shl (objId Nm) 6)
  %15 = shl i64 %14, 6
; # (when N (cond ((> (val $DBs) F) (setq Nm (add Nm Nm)) (when @@ (r...
  %16 = icmp ne i64 %15, 0
  br i1 %16, label %$5, label %$6
$5:
  %17 = phi i64 [%12, %$4] ; # Nm
; # (cond ((> (val $DBs) F) (setq Nm (add Nm Nm)) (when @@ (ret YES))...
; # (val $DBs)
  %18 = load i32, i32* @$DBs
; # (> (val $DBs) F)
  %19 = icmp sgt i32 %18, %13
  br i1 %19, label %$9, label %$8
$9:
  %20 = phi i64 [%17, %$5] ; # Nm
; # (add Nm Nm)
  %21 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %20, i64 %20)
  %22 = extractvalue {i64, i1} %21, 1
  %23 = extractvalue {i64, i1} %21, 0
; # (when @@ (ret YES))
  br i1 %22, label %$10, label %$11
$10:
  %24 = phi i64 [%23, %$9] ; # Nm
; # (ret YES)
  ret i1 1
$11:
  %25 = phi i64 [%23, %$9] ; # Nm
; # (add Nm Nm)
  %26 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %25, i64 %25)
  %27 = extractvalue {i64, i1} %26, 1
  %28 = extractvalue {i64, i1} %26, 0
; # (when @@ (ret YES))
  br i1 %27, label %$12, label %$13
$12:
  %29 = phi i64 [%25, %$11] ; # Nm
; # (ret YES)
  ret i1 1
$13:
  %30 = phi i64 [%25, %$11] ; # Nm
; # (let (Db: (dbFile (set $DbFile (ofs (val $DbFiles) (* F (dbFile T...
; # (set $DbFile (ofs (val $DbFiles) (* F (dbFile T))))
; # (val $DbFiles)
  %31 = load i8*, i8** @$DbFiles
; # (* F (dbFile T))
  %32 = mul i32 %13, 48
; # (ofs (val $DbFiles) (* F (dbFile T)))
  %33 = getelementptr i8, i8* %31, i32 %32
  store i8* %33, i8** @$DbFile
; # (* BLK 2)
; # (b8 (* BLK 2))
  %34 = alloca i8, i64 12
; # (blkPeek BLK P BLK)
  call void @blkPeek(i64 6, i8* %34, i32 6)
; # (when (> (getAdr P) N) (blkPeek (shl N (i64 (Db: sh))) P BLK) (wh...
; # (getAdr P)
  %35 = call i64 @getAdr(i8* %34)
; # (> (getAdr P) N)
  %36 = icmp ugt i64 %35, %15
  br i1 %36, label %$14, label %$15
$14:
  %37 = phi i64 [%30, %$13] ; # Nm
; # (Db: sh)
  %38 = getelementptr i8, i8* %33, i32 8
  %39 = bitcast i8* %38 to i32*
  %40 = load i32, i32* %39
; # (i64 (Db: sh))
  %41 = sext i32 %40 to i64
; # (shl N (i64 (Db: sh)))
  %42 = shl i64 %15, %41
; # (blkPeek (shl N (i64 (Db: sh))) P BLK)
  call void @blkPeek(i64 %42, i8* %34, i32 6)
; # (when (== 1 (& (val P) BLKTAG)) (ret YES))
; # (val P)
  %43 = load i8, i8* %34
; # (& (val P) BLKTAG)
  %44 = and i8 %43, 63
; # (== 1 (& (val P) BLKTAG))
  %45 = icmp eq i8 1, %44
  br i1 %45, label %$16, label %$17
$16:
  %46 = phi i64 [%37, %$14] ; # Nm
; # (ret YES)
  ret i1 1
$17:
  %47 = phi i64 [%37, %$14] ; # Nm
  br label %$15
$15:
  %48 = phi i64 [%30, %$13], [%47, %$17] ; # Nm
  br label %$7
$8:
  %49 = phi i64 [%17, %$5] ; # Nm
; # (val $Ext)
  %50 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 536) to i64) to i64*
  %51 = load i64, i64* %50
; # (pair (val $Ext))
  %52 = and i64 %51, 15
  %53 = icmp eq i64 %52, 0
  br i1 %53, label %$19, label %$18
$19:
  %54 = phi i64 [%49, %$8] ; # Nm
; # (ret YES)
  ret i1 1
$18:
  %55 = phi i64 [%49, %$8] ; # Nm
  br label %$7
$7:
  %56 = phi i64 [%48, %$15], [%55, %$18] ; # Nm
  br label %$6
$6:
  %57 = phi i64 [%12, %$4], [%56, %$7] ; # Nm
  ret i1 0
}

define i64 @_ExtQ(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (save (eval (++ X)))) (if (and (symb? Y) (sym...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (save (eval (++ X)))
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %17 = load i64, i64* %16
  %18 = alloca i64, i64 2, align 16
  %19 = ptrtoint i64* %18 to i64
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = add i64 %19, 8
  %22 = inttoptr i64 %21 to i64*
  store i64 %17, i64* %22
  %23 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %19, i64* %23
; # (if (and (symb? Y) (sym? (val (tail Y))) (or (nil? (eval (car X))...
; # (and (symb? Y) (sym? (val (tail Y))) (or (nil? (eval (car X))) (i...
; # (symb? Y)
  %24 = xor i64 %15, 8
  %25 = and i64 %24, 14
  %26 = icmp eq i64 %25, 0
  br i1 %26, label %$8, label %$7
$8:
; # (tail Y)
  %27 = add i64 %15, -8
; # (val (tail Y))
  %28 = inttoptr i64 %27 to i64*
  %29 = load i64, i64* %28
; # (sym? (val (tail Y)))
  %30 = and i64 %29, 8
  %31 = icmp ne i64 %30, 0
  br i1 %31, label %$9, label %$7
$9:
; # (or (nil? (eval (car X))) (isLife Y))
; # (car X)
  %32 = inttoptr i64 %7 to i64*
  %33 = load i64, i64* %32
; # (eval (car X))
  %34 = and i64 %33, 6
  %35 = icmp ne i64 %34, 0
  br i1 %35, label %$13, label %$12
$13:
  br label %$11
$12:
  %36 = and i64 %33, 8
  %37 = icmp ne i64 %36, 0
  br i1 %37, label %$15, label %$14
$15:
  %38 = inttoptr i64 %33 to i64*
  %39 = load i64, i64* %38
  br label %$11
$14:
  %40 = call i64 @evList(i64 %33)
  br label %$11
$11:
  %41 = phi i64 [%33, %$13], [%39, %$15], [%40, %$14] ; # ->
; # (nil? (eval (car X)))
  %42 = icmp eq i64 %41, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %42, label %$10, label %$16
$16:
; # (isLife Y)
  %43 = call i1 @isLife(i64 %15)
  br label %$10
$10:
  %44 = phi i1 [1, %$11], [%43, %$16] ; # ->
  br label %$7
$7:
  %45 = phi i1 [0, %$2], [0, %$8], [%44, %$10] ; # ->
  br i1 %45, label %$17, label %$18
$17:
  br label %$19
$18:
  br label %$19
$19:
  %46 = phi i64 [%15, %$17], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$18] ; # ->
; # (drop *Safe)
  %47 = inttoptr i64 %19 to i64*
  %48 = getelementptr i64, i64* %47, i32 1
  %49 = load i64, i64* %48
  %50 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %49, i64* %50
  ret i64 %46
}

define void @cleanUp(i64) align 8 {
$1:
; # (let (P (b8 BLK) Db: (dbFile (val $DbFile))) (blkPeek 0 P BLK) (l...
; # (b8 BLK)
  %1 = alloca i8, i64 6
; # (val $DbFile)
  %2 = load i8*, i8** @$DbFile
; # (blkPeek 0 P BLK)
  call void @blkPeek(i64 0, i8* %1, i32 6)
; # (let Free (getAdr P) (setAdr N P) (blkPoke 0 P BLK) (loop (let Po...
; # (getAdr P)
  %3 = call i64 @getAdr(i8* %1)
; # (setAdr N P)
  call void @setAdr(i64 %0, i8* %1)
; # (blkPoke 0 P BLK)
  call void @blkPoke(i64 0, i8* %1, i32 6)
; # (loop (let Pos (shl N (i64 (Db: sh))) (blkPeek Pos P BLK) (set P ...
  br label %$2
$2:
  %4 = phi i64 [%0, %$1], [%15, %$3] ; # N
; # (let Pos (shl N (i64 (Db: sh))) (blkPeek Pos P BLK) (set P (& (va...
; # (Db: sh)
  %5 = getelementptr i8, i8* %2, i32 8
  %6 = bitcast i8* %5 to i32*
  %7 = load i32, i32* %6
; # (i64 (Db: sh))
  %8 = sext i32 %7 to i64
; # (shl N (i64 (Db: sh)))
  %9 = shl i64 %4, %8
; # (blkPeek Pos P BLK)
  call void @blkPeek(i64 %9, i8* %1, i32 6)
; # (set P (& (val P) BLKMASK))
; # (val P)
  %10 = load i8, i8* %1
; # (& (val P) BLKMASK)
  %11 = and i8 %10, -64
  store i8 %11, i8* %1
; # (? (=0 (setq N (getAdr P))) (setAdr Free P) (blkPoke Pos P BLK))
; # (getAdr P)
  %12 = call i64 @getAdr(i8* %1)
; # (=0 (setq N (getAdr P)))
  %13 = icmp eq i64 %12, 0
  br i1 %13, label %$5, label %$3
$5:
  %14 = phi i64 [%12, %$2] ; # N
; # (setAdr Free P)
  call void @setAdr(i64 %3, i8* %1)
; # (blkPoke Pos P BLK)
  call void @blkPoke(i64 %9, i8* %1, i32 6)
  br label %$4
$3:
  %15 = phi i64 [%12, %$2] ; # N
; # (blkPoke Pos P BLK)
  call void @blkPoke(i64 %9, i8* %1, i32 6)
  br label %$2
$4:
  %16 = phi i64 [%14, %$5] ; # N
  ret void
}

define i32 @getBlock() align 8 {
$1:
; # (let P (val $BlkPtr) (when (== P (val $BlkEnd)) (unless (val $Blk...
; # (val $BlkPtr)
  %0 = load i8*, i8** @$BlkPtr
; # (when (== P (val $BlkEnd)) (unless (val $BlkLink) (ret -1)) (setq...
; # (val $BlkEnd)
  %1 = load i8*, i8** @$BlkEnd
; # (== P (val $BlkEnd))
  %2 = icmp eq i8* %0, %1
  br i1 %2, label %$2, label %$3
$2:
  %3 = phi i8* [%0, %$1] ; # P
; # (unless (val $BlkLink) (ret -1))
; # (val $BlkLink)
  %4 = load i64, i64* @$BlkLink
  %5 = icmp ne i64 %4, 0
  br i1 %5, label %$5, label %$4
$4:
  %6 = phi i8* [%3, %$2] ; # P
; # (ret -1)
  ret i32 -1
$5:
  %7 = phi i8* [%3, %$2] ; # P
; # (rdBlock @)
  %8 = call i8* @rdBlock(i64 %4)
; # (ofs (rdBlock @) BLK)
  %9 = getelementptr i8, i8* %8, i32 6
  br label %$3
$3:
  %10 = phi i8* [%0, %$1], [%9, %$5] ; # P
; # (set $BlkPtr (inc P))
; # (inc P)
  %11 = getelementptr i8, i8* %10, i32 1
  store i8* %11, i8** @$BlkPtr
; # (val P)
  %12 = load i8, i8* %10
; # (i32 (val P))
  %13 = zext i8 %12 to i32
  ret i32 %13
}

define void @putBlock(i8) align 8 {
$1:
; # (let P (val $BlkPtr) (when (== P (val $BlkEnd)) (let Link (val $B...
; # (val $BlkPtr)
  %1 = load i8*, i8** @$BlkPtr
; # (when (== P (val $BlkEnd)) (let Link (val $BlkLink) (ifn Link (le...
; # (val $BlkEnd)
  %2 = load i8*, i8** @$BlkEnd
; # (== P (val $BlkEnd))
  %3 = icmp eq i8* %1, %2
  br i1 %3, label %$2, label %$3
$2:
  %4 = phi i8* [%1, %$1] ; # P
; # (let Link (val $BlkLink) (ifn Link (let (New (newBlock) Cnt (i64 ...
; # (val $BlkLink)
  %5 = load i64, i64* @$BlkLink
; # (ifn Link (let (New (newBlock) Cnt (i64 (val (setq P (val $DbBloc...
  %6 = icmp ne i64 %5, 0
  br i1 %6, label %$5, label %$4
$4:
  %7 = phi i8* [%4, %$2] ; # P
; # (let (New (newBlock) Cnt (i64 (val (setq P (val $DbBlock))))) (se...
; # (newBlock)
  %8 = call i64 @newBlock()
; # (val $DbBlock)
  %9 = load i8*, i8** @$DbBlock
; # (val (setq P (val $DbBlock)))
  %10 = load i8, i8* %9
; # (i64 (val (setq P (val $DbBlock))))
  %11 = zext i8 %10 to i64
; # (| New Cnt)
  %12 = or i64 %8, %11
; # (setAdr (| New Cnt) P)
  call void @setAdr(i64 %12, i8* %9)
; # (wrBlock)
  call void @wrBlock()
; # (set $BlkIndex New)
  store i64 %8, i64* @$BlkIndex
; # (if (== Cnt BLKTAG) Cnt (inc Cnt))
; # (== Cnt BLKTAG)
  %13 = icmp eq i64 %11, 63
  br i1 %13, label %$7, label %$8
$7:
  %14 = phi i8* [%9, %$4] ; # P
  br label %$9
$8:
  %15 = phi i8* [%9, %$4] ; # P
; # (inc Cnt)
  %16 = add i64 %11, 1
  br label %$9
$9:
  %17 = phi i8* [%14, %$7], [%15, %$8] ; # P
  %18 = phi i64 [%11, %$7], [%16, %$8] ; # ->
; # (setAdr (if (== Cnt BLKTAG) Cnt (inc Cnt)) P)
  call void @setAdr(i64 %18, i8* %17)
; # (ofs P BLK)
  %19 = getelementptr i8, i8* %17, i32 6
  br label %$6
$5:
  %20 = phi i8* [%4, %$2] ; # P
; # (wrBlock)
  call void @wrBlock()
; # (rdBlock Link)
  %21 = call i8* @rdBlock(i64 %5)
; # (ofs (rdBlock Link) BLK)
  %22 = getelementptr i8, i8* %21, i32 6
  br label %$6
$6:
  %23 = phi i8* [%19, %$9], [%22, %$5] ; # P
  %24 = phi i8* [%19, %$9], [%22, %$5] ; # ->
  br label %$3
$3:
  %25 = phi i8* [%1, %$1], [%23, %$6] ; # P
; # (set P B)
  store i8 %0, i8* %25
; # (set $BlkPtr (inc P))
; # (inc P)
  %26 = getelementptr i8, i8* %25, i32 1
  store i8* %26, i8** @$BlkPtr
  ret void
}

define i64 @_Rollback(i64) align 8 {
$1:
; # (if (and (=0 (val $DBs)) (atom (val $Ext))) $Nil (let (Tos 0 P (v...
; # (and (=0 (val $DBs)) (atom (val $Ext)))
; # (val $DBs)
  %1 = load i32, i32* @$DBs
; # (=0 (val $DBs))
  %2 = icmp eq i32 %1, 0
  br i1 %2, label %$3, label %$2
$3:
; # (val $Ext)
  %3 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 536) to i64) to i64*
  %4 = load i64, i64* %3
; # (atom (val $Ext))
  %5 = and i64 %4, 15
  %6 = icmp ne i64 %5, 0
  br label %$2
$2:
  %7 = phi i1 [0, %$1], [%6, %$3] ; # ->
  br i1 %7, label %$4, label %$5
$4:
  br label %$6
$5:
; # (let (Tos 0 P (val $Extern)) (loop (loop (let X (cdr P) (? (atom ...
; # (val $Extern)
  %8 = load i64, i64* @$Extern
; # (loop (loop (let X (cdr P) (? (atom (cdr X))) (let Y P (setq P @)...
  br label %$7
$7:
  %9 = phi i64 [0, %$5], [%109, %$18] ; # Tos
  %10 = phi i64 [%8, %$5], [%110, %$18] ; # P
; # (loop (let X (cdr P) (? (atom (cdr X))) (let Y P (setq P @) (set ...
  br label %$8
$8:
  %11 = phi i64 [%9, %$7], [%22, %$9] ; # Tos
  %12 = phi i64 [%10, %$7], [%18, %$9] ; # P
; # (let X (cdr P) (? (atom (cdr X))) (let Y P (setq P @) (set 2 X To...
; # (cdr P)
  %13 = inttoptr i64 %12 to i64*
  %14 = getelementptr i64, i64* %13, i32 1
  %15 = load i64, i64* %14
; # (? (atom (cdr X)))
; # (cdr X)
  %16 = inttoptr i64 %15 to i64*
  %17 = getelementptr i64, i64* %16, i32 1
  %18 = load i64, i64* %17
; # (atom (cdr X))
  %19 = and i64 %18, 15
  %20 = icmp ne i64 %19, 0
  br i1 %20, label %$10, label %$9
$9:
  %21 = phi i64 [%11, %$8] ; # Tos
  %22 = phi i64 [%12, %$8] ; # P
; # (let Y P (setq P @) (set 2 X Tos) (setq Tos Y))
; # (set 2 X Tos)
  %23 = inttoptr i64 %15 to i64*
  %24 = getelementptr i64, i64* %23, i32 1
  store i64 %21, i64* %24
  br label %$8
$10:
  %25 = phi i64 [%11, %$8] ; # Tos
  %26 = phi i64 [%12, %$8] ; # P
  %27 = phi i64 [0, %$8] ; # ->
; # (loop (let (S (val P) Tail (val (tail S))) (unless (num? Tail) (s...
  br label %$11
$11:
  %28 = phi i64 [%25, %$10], [%106, %$24] ; # Tos
  %29 = phi i64 [%26, %$10], [%107, %$24] ; # P
; # (let (S (val P) Tail (val (tail S))) (unless (num? Tail) (setq Ta...
; # (val P)
  %30 = inttoptr i64 %29 to i64*
  %31 = load i64, i64* %30
; # (tail S)
  %32 = add i64 %31, -8
; # (val (tail S))
  %33 = inttoptr i64 %32 to i64*
  %34 = load i64, i64* %33
; # (unless (num? Tail) (setq Tail (& Tail -9)) (loop (? (num? (shift...
; # (num? Tail)
  %35 = and i64 %34, 6
  %36 = icmp ne i64 %35, 0
  br i1 %36, label %$13, label %$12
$12:
  %37 = phi i64 [%28, %$11] ; # Tos
  %38 = phi i64 [%29, %$11] ; # P
  %39 = phi i64 [%34, %$11] ; # Tail
; # (& Tail -9)
  %40 = and i64 %39, -9
; # (loop (? (num? (shift Tail))))
  br label %$14
$14:
  %41 = phi i64 [%37, %$12], [%49, %$15] ; # Tos
  %42 = phi i64 [%38, %$12], [%50, %$15] ; # P
  %43 = phi i64 [%40, %$12], [%51, %$15] ; # Tail
; # (? (num? (shift Tail)))
; # (shift Tail)
  %44 = inttoptr i64 %43 to i64*
  %45 = getelementptr i64, i64* %44, i32 1
  %46 = load i64, i64* %45
; # (num? (shift Tail))
  %47 = and i64 %46, 6
  %48 = icmp ne i64 %47, 0
  br i1 %48, label %$16, label %$15
$15:
  %49 = phi i64 [%41, %$14] ; # Tos
  %50 = phi i64 [%42, %$14] ; # P
  %51 = phi i64 [%46, %$14] ; # Tail
  br label %$14
$16:
  %52 = phi i64 [%41, %$14] ; # Tos
  %53 = phi i64 [%42, %$14] ; # P
  %54 = phi i64 [%46, %$14] ; # Tail
  %55 = phi i64 [0, %$14] ; # ->
; # (sym Tail)
  %56 = or i64 %54, 8
  br label %$13
$13:
  %57 = phi i64 [%28, %$11], [%52, %$16] ; # Tos
  %58 = phi i64 [%29, %$11], [%53, %$16] ; # P
  %59 = phi i64 [%34, %$11], [%56, %$16] ; # Tail
; # (set (tail S) (shr (shl Tail 2) 2))
; # (tail S)
  %60 = add i64 %31, -8
; # (shl Tail 2)
  %61 = shl i64 %59, 2
; # (shr (shl Tail 2) 2)
  %62 = lshr i64 %61, 2
  %63 = inttoptr i64 %60 to i64*
  store i64 %62, i64* %63
; # (set S $Nil)
  %64 = inttoptr i64 %31 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %64
; # (let X (cdr P) (? (pair (car X)) (let Y P (setq P @) (set X Tos) ...
; # (cdr P)
  %65 = inttoptr i64 %58 to i64*
  %66 = getelementptr i64, i64* %65, i32 1
  %67 = load i64, i64* %66
; # (? (pair (car X)) (let Y P (setq P @) (set X Tos) (setq Tos (| Y ...
; # (car X)
  %68 = inttoptr i64 %67 to i64*
  %69 = load i64, i64* %68
; # (pair (car X))
  %70 = and i64 %69, 15
  %71 = icmp eq i64 %70, 0
  br i1 %71, label %$19, label %$17
$19:
  %72 = phi i64 [%57, %$13] ; # Tos
  %73 = phi i64 [%58, %$13] ; # P
; # (let Y P (setq P @) (set X Tos) (setq Tos (| Y 8)))
; # (set X Tos)
  %74 = inttoptr i64 %67 to i64*
  store i64 %72, i64* %74
; # (| Y 8)
  %75 = or i64 %73, 8
  br label %$18
$17:
  %76 = phi i64 [%57, %$13] ; # Tos
  %77 = phi i64 [%58, %$13] ; # P
; # (loop (unless Tos (goto 1)) (? (=0 (& Tos 8)) (let (X Tos Y (cdr ...
  br label %$20
$20:
  %78 = phi i64 [%76, %$17], [%104, %$23] ; # Tos
  %79 = phi i64 [%77, %$17], [%99, %$23] ; # P
; # (unless Tos (goto 1))
  %80 = icmp ne i64 %78, 0
  br i1 %80, label %$22, label %$21
$21:
  %81 = phi i64 [%78, %$20] ; # Tos
  %82 = phi i64 [%79, %$20] ; # P
; # (goto 1)
  br label %$-1
$22:
  %83 = phi i64 [%78, %$20] ; # Tos
  %84 = phi i64 [%79, %$20] ; # P
; # (? (=0 (& Tos 8)) (let (X Tos Y (cdr X)) (setq Tos (cdr Y)) (set ...
; # (& Tos 8)
  %85 = and i64 %83, 8
; # (=0 (& Tos 8))
  %86 = icmp eq i64 %85, 0
  br i1 %86, label %$25, label %$23
$25:
  %87 = phi i64 [%83, %$22] ; # Tos
  %88 = phi i64 [%84, %$22] ; # P
; # (let (X Tos Y (cdr X)) (setq Tos (cdr Y)) (set 2 Y P) (setq P X))...
; # (cdr X)
  %89 = inttoptr i64 %87 to i64*
  %90 = getelementptr i64, i64* %89, i32 1
  %91 = load i64, i64* %90
; # (cdr Y)
  %92 = inttoptr i64 %91 to i64*
  %93 = getelementptr i64, i64* %92, i32 1
  %94 = load i64, i64* %93
; # (set 2 Y P)
  %95 = inttoptr i64 %91 to i64*
  %96 = getelementptr i64, i64* %95, i32 1
  store i64 %88, i64* %96
  br label %$24
$23:
  %97 = phi i64 [%83, %$22] ; # Tos
  %98 = phi i64 [%84, %$22] ; # P
; # (& Tos -9)
  %99 = and i64 %97, -9
; # (let (X Tos Y (cdr X)) (setq Tos (car Y)) (set Y P) (setq P X))
; # (cdr X)
  %100 = inttoptr i64 %99 to i64*
  %101 = getelementptr i64, i64* %100, i32 1
  %102 = load i64, i64* %101
; # (car Y)
  %103 = inttoptr i64 %102 to i64*
  %104 = load i64, i64* %103
; # (set Y P)
  %105 = inttoptr i64 %102 to i64*
  store i64 %98, i64* %105
  br label %$20
$24:
  %106 = phi i64 [%94, %$25] ; # Tos
  %107 = phi i64 [%87, %$25] ; # P
  %108 = phi i64 [%87, %$25] ; # ->
  br label %$11
$18:
  %109 = phi i64 [%75, %$19] ; # Tos
  %110 = phi i64 [%69, %$19] ; # P
  %111 = phi i64 [%75, %$19] ; # ->
  br label %$7
$26:
; # (: 1 (when (pair (val $Zap)) (set @ $Nil)))
  br label %$-1
$-1:
; # (when (pair (val $Zap)) (set @ $Nil))
; # (val $Zap)
  %112 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 520) to i64) to i64*
  %113 = load i64, i64* %112
; # (pair (val $Zap))
  %114 = and i64 %113, 15
  %115 = icmp eq i64 %114, 0
  br i1 %115, label %$27, label %$28
$27:
; # (set @ $Nil)
  %116 = inttoptr i64 %113 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %116
  br label %$28
$28:
; # (when (val $DBs) (unLockDb 0))
; # (val $DBs)
  %117 = load i32, i32* @$DBs
  %118 = icmp ne i32 %117, 0
  br i1 %118, label %$29, label %$30
$29:
; # (unLockDb 0)
  call void @unLockDb(i64 0)
  br label %$30
$30:
; # (unsync)
  call void @unsync()
  br label %$6
$6:
  %119 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$4], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$30] ; # ->
  ret i64 %119
}

define i64 @_Extern(i64) align 8 {
$1:
; # (let (Sym (needSymb Exe (eval (cadr Exe))) Nm (name (& (val (tail...
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (needSymb Exe (eval (cadr Exe)))
  %14 = xor i64 %13, 8
  %15 = and i64 %14, 14
  %16 = icmp eq i64 %15, 0
  br i1 %16, label %$8, label %$7
$7:
  call void @symErr(i64 %0, i64 %13)
  unreachable
$8:
; # (tail Sym)
  %17 = add i64 %13, -8
; # (val (tail Sym))
  %18 = inttoptr i64 %17 to i64*
  %19 = load i64, i64* %18
; # (& (val (tail Sym)) -9)
  %20 = and i64 %19, -9
; # (name (& (val (tail Sym)) -9))
  br label %$9
$9:
  %21 = phi i64 [%20, %$8], [%27, %$10] ; # Tail
  %22 = and i64 %21, 6
  %23 = icmp ne i64 %22, 0
  br i1 %23, label %$11, label %$10
$10:
  %24 = phi i64 [%21, %$9] ; # Tail
  %25 = inttoptr i64 %24 to i64*
  %26 = getelementptr i64, i64* %25, i32 1
  %27 = load i64, i64* %26
  br label %$9
$11:
  %28 = phi i64 [%21, %$9] ; # Tail
; # (when (== Nm ZERO) (ret $Nil))
; # (== Nm ZERO)
  %29 = icmp eq i64 %28, 2
  br i1 %29, label %$12, label %$13
$12:
  %30 = phi i64 [%13, %$11] ; # Sym
; # (ret $Nil)
  ret i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
$13:
  %31 = phi i64 [%13, %$11] ; # Sym
; # (let (P (push 0 Nm) C (symChar P) F (i32 0)) (when (== C (char "{...
; # (push 0 Nm)
  %32 = alloca i64, i64 2, align 16
  store i64 0, i64* %32
  %33 = getelementptr i64, i64* %32, i32 1
  store i64 %28, i64* %33
; # (symChar P)
  %34 = call i32 @symChar(i64* %32)
; # (i32 0)
; # (when (== C (char "{")) (setq C (symChar P)))
; # (== C (char "{"))
  %35 = icmp eq i32 %34, 123
  br i1 %35, label %$14, label %$15
$14:
  %36 = phi i64 [%31, %$13] ; # Sym
  %37 = phi i32 [%34, %$13] ; # C
  %38 = phi i32 [0, %$13] ; # F
; # (symChar P)
  %39 = call i32 @symChar(i64* %32)
  br label %$15
$15:
  %40 = phi i64 [%31, %$13], [%36, %$14] ; # Sym
  %41 = phi i32 [%34, %$13], [%39, %$14] ; # C
  %42 = phi i32 [0, %$13], [%38, %$14] ; # F
; # (while (>= C (char "@")) (when (> C (char "O")) (ret $Nil)) (setq...
  br label %$16
$16:
  %43 = phi i64 [%40, %$15], [%54, %$20] ; # Sym
  %44 = phi i32 [%41, %$15], [%60, %$20] ; # C
  %45 = phi i32 [%42, %$15], [%59, %$20] ; # F
; # (>= C (char "@"))
  %46 = icmp sge i32 %44, 64
  br i1 %46, label %$17, label %$18
$17:
  %47 = phi i64 [%43, %$16] ; # Sym
  %48 = phi i32 [%44, %$16] ; # C
  %49 = phi i32 [%45, %$16] ; # F
; # (when (> C (char "O")) (ret $Nil))
; # (> C (char "O"))
  %50 = icmp sgt i32 %48, 79
  br i1 %50, label %$19, label %$20
$19:
  %51 = phi i64 [%47, %$17] ; # Sym
  %52 = phi i32 [%48, %$17] ; # C
  %53 = phi i32 [%49, %$17] ; # F
; # (ret $Nil)
  ret i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
$20:
  %54 = phi i64 [%47, %$17] ; # Sym
  %55 = phi i32 [%48, %$17] ; # C
  %56 = phi i32 [%49, %$17] ; # F
; # (shl F 4)
  %57 = shl i32 %56, 4
; # (- C (char "@"))
  %58 = sub i32 %55, 64
; # (| (shl F 4) (- C (char "@")))
  %59 = or i32 %57, %58
; # (symChar P)
  %60 = call i32 @symChar(i64* %32)
  br label %$16
$18:
  %61 = phi i64 [%43, %$16] ; # Sym
  %62 = phi i32 [%44, %$16] ; # C
  %63 = phi i32 [%45, %$16] ; # F
; # (let N 0 (loop (unless (and (>= C (char "0")) (>= (char "7") C)) ...
; # (loop (unless (and (>= C (char "0")) (>= (char "7") C)) (ret $Nil...
  br label %$21
$21:
  %64 = phi i64 [%61, %$18], [%103, %$28] ; # Sym
  %65 = phi i32 [%62, %$18], [%104, %$28] ; # C
  %66 = phi i32 [%63, %$18], [%105, %$28] ; # F
  %67 = phi i64 [0, %$18], [%106, %$28] ; # N
; # (unless (and (>= C (char "0")) (>= (char "7") C)) (ret $Nil))
; # (and (>= C (char "0")) (>= (char "7") C))
; # (>= C (char "0"))
  %68 = icmp sge i32 %65, 48
  br i1 %68, label %$23, label %$22
$23:
  %69 = phi i64 [%64, %$21] ; # Sym
  %70 = phi i32 [%65, %$21] ; # C
  %71 = phi i32 [%66, %$21] ; # F
  %72 = phi i64 [%67, %$21] ; # N
; # (>= (char "7") C)
  %73 = icmp sge i32 55, %70
  br label %$22
$22:
  %74 = phi i64 [%64, %$21], [%69, %$23] ; # Sym
  %75 = phi i32 [%65, %$21], [%70, %$23] ; # C
  %76 = phi i32 [%66, %$21], [%71, %$23] ; # F
  %77 = phi i64 [%67, %$21], [%72, %$23] ; # N
  %78 = phi i1 [0, %$21], [%73, %$23] ; # ->
  br i1 %78, label %$25, label %$24
$24:
  %79 = phi i64 [%74, %$22] ; # Sym
  %80 = phi i32 [%75, %$22] ; # C
  %81 = phi i32 [%76, %$22] ; # F
  %82 = phi i64 [%77, %$22] ; # N
; # (ret $Nil)
  ret i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
$25:
  %83 = phi i64 [%74, %$22] ; # Sym
  %84 = phi i32 [%75, %$22] ; # C
  %85 = phi i32 [%76, %$22] ; # F
  %86 = phi i64 [%77, %$22] ; # N
; # (shl N 3)
  %87 = shl i64 %86, 3
; # (- C (char "0"))
  %88 = sub i32 %84, 48
; # (i64 (- C (char "0")))
  %89 = sext i32 %88 to i64
; # (| (shl N 3) (i64 (- C (char "0"))))
  %90 = or i64 %87, %89
; # (? (or (=0 (setq C (symChar P))) (== C (char "}"))))
; # (or (=0 (setq C (symChar P))) (== C (char "}")))
; # (symChar P)
  %91 = call i32 @symChar(i64* %32)
; # (=0 (setq C (symChar P)))
  %92 = icmp eq i32 %91, 0
  br i1 %92, label %$26, label %$27
$27:
  %93 = phi i64 [%83, %$25] ; # Sym
  %94 = phi i32 [%91, %$25] ; # C
  %95 = phi i32 [%85, %$25] ; # F
  %96 = phi i64 [%90, %$25] ; # N
; # (== C (char "}"))
  %97 = icmp eq i32 %94, 125
  br label %$26
$26:
  %98 = phi i64 [%83, %$25], [%93, %$27] ; # Sym
  %99 = phi i32 [%91, %$25], [%94, %$27] ; # C
  %100 = phi i32 [%85, %$25], [%95, %$27] ; # F
  %101 = phi i64 [%90, %$25], [%96, %$27] ; # N
  %102 = phi i1 [1, %$25], [%97, %$27] ; # ->
  br i1 %102, label %$29, label %$28
$28:
  %103 = phi i64 [%98, %$26] ; # Sym
  %104 = phi i32 [%99, %$26] ; # C
  %105 = phi i32 [%100, %$26] ; # F
  %106 = phi i64 [%101, %$26] ; # N
  br label %$21
$29:
  %107 = phi i64 [%98, %$26] ; # Sym
  %108 = phi i32 [%99, %$26] ; # C
  %109 = phi i32 [%100, %$26] ; # F
  %110 = phi i64 [%101, %$26] ; # N
  %111 = phi i64 [0, %$26] ; # ->
; # (if (isLife (setq Sym (extern (extNm F N)))) Sym $Nil)
; # (extNm F N)
  %112 = call i64 @extNm(i32 %109, i64 %110)
; # (extern (extNm F N))
  %113 = call i64 @extern(i64 %112)
; # (isLife (setq Sym (extern (extNm F N))))
  %114 = call i1 @isLife(i64 %113)
  br i1 %114, label %$30, label %$31
$30:
  %115 = phi i64 [%113, %$29] ; # Sym
  %116 = phi i32 [%108, %$29] ; # C
  %117 = phi i32 [%109, %$29] ; # F
  %118 = phi i64 [%110, %$29] ; # N
  br label %$32
$31:
  %119 = phi i64 [%113, %$29] ; # Sym
  %120 = phi i32 [%108, %$29] ; # C
  %121 = phi i32 [%109, %$29] ; # F
  %122 = phi i64 [%110, %$29] ; # N
  br label %$32
$32:
  %123 = phi i64 [%115, %$30], [%119, %$31] ; # Sym
  %124 = phi i32 [%116, %$30], [%120, %$31] ; # C
  %125 = phi i32 [%117, %$30], [%121, %$31] ; # F
  %126 = phi i64 [%118, %$30], [%122, %$31] ; # N
  %127 = phi i64 [%115, %$30], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$31] ; # ->
  ret i64 %127
}

define void @ignLog() align 8 {
$1:
; # (stderrMsg ($ "Discarding incomplete transaction^J") null)
  %0 = call i8* @stderrMsg(i8* bitcast ([35 x i8]* @$60 to i8*), i8* null)
  ret void
}

define i1 @transaction() align 8 {
$1:
; # (let (Log (val $DbLog) Blk (b8 BLK)) (fseek0 Log) (if (fread Blk ...
; # (val $DbLog)
  %0 = load i8*, i8** @$DbLog
; # (b8 BLK)
  %1 = alloca i8, i64 6
; # (fseek0 Log)
  %2 = call i1 @fseek0(i8* %0)
; # (if (fread Blk 2 1 Log) (loop (? (== (val (i16* Blk)) (hex "FFFF"...
; # (fread Blk 2 1 Log)
  %3 = call i32 @fread(i8* %1, i64 2, i64 1, i8* %0)
  %4 = icmp ne i32 %3, 0
  br i1 %4, label %$2, label %$3
$2:
; # (loop (? (== (val (i16* Blk)) (hex "FFFF")) YES) (? (or (=0 (dbfB...
  br label %$5
$5:
; # (? (== (val (i16* Blk)) (hex "FFFF")) YES)
; # (i16* Blk)
  %5 = bitcast i8* %1 to i16*
; # (val (i16* Blk))
  %6 = load i16, i16* %5
; # (== (val (i16* Blk)) (hex "FFFF"))
  %7 = icmp eq i16 %6, 65535
  br i1 %7, label %$8, label %$6
$8:
  br label %$7
$6:
; # (? (or (=0 (dbfBuf Blk)) (<> (fread Blk BLK 1 Log) 1) (not (fseek...
; # (or (=0 (dbfBuf Blk)) (<> (fread Blk BLK 1 Log) 1) (not (fseekOfs...
; # (dbfBuf Blk)
  %8 = call i8* @dbfBuf(i8* %1)
; # (=0 (dbfBuf Blk))
  %9 = icmp eq i8* %8, null
  br i1 %9, label %$9, label %$10
$10:
; # (fread Blk BLK 1 Log)
  %10 = call i32 @fread(i8* %1, i64 6, i64 1, i8* %0)
; # (<> (fread Blk BLK 1 Log) 1)
  %11 = icmp ne i32 %10, 1
  br i1 %11, label %$9, label %$11
$11:
; # (val $DbFile)
  %12 = load i8*, i8** @$DbFile
; # ((dbFile (val $DbFile)) siz)
  %13 = getelementptr i8, i8* %12, i32 12
  %14 = bitcast i8* %13 to i32*
  %15 = load i32, i32* %14
; # (fseekOfs Log ((dbFile (val $DbFile)) siz))
  %16 = call i1 @fseekOfs(i8* %0, i32 %15)
; # (not (fseekOfs Log ((dbFile (val $DbFile)) siz)))
  %17 = icmp eq i1 %16, 0
  br i1 %17, label %$9, label %$12
$12:
; # (fread Blk 2 1 Log)
  %18 = call i32 @fread(i8* %1, i64 2, i64 1, i8* %0)
; # (<> (fread Blk 2 1 Log) 1)
  %19 = icmp ne i32 %18, 1
  br label %$9
$9:
  %20 = phi i1 [1, %$6], [1, %$10], [1, %$11], [%19, %$12] ; # ->
  br i1 %20, label %$14, label %$13
$14:
; # (ignLog)
  call void @ignLog()
  br label %$7
$13:
  br label %$5
$7:
  %21 = phi i1 [1, %$8], [0, %$14] ; # ->
  br label %$4
$3:
; # (unless (feof Log) (ignLog))
; # (feof Log)
  %22 = call i32 @feof(i8* %0)
  %23 = icmp ne i32 %22, 0
  br i1 %23, label %$16, label %$15
$15:
; # (ignLog)
  call void @ignLog()
  br label %$16
$16:
  br label %$4
$4:
  %24 = phi i1 [%21, %$7], [0, %$16] ; # ->
  ret i1 %24
}

define void @fsyncDB(i64) align 8 {
$1:
; # (let (Db (val $DbFiles) C (val $DBs)) (loop (let Db: (dbFile Db) ...
; # (val $DbFiles)
  %1 = load i8*, i8** @$DbFiles
; # (val $DBs)
  %2 = load i32, i32* @$DBs
; # (loop (let Db: (dbFile Db) (when (and (Db: drt) (lt0 (fsync (Db: ...
  br label %$2
$2:
  %3 = phi i8* [%1, %$1], [%25, %$7] ; # Db
  %4 = phi i32 [%2, %$1], [%24, %$7] ; # C
; # (let Db: (dbFile Db) (when (and (Db: drt) (lt0 (fsync (Db: fd))))...
; # (when (and (Db: drt) (lt0 (fsync (Db: fd)))) (dbSyncErr Exe))
; # (and (Db: drt) (lt0 (fsync (Db: fd))))
; # (Db: drt)
  %5 = getelementptr i8, i8* %3, i32 41
  %6 = bitcast i8* %5 to i1*
  %7 = load i1, i1* %6
  br i1 %7, label %$4, label %$3
$4:
  %8 = phi i8* [%3, %$2] ; # Db
  %9 = phi i32 [%4, %$2] ; # C
; # (Db: fd)
  %10 = bitcast i8* %3 to i32*
  %11 = load i32, i32* %10
; # (fsync (Db: fd))
  %12 = call i32 @fsync(i32 %11)
; # (lt0 (fsync (Db: fd)))
  %13 = icmp slt i32 %12, 0
  br label %$3
$3:
  %14 = phi i8* [%3, %$2], [%8, %$4] ; # Db
  %15 = phi i32 [%4, %$2], [%9, %$4] ; # C
  %16 = phi i1 [0, %$2], [%13, %$4] ; # ->
  br i1 %16, label %$5, label %$6
$5:
  %17 = phi i8* [%14, %$3] ; # Db
  %18 = phi i32 [%15, %$3] ; # C
; # (dbSyncErr Exe)
  call void @dbSyncErr(i64 %0)
  unreachable
$6:
  %19 = phi i8* [%14, %$3] ; # Db
  %20 = phi i32 [%15, %$3] ; # C
; # (? (=0 (dec 'C)))
; # (dec 'C)
  %21 = sub i32 %20, 1
; # (=0 (dec 'C))
  %22 = icmp eq i32 %21, 0
  br i1 %22, label %$8, label %$7
$7:
  %23 = phi i8* [%19, %$6] ; # Db
  %24 = phi i32 [%21, %$6] ; # C
; # (ofs Db (dbFile T))
  %25 = getelementptr i8, i8* %23, i32 48
  br label %$2
$8:
  %26 = phi i8* [%19, %$6] ; # Db
  %27 = phi i32 [%21, %$6] ; # C
  %28 = phi i64 [0, %$6] ; # ->
  ret void
}

define void @restore(i64) align 8 {
$1:
; # (stderrMsg ($ "Last transaction not completed: Rollback^J") null)...
  %1 = call i8* @stderrMsg(i8* bitcast ([42 x i8]* @$61 to i8*), i8* null)
; # (let Log (val $DbLog) (fseek0 Log) (let (Db (val $DbFiles) C (val...
; # (val $DbLog)
  %2 = load i8*, i8** @$DbLog
; # (fseek0 Log)
  %3 = call i1 @fseek0(i8* %2)
; # (let (Db (val $DbFiles) C (val $DBs)) (loop ((dbFile Db) drt NO) ...
; # (val $DbFiles)
  %4 = load i8*, i8** @$DbFiles
; # (val $DBs)
  %5 = load i32, i32* @$DBs
; # (loop ((dbFile Db) drt NO) (? (=0 (dec 'C))) (setq Db (ofs Db (db...
  br label %$2
$2:
  %6 = phi i8* [%4, %$1], [%14, %$3] ; # Db
  %7 = phi i32 [%5, %$1], [%13, %$3] ; # C
; # ((dbFile Db) drt NO)
  %8 = getelementptr i8, i8* %6, i32 41
  %9 = bitcast i8* %8 to i1*
  store i1 0, i1* %9
; # (? (=0 (dec 'C)))
; # (dec 'C)
  %10 = sub i32 %7, 1
; # (=0 (dec 'C))
  %11 = icmp eq i32 %10, 0
  br i1 %11, label %$4, label %$3
$3:
  %12 = phi i8* [%6, %$2] ; # Db
  %13 = phi i32 [%10, %$2] ; # C
; # (ofs Db (dbFile T))
  %14 = getelementptr i8, i8* %12, i32 48
  br label %$2
$4:
  %15 = phi i8* [%6, %$2] ; # Db
  %16 = phi i32 [%10, %$2] ; # C
  %17 = phi i64 [0, %$2] ; # ->
; # (let (Blk (b8 BLK) Buf (b8 (val $MaxBlkSize))) (loop (unless (== ...
; # (b8 BLK)
  %18 = alloca i8, i64 6
; # (val $MaxBlkSize)
  %19 = load i32, i32* @$MaxBlkSize
; # (b8 (val $MaxBlkSize))
  %20 = alloca i8, i32 %19
; # (loop (unless (== (fread Blk 2 1 Log) 1) (jnlErr Exe)) (? (== (va...
  br label %$5
$5:
; # (unless (== (fread Blk 2 1 Log) 1) (jnlErr Exe))
; # (fread Blk 2 1 Log)
  %21 = call i32 @fread(i8* %18, i64 2, i64 1, i8* %2)
; # (== (fread Blk 2 1 Log) 1)
  %22 = icmp eq i32 %21, 1
  br i1 %22, label %$7, label %$6
$6:
; # (jnlErr Exe)
  call void @jnlErr(i64 %0)
  unreachable
$7:
; # (? (== (val (i16* Blk)) (hex "FFFF")))
; # (i16* Blk)
  %23 = bitcast i8* %18 to i16*
; # (val (i16* Blk))
  %24 = load i16, i16* %23
; # (== (val (i16* Blk)) (hex "FFFF"))
  %25 = icmp eq i16 %24, 65535
  br i1 %25, label %$9, label %$8
$8:
; # (if (dbfBuf Blk) (let Db: (dbFile @) (unless (and (== (fread Blk ...
; # (dbfBuf Blk)
  %26 = call i8* @dbfBuf(i8* %18)
  %27 = icmp ne i8* %26, null
  br i1 %27, label %$10, label %$11
$10:
; # (let Db: (dbFile @) (unless (and (== (fread Blk BLK 1 Log) 1) (==...
; # (unless (and (== (fread Blk BLK 1 Log) 1) (== (fread Buf (i64 (Db...
; # (and (== (fread Blk BLK 1 Log) 1) (== (fread Buf (i64 (Db: siz)) ...
; # (fread Blk BLK 1 Log)
  %28 = call i32 @fread(i8* %18, i64 6, i64 1, i8* %2)
; # (== (fread Blk BLK 1 Log) 1)
  %29 = icmp eq i32 %28, 1
  br i1 %29, label %$14, label %$13
$14:
; # (Db: siz)
  %30 = getelementptr i8, i8* %26, i32 12
  %31 = bitcast i8* %30 to i32*
  %32 = load i32, i32* %31
; # (i64 (Db: siz))
  %33 = sext i32 %32 to i64
; # (fread Buf (i64 (Db: siz)) 1 Log)
  %34 = call i32 @fread(i8* %20, i64 %33, i64 1, i8* %2)
; # (== (fread Buf (i64 (Db: siz)) 1 Log) 1)
  %35 = icmp eq i32 %34, 1
  br label %$13
$13:
  %36 = phi i1 [0, %$10], [%35, %$14] ; # ->
  br i1 %36, label %$16, label %$15
$15:
; # (jnlErr Exe)
  call void @jnlErr(i64 %0)
  unreachable
$16:
; # (unless (== (pwrite (Db: fd) Buf (i64 (Db: siz)) (shl (getAdr Blk...
; # (Db: fd)
  %37 = bitcast i8* %26 to i32*
  %38 = load i32, i32* %37
; # (Db: siz)
  %39 = getelementptr i8, i8* %26, i32 12
  %40 = bitcast i8* %39 to i32*
  %41 = load i32, i32* %40
; # (i64 (Db: siz))
  %42 = sext i32 %41 to i64
; # (getAdr Blk)
  %43 = call i64 @getAdr(i8* %18)
; # (Db: sh)
  %44 = getelementptr i8, i8* %26, i32 8
  %45 = bitcast i8* %44 to i32*
  %46 = load i32, i32* %45
; # (i64 (Db: sh))
  %47 = sext i32 %46 to i64
; # (shl (getAdr Blk) (i64 (Db: sh)))
  %48 = shl i64 %43, %47
; # (pwrite (Db: fd) Buf (i64 (Db: siz)) (shl (getAdr Blk) (i64 (Db: ...
  %49 = call i64 @pwrite(i32 %38, i8* %20, i64 %42, i64 %48)
; # (Db: siz)
  %50 = getelementptr i8, i8* %26, i32 12
  %51 = bitcast i8* %50 to i32*
  %52 = load i32, i32* %51
; # (i64 (Db: siz))
  %53 = sext i32 %52 to i64
; # (== (pwrite (Db: fd) Buf (i64 (Db: siz)) (shl (getAdr Blk) (i64 (...
  %54 = icmp eq i64 %49, %53
  br i1 %54, label %$18, label %$17
$17:
; # (dbWrErr)
  call void @dbWrErr()
  unreachable
$18:
; # (Db: drt YES)
  %55 = getelementptr i8, i8* %26, i32 41
  %56 = bitcast i8* %55 to i1*
  store i1 1, i1* %56
  br label %$12
$11:
; # (jnlErr Exe)
  call void @jnlErr(i64 %0)
  unreachable
$12:
  %57 = phi i1 [1, %$18] ; # ->
  br label %$5
$9:
  %58 = phi i64 [0, %$7] ; # ->
; # (fsyncDB Exe)
  call void @fsyncDB(i64 %0)
  ret void
}

define void @truncLog(i64) align 8 {
$1:
; # (let Log (val $DbLog) (unless (and (fseek0 Log) (truncate0 (filen...
; # (val $DbLog)
  %1 = load i8*, i8** @$DbLog
; # (unless (and (fseek0 Log) (truncate0 (fileno Log))) (err Exe 0 ($...
; # (and (fseek0 Log) (truncate0 (fileno Log)))
; # (fseek0 Log)
  %2 = call i1 @fseek0(i8* %1)
  br i1 %2, label %$3, label %$2
$3:
; # (fileno Log)
  %3 = call i32 @fileno(i8* %1)
; # (truncate0 (fileno Log))
  %4 = call i1 @truncate0(i32 %3)
  br label %$2
$2:
  %5 = phi i1 [0, %$1], [%4, %$3] ; # ->
  br i1 %5, label %$5, label %$4
$4:
; # (strErrno)
  %6 = call i8* @strErrno()
; # (err Exe 0 ($ "Log truncate error: %s") (strErrno))
  call void @err(i64 %0, i64 0, i8* bitcast ([23 x i8]* @$62 to i8*), i8* %6)
  unreachable
$5:
  ret void
}

define i64 @_Pool(i64) align 8 {
$1:
; # (let (X (cdr Exe) Sym1 (save (evSym X)) Dbs (save (evLst (shift X...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (evSym X)
  %4 = call i64 @evSym(i64 %3)
; # (save (evSym X))
  %5 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %6 = load i64, i64* %5
  %7 = alloca i64, i64 2, align 16
  %8 = ptrtoint i64* %7 to i64
  %9 = inttoptr i64 %8 to i64*
  store i64 %4, i64* %9
  %10 = add i64 %8, 8
  %11 = inttoptr i64 %10 to i64*
  store i64 %6, i64* %11
  %12 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %8, i64* %12
; # (shift X)
  %13 = inttoptr i64 %3 to i64*
  %14 = getelementptr i64, i64* %13, i32 1
  %15 = load i64, i64* %14
; # (evLst (shift X))
  %16 = call i64 @evLst(i64 %15)
; # (save (evLst (shift X)))
  %17 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %18 = load i64, i64* %17
  %19 = alloca i64, i64 2, align 16
  %20 = ptrtoint i64* %19 to i64
  %21 = inttoptr i64 %20 to i64*
  store i64 %16, i64* %21
  %22 = add i64 %20, 8
  %23 = inttoptr i64 %22 to i64*
  store i64 %18, i64* %23
  %24 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %20, i64* %24
; # (shift X)
  %25 = inttoptr i64 %15 to i64*
  %26 = getelementptr i64, i64* %25, i32 1
  %27 = load i64, i64* %26
; # (evSym (shift X))
  %28 = call i64 @evSym(i64 %27)
; # (save (evSym (shift X)))
  %29 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %30 = load i64, i64* %29
  %31 = alloca i64, i64 2, align 16
  %32 = ptrtoint i64* %31 to i64
  %33 = inttoptr i64 %32 to i64*
  store i64 %28, i64* %33
  %34 = add i64 %32, 8
  %35 = inttoptr i64 %34 to i64*
  store i64 %30, i64* %35
  %36 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %32, i64* %36
; # (shift X)
  %37 = inttoptr i64 %27 to i64*
  %38 = getelementptr i64, i64* %37, i32 1
  %39 = load i64, i64* %38
; # (evSym (shift X))
  %40 = call i64 @evSym(i64 %39)
; # (save (evSym (shift X)))
  %41 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %42 = load i64, i64* %41
  %43 = alloca i64, i64 2, align 16
  %44 = ptrtoint i64* %43 to i64
  %45 = inttoptr i64 %44 to i64*
  store i64 %40, i64* %45
  %46 = add i64 %44, 8
  %47 = inttoptr i64 %46 to i64*
  store i64 %42, i64* %47
  %48 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %44, i64* %48
; # (set $Solo ZERO)
  %49 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 424) to i64) to i64*
  store i64 2, i64* %49
; # (when (val $DBs) (_Rollback ZERO) (let (Db (val $DbFiles) C @) (l...
; # (val $DBs)
  %50 = load i32, i32* @$DBs
  %51 = icmp ne i32 %50, 0
  br i1 %51, label %$2, label %$3
$2:
  %52 = phi i64 [%16, %$1] ; # Dbs
; # (_Rollback ZERO)
  %53 = call i64 @_Rollback(i64 2)
; # (let (Db (val $DbFiles) C @) (loop (let Db: (dbFile Db) (close (D...
; # (val $DbFiles)
  %54 = load i8*, i8** @$DbFiles
; # (loop (let Db: (dbFile Db) (close (Db: fd)) (free (Db: mark))) (?...
  br label %$4
$4:
  %55 = phi i64 [%52, %$2], [%66, %$5] ; # Dbs
  %56 = phi i8* [%54, %$2], [%69, %$5] ; # Db
  %57 = phi i32 [%50, %$2], [%68, %$5] ; # C
; # (let Db: (dbFile Db) (close (Db: fd)) (free (Db: mark)))
; # (Db: fd)
  %58 = bitcast i8* %56 to i32*
  %59 = load i32, i32* %58
; # (close (Db: fd))
  %60 = call i32 @close(i32 %59)
; # (Db: mark)
  %61 = getelementptr i8, i8* %56, i32 16
  %62 = bitcast i8* %61 to i8**
  %63 = load i8*, i8** %62
; # (free (Db: mark))
  call void @free(i8* %63)
; # (? (=0 (dec 'C)))
; # (dec 'C)
  %64 = sub i32 %57, 1
; # (=0 (dec 'C))
  %65 = icmp eq i32 %64, 0
  br i1 %65, label %$6, label %$5
$5:
  %66 = phi i64 [%55, %$4] ; # Dbs
  %67 = phi i8* [%56, %$4] ; # Db
  %68 = phi i32 [%64, %$4] ; # C
; # (ofs Db (dbFile T))
  %69 = getelementptr i8, i8* %67, i32 48
  br label %$4
$6:
  %70 = phi i64 [%55, %$4] ; # Dbs
  %71 = phi i8* [%56, %$4] ; # Db
  %72 = phi i32 [%64, %$4] ; # C
  %73 = phi i64 [0, %$4] ; # ->
; # (set $DBs 0 $DB $Nil)
  store i32 0, i32* @$DBs
  %74 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 232) to i64) to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %74
; # (when (val $DbJnl) (fclose @) (set $DbJnl null))
; # (val $DbJnl)
  %75 = load i8*, i8** @$DbJnl
  %76 = icmp ne i8* %75, null
  br i1 %76, label %$7, label %$8
$7:
  %77 = phi i64 [%70, %$6] ; # Dbs
; # (fclose @)
  %78 = call i32 @fclose(i8* %75)
; # (set $DbJnl null)
  store i8* null, i8** @$DbJnl
  br label %$8
$8:
  %79 = phi i64 [%70, %$6], [%77, %$7] ; # Dbs
; # (when (val $DbLog) (fclose @) (set $DbLog null))
; # (val $DbLog)
  %80 = load i8*, i8** @$DbLog
  %81 = icmp ne i8* %80, null
  br i1 %81, label %$9, label %$10
$9:
  %82 = phi i64 [%79, %$8] ; # Dbs
; # (fclose @)
  %83 = call i32 @fclose(i8* %80)
; # (set $DbLog null)
  store i8* null, i8** @$DbLog
  br label %$10
$10:
  %84 = phi i64 [%79, %$8], [%82, %$9] ; # Dbs
  br label %$3
$3:
  %85 = phi i64 [%16, %$1], [%84, %$10] ; # Dbs
; # (unless (nil? Sym1) (let (Nm (xName Sym1) Len (pathSize Nm) Buf (...
; # (nil? Sym1)
  %86 = icmp eq i64 %4, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %86, label %$12, label %$11
$11:
  %87 = phi i64 [%85, %$3] ; # Dbs
; # (let (Nm (xName Sym1) Len (pathSize Nm) Buf (pathString Nm (b8 (+...
; # (xName Sym1)
  %88 = call i64 @xName(i64 %4)
; # (pathSize Nm)
  %89 = call i64 @pathSize(i64 %88)
; # (+ Len 4)
  %90 = add i64 %89, 4
; # (b8 (+ Len 4))
  %91 = alloca i8, i64 %90
; # (pathString Nm (b8 (+ Len 4)))
  %92 = call i8* @pathString(i64 %88, i8* %91)
; # (dec Len)
  %93 = sub i64 %89, 1
; # (ofs Buf (dec Len))
  %94 = getelementptr i8, i8* %92, i64 %93
; # (when (pair Dbs) (let L Dbs (while (pair (shift L)) (inc 'Siz (db...
; # (pair Dbs)
  %95 = and i64 %87, 15
  %96 = icmp eq i64 %95, 0
  br i1 %96, label %$13, label %$14
$13:
  %97 = phi i64 [%87, %$11] ; # Dbs
  %98 = phi i64 [48, %$11] ; # Siz
; # (let L Dbs (while (pair (shift L)) (inc 'Siz (dbFile T))))
; # (while (pair (shift L)) (inc 'Siz (dbFile T)))
  br label %$15
$15:
  %99 = phi i64 [%97, %$13], [%107, %$16] ; # Dbs
  %100 = phi i64 [%98, %$13], [%110, %$16] ; # Siz
  %101 = phi i64 [%97, %$13], [%109, %$16] ; # L
; # (shift L)
  %102 = inttoptr i64 %101 to i64*
  %103 = getelementptr i64, i64* %102, i32 1
  %104 = load i64, i64* %103
; # (pair (shift L))
  %105 = and i64 %104, 15
  %106 = icmp eq i64 %105, 0
  br i1 %106, label %$16, label %$17
$16:
  %107 = phi i64 [%99, %$15] ; # Dbs
  %108 = phi i64 [%100, %$15] ; # Siz
  %109 = phi i64 [%104, %$15] ; # L
; # (inc 'Siz (dbFile T))
  %110 = add i64 %108, 48
  br label %$15
$17:
  %111 = phi i64 [%99, %$15] ; # Dbs
  %112 = phi i64 [%100, %$15] ; # Siz
  %113 = phi i64 [%104, %$15] ; # L
  br label %$14
$14:
  %114 = phi i64 [%87, %$11], [%111, %$17] ; # Dbs
  %115 = phi i64 [48, %$11], [%112, %$17] ; # Siz
; # (let (Db (set $DbFiles (alloc (val $DbFiles) Siz)) P (b8 (+ BLK B...
; # (set $DbFiles (alloc (val $DbFiles) Siz))
; # (val $DbFiles)
  %116 = load i8*, i8** @$DbFiles
; # (alloc (val $DbFiles) Siz)
  %117 = call i8* @alloc(i8* %116, i64 %115)
  store i8* %117, i8** @$DbFiles
; # (+ BLK BLK 1)
; # (b8 (+ BLK BLK 1))
  %118 = alloca i8, i64 13
; # (i32 0)
; # (i32 0)
; # (loop (let Db: (dbFile (set $DbFile Db)) (Db: db Fnr) (if (atom D...
  br label %$18
$18:
  %119 = phi i64 [%114, %$14], [%285, %$36] ; # Dbs
  %120 = phi i64 [%115, %$14], [%286, %$36] ; # Siz
  %121 = phi i8* [%117, %$14], [%290, %$36] ; # Db
  %122 = phi i32 [0, %$14], [%288, %$36] ; # Fnr
  %123 = phi i32 [0, %$14], [%289, %$36] ; # Max
; # (let Db: (dbFile (set $DbFile Db)) (Db: db Fnr) (if (atom Dbs) (D...
; # (set $DbFile Db)
  store i8* %121, i8** @$DbFile
; # (Db: db Fnr)
  %124 = getelementptr i8, i8* %121, i32 4
  %125 = bitcast i8* %124 to i32*
  store i32 %122, i32* %125
; # (if (atom Dbs) (Db: sh 2) (set (bufAo End Fnr) 0) (Db: sh (i32 (i...
; # (atom Dbs)
  %126 = and i64 %119, 15
  %127 = icmp ne i64 %126, 0
  br i1 %127, label %$19, label %$20
$19:
  %128 = phi i64 [%119, %$18] ; # Dbs
  %129 = phi i64 [%120, %$18] ; # Siz
  %130 = phi i8* [%121, %$18] ; # Db
  %131 = phi i32 [%122, %$18] ; # Fnr
  %132 = phi i32 [%123, %$18] ; # Max
; # (Db: sh 2)
  %133 = getelementptr i8, i8* %121, i32 8
  %134 = bitcast i8* %133 to i32*
  store i32 2, i32* %134
  br label %$21
$20:
  %135 = phi i64 [%119, %$18] ; # Dbs
  %136 = phi i64 [%120, %$18] ; # Siz
  %137 = phi i8* [%121, %$18] ; # Db
  %138 = phi i32 [%122, %$18] ; # Fnr
  %139 = phi i32 [%123, %$18] ; # Max
; # (set (bufAo End Fnr) 0)
; # (bufAo End Fnr)
  %140 = call i8* @bufAo(i8* %94, i32 %138)
  store i8 0, i8* %140
; # (Db: sh (i32 (int (++ Dbs))))
  %141 = getelementptr i8, i8* %121, i32 8
  %142 = bitcast i8* %141 to i32*
  %143 = inttoptr i64 %135 to i64*
  %144 = load i64, i64* %143
  %145 = getelementptr i64, i64* %143, i32 1
  %146 = load i64, i64* %145
  %147 = lshr i64 %144, 4
  %148 = trunc i64 %147 to i32
  store i32 %148, i32* %142
  br label %$21
$21:
  %149 = phi i64 [%128, %$19], [%146, %$20] ; # Dbs
  %150 = phi i64 [%129, %$19], [%136, %$20] ; # Siz
  %151 = phi i8* [%130, %$19], [%137, %$20] ; # Db
  %152 = phi i32 [%131, %$19], [%138, %$20] ; # Fnr
  %153 = phi i32 [%132, %$19], [%139, %$20] ; # Max
  %154 = phi i32 [2, %$19], [%148, %$20] ; # ->
; # (cond ((ge0 (Db: fd (openRdWr Buf))) (blkPeek 0 P (+ BLK BLK 1)) ...
; # (Db: fd (openRdWr Buf))
  %155 = bitcast i8* %121 to i32*
  %156 = call i32 @openRdWr(i8* %92)
  store i32 %156, i32* %155
; # (ge0 (Db: fd (openRdWr Buf)))
  %157 = icmp sge i32 %156, 0
  br i1 %157, label %$24, label %$23
$24:
  %158 = phi i64 [%149, %$21] ; # Dbs
  %159 = phi i64 [%150, %$21] ; # Siz
  %160 = phi i8* [%151, %$21] ; # Db
  %161 = phi i32 [%152, %$21] ; # Fnr
  %162 = phi i32 [%153, %$21] ; # Max
; # (+ BLK BLK 1)
; # (blkPeek 0 P (+ BLK BLK 1))
  call void @blkPeek(i64 0, i8* %118, i32 13)
; # (Db: siz (shl (i32 BLKSIZE) (Db: sh (i32 (val (+ BLK BLK 1) P))))...
  %163 = getelementptr i8, i8* %121, i32 12
  %164 = bitcast i8* %163 to i32*
  %165 = getelementptr i8, i8* %121, i32 8
  %166 = bitcast i8* %165 to i32*
  %167 = getelementptr i8, i8* %118, i32 12
  %168 = load i8, i8* %167
  %169 = zext i8 %168 to i32
  store i32 %169, i32* %166
  %170 = shl i32 64, %169
  store i32 %170, i32* %164
  br label %$22
$23:
  %171 = phi i64 [%149, %$21] ; # Dbs
  %172 = phi i64 [%150, %$21] ; # Siz
  %173 = phi i8* [%151, %$21] ; # Db
  %174 = phi i32 [%152, %$21] ; # Fnr
  %175 = phi i32 [%153, %$21] ; # Max
; # (and (== (gErrno) ENOENT) (ge0 (Db: fd (openRdWrExcl Buf))))
; # (gErrno)
  %176 = call i32 @gErrno()
; # (== (gErrno) ENOENT)
  %177 = icmp eq i32 %176, 1
  br i1 %177, label %$26, label %$25
$26:
  %178 = phi i64 [%171, %$23] ; # Dbs
  %179 = phi i64 [%172, %$23] ; # Siz
  %180 = phi i8* [%173, %$23] ; # Db
  %181 = phi i32 [%174, %$23] ; # Fnr
  %182 = phi i32 [%175, %$23] ; # Max
; # (Db: fd (openRdWrExcl Buf))
  %183 = bitcast i8* %121 to i32*
  %184 = call i32 @openRdWrExcl(i8* %92)
  store i32 %184, i32* %183
; # (ge0 (Db: fd (openRdWrExcl Buf)))
  %185 = icmp sge i32 %184, 0
  br label %$25
$25:
  %186 = phi i64 [%171, %$23], [%178, %$26] ; # Dbs
  %187 = phi i64 [%172, %$23], [%179, %$26] ; # Siz
  %188 = phi i8* [%173, %$23], [%180, %$26] ; # Db
  %189 = phi i32 [%174, %$23], [%181, %$26] ; # Fnr
  %190 = phi i32 [%175, %$23], [%182, %$26] ; # Max
  %191 = phi i1 [0, %$23], [%185, %$26] ; # ->
  br i1 %191, label %$28, label %$27
$28:
  %192 = phi i64 [%186, %$25] ; # Dbs
  %193 = phi i64 [%187, %$25] ; # Siz
  %194 = phi i8* [%188, %$25] ; # Db
  %195 = phi i32 [%189, %$25] ; # Fnr
  %196 = phi i32 [%190, %$25] ; # Max
; # (let (N (shl (i32 BLKSIZE) (Db: sh)) Stk (stack) Blk (b8 (Db: siz...
; # (i32 BLKSIZE)
; # (Db: sh)
  %197 = getelementptr i8, i8* %121, i32 8
  %198 = bitcast i8* %197 to i32*
  %199 = load i32, i32* %198
; # (shl (i32 BLKSIZE) (Db: sh))
  %200 = shl i32 64, %199
; # (stack)
  %201 = call i8* @llvm.stacksave()
; # (Db: siz N)
  %202 = getelementptr i8, i8* %121, i32 12
  %203 = bitcast i8* %202 to i32*
  store i32 %200, i32* %203
; # (b8 (Db: siz N))
  %204 = alloca i8, i32 %200
; # (i64 N)
  %205 = sext i32 %200 to i64
; # (memset Blk 0 (i64 N) T)
  call void @llvm.memset.p0i8.i64(i8* align 8 %204, i8 0, i64 %205, i1 0)
; # (if (== (Db:) (val $DbFiles)) (* 2 BLKSIZE) BLKSIZE)
; # (Db:)
; # (val $DbFiles)
  %206 = load i8*, i8** @$DbFiles
; # (== (Db:) (val $DbFiles))
  %207 = icmp eq i8* %121, %206
  br i1 %207, label %$29, label %$30
$29:
  %208 = phi i64 [%192, %$28] ; # Dbs
  %209 = phi i64 [%193, %$28] ; # Siz
  %210 = phi i8* [%194, %$28] ; # Db
  %211 = phi i32 [%195, %$28] ; # Fnr
  %212 = phi i32 [%196, %$28] ; # Max
; # (* 2 BLKSIZE)
  br label %$31
$30:
  %213 = phi i64 [%192, %$28] ; # Dbs
  %214 = phi i64 [%193, %$28] ; # Siz
  %215 = phi i8* [%194, %$28] ; # Db
  %216 = phi i32 [%195, %$28] ; # Fnr
  %217 = phi i32 [%196, %$28] ; # Max
  br label %$31
$31:
  %218 = phi i64 [%208, %$29], [%213, %$30] ; # Dbs
  %219 = phi i64 [%209, %$29], [%214, %$30] ; # Siz
  %220 = phi i8* [%210, %$29], [%215, %$30] ; # Db
  %221 = phi i32 [%211, %$29], [%216, %$30] ; # Fnr
  %222 = phi i32 [%212, %$29], [%217, %$30] ; # Max
  %223 = phi i64 [128, %$29], [64, %$30] ; # ->
; # (ofs Blk BLK)
  %224 = getelementptr i8, i8* %204, i32 6
; # (setAdr (if (== (Db:) (val $DbFiles)) (* 2 BLKSIZE) BLKSIZE) (ofs...
  call void @setAdr(i64 %223, i8* %224)
; # (set (inc (* 2 BLK)) Blk (i8 (Db: sh)))
; # (* 2 BLK)
; # (inc (* 2 BLK))
; # (Db: sh)
  %225 = getelementptr i8, i8* %121, i32 8
  %226 = bitcast i8* %225 to i32*
  %227 = load i32, i32* %226
; # (i8 (Db: sh))
  %228 = trunc i32 %227 to i8
  %229 = getelementptr i8, i8* %204, i32 12
  store i8 %228, i8* %229
; # (blkPoke 0 Blk N)
  call void @blkPoke(i64 0, i8* %204, i32 %200)
; # (when (== (Db:) (val $DbFiles)) (memset Blk 0 16 T) (setAdr 1 Blk...
; # (Db:)
; # (val $DbFiles)
  %230 = load i8*, i8** @$DbFiles
; # (== (Db:) (val $DbFiles))
  %231 = icmp eq i8* %121, %230
  br i1 %231, label %$32, label %$33
$32:
  %232 = phi i64 [%218, %$31] ; # Dbs
  %233 = phi i64 [%219, %$31] ; # Siz
  %234 = phi i8* [%220, %$31] ; # Db
  %235 = phi i32 [%221, %$31] ; # Fnr
  %236 = phi i32 [%222, %$31] ; # Max
; # (memset Blk 0 16 T)
  call void @llvm.memset.p0i8.i64(i8* align 8 %204, i8 0, i64 16, i1 0)
; # (setAdr 1 Blk)
  call void @setAdr(i64 1, i8* %204)
; # (Db: siz)
  %237 = getelementptr i8, i8* %121, i32 12
  %238 = bitcast i8* %237 to i32*
  %239 = load i32, i32* %238
; # (i64 (Db: siz))
  %240 = sext i32 %239 to i64
; # (blkPoke (i64 (Db: siz)) Blk N)
  call void @blkPoke(i64 %240, i8* %204, i32 %200)
  br label %$33
$33:
  %241 = phi i64 [%218, %$31], [%232, %$32] ; # Dbs
  %242 = phi i64 [%219, %$31], [%233, %$32] ; # Siz
  %243 = phi i8* [%220, %$31], [%234, %$32] ; # Db
  %244 = phi i32 [%221, %$31], [%235, %$32] ; # Fnr
  %245 = phi i32 [%222, %$31], [%236, %$32] ; # Max
; # (stack Stk)
  call void @llvm.stackrestore(i8* %201)
  br label %$22
$27:
  %246 = phi i64 [%186, %$25] ; # Dbs
  %247 = phi i64 [%187, %$25] ; # Siz
  %248 = phi i8* [%188, %$25] ; # Db
  %249 = phi i32 [%189, %$25] ; # Fnr
  %250 = phi i32 [%190, %$25] ; # Max
; # (openErr Exe Sym1)
  call void @openErr(i64 %0, i64 %4)
  unreachable
$22:
  %251 = phi i64 [%158, %$24], [%241, %$33] ; # Dbs
  %252 = phi i64 [%159, %$24], [%242, %$33] ; # Siz
  %253 = phi i8* [%160, %$24], [%243, %$33] ; # Db
  %254 = phi i32 [%161, %$24], [%244, %$33] ; # Fnr
  %255 = phi i32 [%162, %$24], [%245, %$33] ; # Max
; # (Db: fd)
  %256 = bitcast i8* %121 to i32*
  %257 = load i32, i32* %256
; # (closeOnExec Exe (Db: fd))
  call void @closeOnExec(i64 %0, i32 %257)
; # (when (> (Db: siz) Max) (setq Max @))
; # (Db: siz)
  %258 = getelementptr i8, i8* %121, i32 12
  %259 = bitcast i8* %258 to i32*
  %260 = load i32, i32* %259
; # (> (Db: siz) Max)
  %261 = icmp sgt i32 %260, %255
  br i1 %261, label %$34, label %$35
$34:
  %262 = phi i64 [%251, %$22] ; # Dbs
  %263 = phi i64 [%252, %$22] ; # Siz
  %264 = phi i8* [%253, %$22] ; # Db
  %265 = phi i32 [%254, %$22] ; # Fnr
  %266 = phi i32 [%255, %$22] ; # Max
  br label %$35
$35:
  %267 = phi i64 [%251, %$22], [%262, %$34] ; # Dbs
  %268 = phi i64 [%252, %$22], [%263, %$34] ; # Siz
  %269 = phi i8* [%253, %$22], [%264, %$34] ; # Db
  %270 = phi i32 [%254, %$22], [%265, %$34] ; # Fnr
  %271 = phi i32 [%255, %$22], [%260, %$34] ; # Max
; # (Db: mark null)
  %272 = getelementptr i8, i8* %121, i32 16
  %273 = bitcast i8* %272 to i8**
  store i8* null, i8** %273
; # (Db: mrks 0)
  %274 = getelementptr i8, i8* %121, i32 24
  %275 = bitcast i8* %274 to i64*
  store i64 0, i64* %275
; # (Db: flu -1)
  %276 = getelementptr i8, i8* %121, i32 32
  %277 = bitcast i8* %276 to i64*
  store i64 -1, i64* %277
; # (Db: lck (Db: drt NO))
  %278 = getelementptr i8, i8* %121, i32 40
  %279 = bitcast i8* %278 to i1*
  %280 = getelementptr i8, i8* %121, i32 41
  %281 = bitcast i8* %280 to i1*
  store i1 0, i1* %281
  store i1 0, i1* %279
; # (inc 'Fnr)
  %282 = add i32 %270, 1
; # (? (atom Dbs))
; # (atom Dbs)
  %283 = and i64 %267, 15
  %284 = icmp ne i64 %283, 0
  br i1 %284, label %$37, label %$36
$36:
  %285 = phi i64 [%267, %$35] ; # Dbs
  %286 = phi i64 [%268, %$35] ; # Siz
  %287 = phi i8* [%269, %$35] ; # Db
  %288 = phi i32 [%282, %$35] ; # Fnr
  %289 = phi i32 [%271, %$35] ; # Max
; # (ofs Db (dbFile T))
  %290 = getelementptr i8, i8* %287, i32 48
  br label %$18
$37:
  %291 = phi i64 [%267, %$35] ; # Dbs
  %292 = phi i64 [%268, %$35] ; # Siz
  %293 = phi i8* [%269, %$35] ; # Db
  %294 = phi i32 [%282, %$35] ; # Fnr
  %295 = phi i32 [%271, %$35] ; # Max
  %296 = phi i64 [0, %$35] ; # ->
; # (set $DB $Db1 $DBs Fnr $MaxBlkSize Max $DbBlock (alloc (val $DbBl...
  %297 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 232) to i64) to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 408) to i64), i64* %297
  store i32 %294, i32* @$DBs
  store i32 %295, i32* @$MaxBlkSize
; # (val $DbBlock)
  %298 = load i8*, i8** @$DbBlock
; # (i64 Max)
  %299 = sext i32 %295 to i64
; # (alloc (val $DbBlock) (i64 Max))
  %300 = call i8* @alloc(i8* %298, i64 %299)
  store i8* %300, i8** @$DbBlock
; # (unless (nil? Sym2) (let Nm (xName Sym2) (unless (fopen (pathStri...
; # (nil? Sym2)
  %301 = icmp eq i64 %28, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %301, label %$39, label %$38
$38:
  %302 = phi i64 [%291, %$37] ; # Dbs
; # (let Nm (xName Sym2) (unless (fopen (pathString Nm (b8 (pathSize ...
; # (xName Sym2)
  %303 = call i64 @xName(i64 %28)
; # (unless (fopen (pathString Nm (b8 (pathSize Nm))) ($ "a")) (openE...
; # (pathSize Nm)
  %304 = call i64 @pathSize(i64 %303)
; # (b8 (pathSize Nm))
  %305 = alloca i8, i64 %304
; # (pathString Nm (b8 (pathSize Nm)))
  %306 = call i8* @pathString(i64 %303, i8* %305)
; # (fopen (pathString Nm (b8 (pathSize Nm))) ($ "a"))
  %307 = call i8* @fopen(i8* %306, i8* bitcast ([2 x i8]* @$63 to i8*))
  %308 = icmp ne i8* %307, null
  br i1 %308, label %$41, label %$40
$40:
  %309 = phi i64 [%302, %$38] ; # Dbs
; # (openErr Exe Sym2)
  call void @openErr(i64 %0, i64 %28)
  unreachable
$41:
  %310 = phi i64 [%302, %$38] ; # Dbs
; # (set $DbJnl @)
  store i8* %307, i8** @$DbJnl
; # (fileno @)
  %311 = call i32 @fileno(i8* %307)
; # (closeOnExec Exe (fileno @))
  call void @closeOnExec(i64 %0, i32 %311)
  br label %$39
$39:
  %312 = phi i64 [%291, %$37], [%310, %$41] ; # Dbs
; # (unless (nil? Sym3) (let Nm (xName Sym3) (unless (fopen (pathStri...
; # (nil? Sym3)
  %313 = icmp eq i64 %40, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %313, label %$43, label %$42
$42:
  %314 = phi i64 [%312, %$39] ; # Dbs
; # (let Nm (xName Sym3) (unless (fopen (pathString Nm (b8 (pathSize ...
; # (xName Sym3)
  %315 = call i64 @xName(i64 %40)
; # (unless (fopen (pathString Nm (b8 (pathSize Nm))) ($ "a+")) (open...
; # (pathSize Nm)
  %316 = call i64 @pathSize(i64 %315)
; # (b8 (pathSize Nm))
  %317 = alloca i8, i64 %316
; # (pathString Nm (b8 (pathSize Nm)))
  %318 = call i8* @pathString(i64 %315, i8* %317)
; # (fopen (pathString Nm (b8 (pathSize Nm))) ($ "a+"))
  %319 = call i8* @fopen(i8* %318, i8* bitcast ([3 x i8]* @$64 to i8*))
  %320 = icmp ne i8* %319, null
  br i1 %320, label %$45, label %$44
$44:
  %321 = phi i64 [%314, %$42] ; # Dbs
; # (openErr Exe Sym3)
  call void @openErr(i64 %0, i64 %40)
  unreachable
$45:
  %322 = phi i64 [%314, %$42] ; # Dbs
; # (set $DbLog @)
  store i8* %319, i8** @$DbLog
; # (fileno @)
  %323 = call i32 @fileno(i8* %319)
; # (closeOnExec Exe (fileno @))
  call void @closeOnExec(i64 %0, i32 %323)
; # (when (transaction) (restore Exe))
; # (transaction)
  %324 = call i1 @transaction()
  br i1 %324, label %$46, label %$47
$46:
  %325 = phi i64 [%322, %$45] ; # Dbs
; # (restore Exe)
  call void @restore(i64 %0)
  br label %$47
$47:
  %326 = phi i64 [%322, %$45], [%325, %$46] ; # Dbs
; # (truncLog Exe)
  call void @truncLog(i64 %0)
  br label %$43
$43:
  %327 = phi i64 [%312, %$39], [%326, %$47] ; # Dbs
  br label %$12
$12:
  %328 = phi i64 [%85, %$3], [%327, %$43] ; # Dbs
; # (drop *Safe)
  %329 = inttoptr i64 %8 to i64*
  %330 = getelementptr i64, i64* %329, i32 1
  %331 = load i64, i64* %330
  %332 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %331, i64* %332
  ret i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
}

define i64 @_Pool2(i64) align 8 {
$1:
; # (let (X (cdr Exe) Sym (evSym X) Nm (xName Sym) Jnl (val $DbJnl) L...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (evSym X)
  %4 = call i64 @evSym(i64 %3)
; # (xName Sym)
  %5 = call i64 @xName(i64 %4)
; # (val $DbJnl)
  %6 = load i8*, i8** @$DbJnl
; # (val $DbLog)
  %7 = load i8*, i8** @$DbLog
; # (val $DBs)
  %8 = load i32, i32* @$DBs
; # (b32 C)
  %9 = alloca i32, i32 %8
; # (set $DbJnl null $DbLog null)
  store i8* null, i8** @$DbJnl
  store i8* null, i8** @$DbLog
; # (let (Db (val $DbFiles) I (i32 0)) (loop (let Db: (dbFile Db) (se...
; # (val $DbFiles)
  %10 = load i8*, i8** @$DbFiles
; # (i32 0)
; # (loop (let Db: (dbFile Db) (set (ofs FDs I) (Db: fd))) (? (== C (...
  br label %$2
$2:
  %11 = phi i8* [%10, %$1], [%20, %$3] ; # Db
  %12 = phi i32 [0, %$1], [%19, %$3] ; # I
; # (let Db: (dbFile Db) (set (ofs FDs I) (Db: fd)))
; # (set (ofs FDs I) (Db: fd))
; # (ofs FDs I)
  %13 = getelementptr i32, i32* %9, i32 %12
; # (Db: fd)
  %14 = bitcast i8* %11 to i32*
  %15 = load i32, i32* %14
  store i32 %15, i32* %13
; # (? (== C (inc 'I)))
; # (inc 'I)
  %16 = add i32 %12, 1
; # (== C (inc 'I))
  %17 = icmp eq i32 %8, %16
  br i1 %17, label %$4, label %$3
$3:
  %18 = phi i8* [%11, %$2] ; # Db
  %19 = phi i32 [%16, %$2] ; # I
; # (ofs Db (dbFile T))
  %20 = getelementptr i8, i8* %18, i32 48
  br label %$2
$4:
  %21 = phi i8* [%11, %$2] ; # Db
  %22 = phi i32 [%16, %$2] ; # I
  %23 = phi i64 [0, %$2] ; # ->
; # (let (Len (pathSize Nm) Buf (pathString Nm (b8 (+ Len 4))) End (o...
; # (pathSize Nm)
  %24 = call i64 @pathSize(i64 %5)
; # (+ Len 4)
  %25 = add i64 %24, 4
; # (b8 (+ Len 4))
  %26 = alloca i8, i64 %25
; # (pathString Nm (b8 (+ Len 4)))
  %27 = call i8* @pathString(i64 %5, i8* %26)
; # (dec Len)
  %28 = sub i64 %24, 1
; # (ofs Buf (dec Len))
  %29 = getelementptr i8, i8* %27, i64 %28
; # (let (Db (val $DbFiles) I (i32 0)) (loop (let Db: (dbFile Db) (se...
; # (val $DbFiles)
  %30 = load i8*, i8** @$DbFiles
; # (i32 0)
; # (loop (let Db: (dbFile Db) (set (bufAo End (Db: db)) 0) (when (lt...
  br label %$5
$5:
  %31 = phi i8* [%30, %$4], [%48, %$8] ; # Db
  %32 = phi i32 [0, %$4], [%47, %$8] ; # I
; # (let Db: (dbFile Db) (set (bufAo End (Db: db)) 0) (when (lt0 (Db:...
; # (set (bufAo End (Db: db)) 0)
; # (Db: db)
  %33 = getelementptr i8, i8* %31, i32 4
  %34 = bitcast i8* %33 to i32*
  %35 = load i32, i32* %34
; # (bufAo End (Db: db))
  %36 = call i8* @bufAo(i8* %29, i32 %35)
  store i8 0, i8* %36
; # (when (lt0 (Db: fd (openRdWr Buf))) (openErr Exe Sym))
; # (Db: fd (openRdWr Buf))
  %37 = bitcast i8* %31 to i32*
  %38 = call i32 @openRdWr(i8* %27)
  store i32 %38, i32* %37
; # (lt0 (Db: fd (openRdWr Buf)))
  %39 = icmp slt i32 %38, 0
  br i1 %39, label %$6, label %$7
$6:
  %40 = phi i8* [%31, %$5] ; # Db
  %41 = phi i32 [%32, %$5] ; # I
; # (openErr Exe Sym)
  call void @openErr(i64 %0, i64 %4)
  unreachable
$7:
  %42 = phi i8* [%31, %$5] ; # Db
  %43 = phi i32 [%32, %$5] ; # I
; # (closeOnExec Exe @)
  call void @closeOnExec(i64 %0, i32 %38)
; # (? (== C (inc 'I)))
; # (inc 'I)
  %44 = add i32 %43, 1
; # (== C (inc 'I))
  %45 = icmp eq i32 %8, %44
  br i1 %45, label %$9, label %$8
$8:
  %46 = phi i8* [%42, %$7] ; # Db
  %47 = phi i32 [%44, %$7] ; # I
; # (ofs Db (dbFile T))
  %48 = getelementptr i8, i8* %46, i32 48
  br label %$5
$9:
  %49 = phi i8* [%42, %$7] ; # Db
  %50 = phi i32 [%44, %$7] ; # I
  %51 = phi i64 [0, %$7] ; # ->
; # (prog1 (run (cdr X) (let (Db (val $DbFiles) I (i32 0)) (loop (let...
; # (cdr X)
  %52 = inttoptr i64 %3 to i64*
  %53 = getelementptr i64, i64* %52, i32 1
  %54 = load i64, i64* %53
; # (run (cdr X) (let (Db (val $DbFiles) I (i32 0)) (loop (let Db: (d...
  br label %$10
$10:
  %55 = phi i64 [%54, %$9], [%77, %$19] ; # Prg
  %56 = inttoptr i64 %55 to i64*
  %57 = load i64, i64* %56
  %58 = getelementptr i64, i64* %56, i32 1
  %59 = load i64, i64* %58
  %60 = and i64 %59, 15
  %61 = icmp ne i64 %60, 0
  br i1 %61, label %$13, label %$11
$13:
  %62 = phi i64 [%59, %$10] ; # Prg
  %63 = and i64 %57, 6
  %64 = icmp ne i64 %63, 0
  br i1 %64, label %$16, label %$15
$16:
  br label %$14
$15:
  %65 = and i64 %57, 8
  %66 = icmp ne i64 %65, 0
  br i1 %66, label %$18, label %$17
$18:
  %67 = inttoptr i64 %57 to i64*
  %68 = load i64, i64* %67
  br label %$14
$17:
  %69 = call i64 @evList(i64 %57)
  br label %$14
$14:
  %70 = phi i64 [%57, %$16], [%68, %$18], [%69, %$17] ; # ->
  br label %$12
$11:
  %71 = phi i64 [%59, %$10] ; # Prg
  %72 = and i64 %57, 15
  %73 = icmp eq i64 %72, 0
  br i1 %73, label %$20, label %$19
$20:
  %74 = phi i64 [%71, %$11] ; # Prg
  %75 = call i64 @evList(i64 %57)
  %76 = icmp ne i64 %75, 0
  br label %$19
$19:
  %77 = phi i64 [%71, %$11], [%74, %$20] ; # Prg
  %78 = phi i1 [0, %$11], [%76, %$20] ; # ->
  br label %$10
$12:
  %79 = phi i64 [%62, %$14] ; # Prg
  %80 = phi i64 [%70, %$14] ; # ->
  ret i64 %80
}

define i64 @_Journal(i64) align 8 {
$1:
; # (let (X (cdr Exe) Sym (evSym X) Jnl (val $DbJnl) Log (val $DbLog)...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (evSym X)
  %4 = call i64 @evSym(i64 %3)
; # (val $DbJnl)
  %5 = load i8*, i8** @$DbJnl
; # (val $DbLog)
  %6 = load i8*, i8** @$DbLog
; # (val $MaxBlkSize)
  %7 = load i32, i32* @$MaxBlkSize
; # (b8 (val $MaxBlkSize))
  %8 = alloca i8, i32 %7
; # (b8 BLK)
  %9 = alloca i8, i64 6
; # (stkChk Exe)
  %10 = load i8*, i8** @$StkLimit
  %11 = call i8* @llvm.stacksave()
  %12 = icmp ugt i8* %10, %11
  br i1 %12, label %$2, label %$3
$2:
  call void @stkErr(i64 %0)
  unreachable
$3:
; # (when (t? Sym) (set $DbJnl null $DbLog null) (setq Sym (evSym (sh...
; # (t? Sym)
  %13 = icmp eq i64 %4, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %13, label %$4, label %$5
$4:
  %14 = phi i64 [%3, %$3] ; # X
  %15 = phi i64 [%4, %$3] ; # Sym
; # (set $DbJnl null $DbLog null)
  store i8* null, i8** @$DbJnl
  store i8* null, i8** @$DbLog
; # (shift X)
  %16 = inttoptr i64 %14 to i64*
  %17 = getelementptr i64, i64* %16, i32 1
  %18 = load i64, i64* %17
; # (evSym (shift X))
  %19 = call i64 @evSym(i64 %18)
  br label %$5
$5:
  %20 = phi i64 [%3, %$3], [%18, %$4] ; # X
  %21 = phi i64 [%4, %$3], [%19, %$4] ; # Sym
; # (loop (let (Nm (xName Sym) Fp (fopen (pathString Nm (b8 (pathSize...
  br label %$6
$6:
  %22 = phi i64 [%20, %$5], [%111, %$25] ; # X
  %23 = phi i64 [%21, %$5], [%113, %$25] ; # Sym
; # (let (Nm (xName Sym) Fp (fopen (pathString Nm (b8 (pathSize Nm)))...
; # (xName Sym)
  %24 = call i64 @xName(i64 %23)
; # (pathSize Nm)
  %25 = call i64 @pathSize(i64 %24)
; # (b8 (pathSize Nm))
  %26 = alloca i8, i64 %25
; # (pathString Nm (b8 (pathSize Nm)))
  %27 = call i8* @pathString(i64 %24, i8* %26)
; # (fopen (pathString Nm (b8 (pathSize Nm))) ($ "r"))
  %28 = call i8* @fopen(i8* %27, i8* bitcast ([2 x i8]* @$65 to i8*))
; # (unless Fp (openErr Exe Sym))
  %29 = icmp ne i8* %28, null
  br i1 %29, label %$8, label %$7
$7:
  %30 = phi i64 [%22, %$6] ; # X
  %31 = phi i64 [%23, %$6] ; # Sym
; # (openErr Exe Sym)
  call void @openErr(i64 %0, i64 %31)
  unreachable
$8:
  %32 = phi i64 [%22, %$6] ; # X
  %33 = phi i64 [%23, %$6] ; # Sym
; # (while (ge0 (getc_unlocked Fp)) (let Siz @ (unless (== (fread Blk...
  br label %$9
$9:
  %34 = phi i64 [%32, %$8], [%100, %$16] ; # X
  %35 = phi i64 [%33, %$8], [%101, %$16] ; # Sym
; # (getc_unlocked Fp)
  %36 = call i32 @getc_unlocked(i8* %28)
; # (ge0 (getc_unlocked Fp))
  %37 = icmp sge i32 %36, 0
  br i1 %37, label %$10, label %$11
$10:
  %38 = phi i64 [%34, %$9] ; # X
  %39 = phi i64 [%35, %$9] ; # Sym
; # (let Siz @ (unless (== (fread Blk 2 1 Fp) 1) (jnlErr Exe)) (if (d...
; # (unless (== (fread Blk 2 1 Fp) 1) (jnlErr Exe))
; # (fread Blk 2 1 Fp)
  %40 = call i32 @fread(i8* %9, i64 2, i64 1, i8* %28)
; # (== (fread Blk 2 1 Fp) 1)
  %41 = icmp eq i32 %40, 1
  br i1 %41, label %$13, label %$12
$12:
  %42 = phi i64 [%38, %$10] ; # X
  %43 = phi i64 [%39, %$10] ; # Sym
  %44 = phi i32 [%36, %$10] ; # Siz
; # (jnlErr Exe)
  call void @jnlErr(i64 %0)
  unreachable
$13:
  %45 = phi i64 [%38, %$10] ; # X
  %46 = phi i64 [%39, %$10] ; # Sym
  %47 = phi i32 [%36, %$10] ; # Siz
; # (if (dbfBuf Blk) (let Db: (dbFile @) (when (== Siz BLKSIZE) (setq...
; # (dbfBuf Blk)
  %48 = call i8* @dbfBuf(i8* %9)
  %49 = icmp ne i8* %48, null
  br i1 %49, label %$14, label %$15
$14:
  %50 = phi i64 [%45, %$13] ; # X
  %51 = phi i64 [%46, %$13] ; # Sym
  %52 = phi i32 [%47, %$13] ; # Siz
; # (let Db: (dbFile @) (when (== Siz BLKSIZE) (setq Siz (Db: siz))) ...
; # (when (== Siz BLKSIZE) (setq Siz (Db: siz)))
; # (== Siz BLKSIZE)
  %53 = icmp eq i32 %52, 64
  br i1 %53, label %$17, label %$18
$17:
  %54 = phi i64 [%50, %$14] ; # X
  %55 = phi i64 [%51, %$14] ; # Sym
  %56 = phi i32 [%52, %$14] ; # Siz
; # (Db: siz)
  %57 = getelementptr i8, i8* %48, i32 12
  %58 = bitcast i8* %57 to i32*
  %59 = load i32, i32* %58
  br label %$18
$18:
  %60 = phi i64 [%50, %$14], [%54, %$17] ; # X
  %61 = phi i64 [%51, %$14], [%55, %$17] ; # Sym
  %62 = phi i32 [%52, %$14], [%59, %$17] ; # Siz
; # (unless Siz (setq Siz (Db: siz)))
  %63 = icmp ne i32 %62, 0
  br i1 %63, label %$20, label %$19
$19:
  %64 = phi i64 [%60, %$18] ; # X
  %65 = phi i64 [%61, %$18] ; # Sym
  %66 = phi i32 [%62, %$18] ; # Siz
; # (Db: siz)
  %67 = getelementptr i8, i8* %48, i32 12
  %68 = bitcast i8* %67 to i32*
  %69 = load i32, i32* %68
  br label %$20
$20:
  %70 = phi i64 [%60, %$18], [%64, %$19] ; # X
  %71 = phi i64 [%61, %$18], [%65, %$19] ; # Sym
  %72 = phi i32 [%62, %$18], [%69, %$19] ; # Siz
; # (unless (and (== (fread Blk BLK 1 Fp) 1) (== (fread Buf (i64 Siz)...
; # (and (== (fread Blk BLK 1 Fp) 1) (== (fread Buf (i64 Siz) 1 Fp) 1...
; # (fread Blk BLK 1 Fp)
  %73 = call i32 @fread(i8* %9, i64 6, i64 1, i8* %28)
; # (== (fread Blk BLK 1 Fp) 1)
  %74 = icmp eq i32 %73, 1
  br i1 %74, label %$22, label %$21
$22:
  %75 = phi i64 [%70, %$20] ; # X
  %76 = phi i64 [%71, %$20] ; # Sym
  %77 = phi i32 [%72, %$20] ; # Siz
; # (i64 Siz)
  %78 = sext i32 %77 to i64
; # (fread Buf (i64 Siz) 1 Fp)
  %79 = call i32 @fread(i8* %8, i64 %78, i64 1, i8* %28)
; # (== (fread Buf (i64 Siz) 1 Fp) 1)
  %80 = icmp eq i32 %79, 1
  br label %$21
$21:
  %81 = phi i64 [%70, %$20], [%75, %$22] ; # X
  %82 = phi i64 [%71, %$20], [%76, %$22] ; # Sym
  %83 = phi i32 [%72, %$20], [%77, %$22] ; # Siz
  %84 = phi i1 [0, %$20], [%80, %$22] ; # ->
  br i1 %84, label %$24, label %$23
$23:
  %85 = phi i64 [%81, %$21] ; # X
  %86 = phi i64 [%82, %$21] ; # Sym
  %87 = phi i32 [%83, %$21] ; # Siz
; # (jnlErr Exe)
  call void @jnlErr(i64 %0)
  unreachable
$24:
  %88 = phi i64 [%81, %$21] ; # X
  %89 = phi i64 [%82, %$21] ; # Sym
  %90 = phi i32 [%83, %$21] ; # Siz
; # (getAdr Blk)
  %91 = call i64 @getAdr(i8* %9)
; # (Db: sh)
  %92 = getelementptr i8, i8* %48, i32 8
  %93 = bitcast i8* %92 to i32*
  %94 = load i32, i32* %93
; # (i64 (Db: sh))
  %95 = sext i32 %94 to i64
; # (shl (getAdr Blk) (i64 (Db: sh)))
  %96 = shl i64 %91, %95
; # (blkPoke (shl (getAdr Blk) (i64 (Db: sh))) Buf Siz)
  call void @blkPoke(i64 %96, i8* %8, i32 %90)
  br label %$16
$15:
  %97 = phi i64 [%45, %$13] ; # X
  %98 = phi i64 [%46, %$13] ; # Sym
  %99 = phi i32 [%47, %$13] ; # Siz
; # (dbfErr Exe)
  call void @dbfErr(i64 %0)
  unreachable
$16:
  %100 = phi i64 [%88, %$24] ; # X
  %101 = phi i64 [%89, %$24] ; # Sym
  %102 = phi i32 [%90, %$24] ; # Siz
  br label %$9
$11:
  %103 = phi i64 [%34, %$9] ; # X
  %104 = phi i64 [%35, %$9] ; # Sym
; # (fclose Fp)
  %105 = call i32 @fclose(i8* %28)
; # (? (atom (shift X)))
; # (shift X)
  %106 = inttoptr i64 %103 to i64*
  %107 = getelementptr i64, i64* %106, i32 1
  %108 = load i64, i64* %107
; # (atom (shift X))
  %109 = and i64 %108, 15
  %110 = icmp ne i64 %109, 0
  br i1 %110, label %$26, label %$25
$25:
  %111 = phi i64 [%108, %$11] ; # X
  %112 = phi i64 [%104, %$11] ; # Sym
; # (evSym X)
  %113 = call i64 @evSym(i64 %111)
  br label %$6
$26:
  %114 = phi i64 [%108, %$11] ; # X
  %115 = phi i64 [%104, %$11] ; # Sym
  %116 = phi i64 [0, %$11] ; # ->
; # (set $DbLog Log $DbJnl Jnl)
  store i8* %6, i8** @$DbLog
  store i8* %5, i8** @$DbJnl
  ret i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
}

define i64 @_Id(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (eval (++ X))) (if (cnt? Y) (extern (if (nil?...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (if (cnt? Y) (extern (if (nil? (eval (car X))) (extNm 0 (int Y)) ...
; # (cnt? Y)
  %16 = and i64 %15, 2
  %17 = icmp ne i64 %16, 0
  br i1 %17, label %$7, label %$8
$7:
; # (if (nil? (eval (car X))) (extNm 0 (int Y)) (extNm (dec (i32 (int...
; # (car X)
  %18 = inttoptr i64 %7 to i64*
  %19 = load i64, i64* %18
; # (eval (car X))
  %20 = and i64 %19, 6
  %21 = icmp ne i64 %20, 0
  br i1 %21, label %$12, label %$11
$12:
  br label %$10
$11:
  %22 = and i64 %19, 8
  %23 = icmp ne i64 %22, 0
  br i1 %23, label %$14, label %$13
$14:
  %24 = inttoptr i64 %19 to i64*
  %25 = load i64, i64* %24
  br label %$10
$13:
  %26 = call i64 @evList(i64 %19)
  br label %$10
$10:
  %27 = phi i64 [%19, %$12], [%25, %$14], [%26, %$13] ; # ->
; # (nil? (eval (car X)))
  %28 = icmp eq i64 %27, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %28, label %$15, label %$16
$15:
; # (int Y)
  %29 = lshr i64 %15, 4
; # (extNm 0 (int Y))
  %30 = call i64 @extNm(i32 0, i64 %29)
  br label %$17
$16:
; # (int Y)
  %31 = lshr i64 %15, 4
; # (i32 (int Y))
  %32 = trunc i64 %31 to i32
; # (dec (i32 (int Y)))
  %33 = sub i32 %32, 1
; # (xCnt Exe @)
  %34 = call i64 @xCnt(i64 %0, i64 %27)
; # (extNm (dec (i32 (int Y))) (xCnt Exe @))
  %35 = call i64 @extNm(i32 %33, i64 %34)
  br label %$17
$17:
  %36 = phi i64 [%30, %$15], [%35, %$16] ; # ->
; # (extern (if (nil? (eval (car X))) (extNm 0 (int Y)) (extNm (dec (...
  %37 = call i64 @extern(i64 %36)
  br label %$9
$8:
; # (needSymb Exe Y)
  %38 = xor i64 %15, 8
  %39 = and i64 %38, 14
  %40 = icmp eq i64 %39, 0
  br i1 %40, label %$19, label %$18
$18:
  call void @symErr(i64 %0, i64 %15)
  unreachable
$19:
; # (unless (sym? (val (tail (needSymb Exe Y)))) (extErr Exe Y))
; # (needSymb Exe Y)
  %41 = xor i64 %15, 8
  %42 = and i64 %41, 14
  %43 = icmp eq i64 %42, 0
  br i1 %43, label %$21, label %$20
$20:
  call void @symErr(i64 %0, i64 %15)
  unreachable
$21:
; # (tail (needSymb Exe Y))
  %44 = add i64 %15, -8
; # (val (tail (needSymb Exe Y)))
  %45 = inttoptr i64 %44 to i64*
  %46 = load i64, i64* %45
; # (sym? (val (tail (needSymb Exe Y))))
  %47 = and i64 %46, 8
  %48 = icmp ne i64 %47, 0
  br i1 %48, label %$23, label %$22
$22:
; # (extErr Exe Y)
  call void @extErr(i64 %0, i64 %15)
  unreachable
$23:
; # (let (Nm (name (& (val (tail Y)) -9)) Z (cnt (objId Nm))) (if (ni...
; # (tail Y)
  %49 = add i64 %15, -8
; # (val (tail Y))
  %50 = inttoptr i64 %49 to i64*
  %51 = load i64, i64* %50
; # (& (val (tail Y)) -9)
  %52 = and i64 %51, -9
; # (name (& (val (tail Y)) -9))
  br label %$24
$24:
  %53 = phi i64 [%52, %$23], [%59, %$25] ; # Tail
  %54 = and i64 %53, 6
  %55 = icmp ne i64 %54, 0
  br i1 %55, label %$26, label %$25
$25:
  %56 = phi i64 [%53, %$24] ; # Tail
  %57 = inttoptr i64 %56 to i64*
  %58 = getelementptr i64, i64* %57, i32 1
  %59 = load i64, i64* %58
  br label %$24
$26:
  %60 = phi i64 [%53, %$24] ; # Tail
; # (objId Nm)
  %61 = call i64 @objId(i64 %60)
; # (cnt (objId Nm))
  %62 = shl i64 %61, 4
  %63 = or i64 %62, 2
; # (if (nil? (eval (car X))) Z (cons (cnt (i64 (inc (objFile Nm)))) ...
; # (car X)
  %64 = inttoptr i64 %7 to i64*
  %65 = load i64, i64* %64
; # (eval (car X))
  %66 = and i64 %65, 6
  %67 = icmp ne i64 %66, 0
  br i1 %67, label %$29, label %$28
$29:
  br label %$27
$28:
  %68 = and i64 %65, 8
  %69 = icmp ne i64 %68, 0
  br i1 %69, label %$31, label %$30
$31:
  %70 = inttoptr i64 %65 to i64*
  %71 = load i64, i64* %70
  br label %$27
$30:
  %72 = call i64 @evList(i64 %65)
  br label %$27
$27:
  %73 = phi i64 [%65, %$29], [%71, %$31], [%72, %$30] ; # ->
; # (nil? (eval (car X)))
  %74 = icmp eq i64 %73, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %74, label %$32, label %$33
$32:
  br label %$34
$33:
; # (objFile Nm)
  %75 = call i32 @objFile(i64 %60)
; # (inc (objFile Nm))
  %76 = add i32 %75, 1
; # (i64 (inc (objFile Nm)))
  %77 = sext i32 %76 to i64
; # (cnt (i64 (inc (objFile Nm))))
  %78 = shl i64 %77, 4
  %79 = or i64 %78, 2
; # (cons (cnt (i64 (inc (objFile Nm)))) Z)
  %80 = call i64 @cons(i64 %79, i64 %63)
  br label %$34
$34:
  %81 = phi i64 [%63, %$32], [%80, %$33] ; # ->
  br label %$9
$9:
  %82 = phi i64 [%37, %$17], [%81, %$34] ; # ->
  ret i64 %82
}

define i64 @_Blk(i64) align 8 {
$1:
; # (let (X (cdr Exe) Db: (dbFile (b8+ (dbFile T)))) (Db: fd (i32 (ev...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (b8+ (dbFile T))
  %4 = alloca i8, i64 48, align 8
; # (Db: fd (i32 (evCnt Exe X)))
  %5 = bitcast i8* %4 to i32*
  %6 = call i64 @evCnt(i64 %0, i64 %3)
  %7 = trunc i64 %6 to i32
  store i32 %7, i32* %5
; # (if (=0 (evCnt Exe (shift X))) (let Buf (b8 BLK) (unless (== (+ B...
; # (shift X)
  %8 = inttoptr i64 %3 to i64*
  %9 = getelementptr i64, i64* %8, i32 1
  %10 = load i64, i64* %9
; # (evCnt Exe (shift X))
  %11 = call i64 @evCnt(i64 %0, i64 %10)
; # (=0 (evCnt Exe (shift X)))
  %12 = icmp eq i64 %11, 0
  br i1 %12, label %$2, label %$3
$2:
  %13 = phi i64 [%10, %$1] ; # X
; # (let Buf (b8 BLK) (unless (== (+ BLK 1) (pread (Db: fd) Buf (+ BL...
; # (b8 BLK)
  %14 = alloca i8, i64 6
; # (unless (== (+ BLK 1) (pread (Db: fd) Buf (+ BLK 1) BLK)) (dbRdEr...
; # (+ BLK 1)
; # (Db: fd)
  %15 = bitcast i8* %4 to i32*
  %16 = load i32, i32* %15
; # (+ BLK 1)
; # (pread (Db: fd) Buf (+ BLK 1) BLK)
  %17 = call i64 @pread(i32 %16, i8* %14, i64 7, i64 6)
; # (== (+ BLK 1) (pread (Db: fd) Buf (+ BLK 1) BLK))
  %18 = icmp eq i64 7, %17
  br i1 %18, label %$6, label %$5
$5:
  %19 = phi i64 [%13, %$2] ; # X
; # (dbRdErr)
  call void @dbRdErr()
  unreachable
$6:
  %20 = phi i64 [%13, %$2] ; # X
; # (getAdr Buf)
  %21 = call i64 @getAdr(i8* %14)
; # (shr (getAdr Buf) 6)
  %22 = lshr i64 %21, 6
; # (cnt (shr (getAdr Buf) 6))
  %23 = shl i64 %22, 4
  %24 = or i64 %23, 2
; # (ofs Buf BLK)
  %25 = getelementptr i8, i8* %14, i32 6
; # (val (ofs Buf BLK))
  %26 = load i8, i8* %25
; # (i64 (val (ofs Buf BLK)))
  %27 = zext i8 %26 to i64
; # (cnt (i64 (val (ofs Buf BLK))))
  %28 = shl i64 %27, 4
  %29 = or i64 %28, 2
; # (cons (cnt (shr (getAdr Buf) 6)) (cnt (i64 (val (ofs Buf BLK)))))...
  %30 = call i64 @cons(i64 %24, i64 %29)
  br label %$4
$3:
  %31 = phi i64 [%10, %$1] ; # X
; # (let (N (shl @ 6) P (val $DbBlock) Siz (shl (i32 BLKSIZE) (Db: sh...
; # (shl @ 6)
  %32 = shl i64 %11, 6
; # (val $DbBlock)
  %33 = load i8*, i8** @$DbBlock
; # (i32 BLKSIZE)
; # (Db: sh (i32 (evCnt Exe (shift X))))
  %34 = getelementptr i8, i8* %4, i32 8
  %35 = bitcast i8* %34 to i32*
  %36 = inttoptr i64 %31 to i64*
  %37 = getelementptr i64, i64* %36, i32 1
  %38 = load i64, i64* %37
  %39 = call i64 @evCnt(i64 %0, i64 %38)
  %40 = trunc i64 %39 to i32
  store i32 %40, i32* %35
; # (shl (i32 BLKSIZE) (Db: sh (i32 (evCnt Exe (shift X)))))
  %41 = shl i32 64, %40
; # (if (atom (shift X)) -1 (evCnt Exe @))
; # (shift X)
  %42 = inttoptr i64 %38 to i64*
  %43 = getelementptr i64, i64* %42, i32 1
  %44 = load i64, i64* %43
; # (atom (shift X))
  %45 = and i64 %44, 15
  %46 = icmp ne i64 %45, 0
  br i1 %46, label %$7, label %$8
$7:
  %47 = phi i64 [%44, %$3] ; # X
  br label %$9
$8:
  %48 = phi i64 [%44, %$3] ; # X
; # (evCnt Exe @)
  %49 = call i64 @evCnt(i64 %0, i64 %44)
  br label %$9
$9:
  %50 = phi i64 [%47, %$7], [%48, %$8] ; # X
  %51 = phi i64 [-1, %$7], [%49, %$8] ; # ->
; # (i32 (if (atom (shift X)) -1 (evCnt Exe @)))
  %52 = trunc i64 %51 to i32
; # (when (> (Db: siz Siz) (val $MaxBlkSize)) (set $MaxBlkSize Siz $D...
; # (Db: siz Siz)
  %53 = getelementptr i8, i8* %4, i32 12
  %54 = bitcast i8* %53 to i32*
  store i32 %41, i32* %54
; # (val $MaxBlkSize)
  %55 = load i32, i32* @$MaxBlkSize
; # (> (Db: siz Siz) (val $MaxBlkSize))
  %56 = icmp sgt i32 %41, %55
  br i1 %56, label %$10, label %$11
$10:
  %57 = phi i64 [%50, %$9] ; # X
; # (set $MaxBlkSize Siz $DbBlock (alloc P (i64 Siz)))
  store i32 %41, i32* @$MaxBlkSize
; # (i64 Siz)
  %58 = sext i32 %41 to i64
; # (alloc P (i64 Siz))
  %59 = call i8* @alloc(i8* %33, i64 %58)
  store i8* %59, i8** @$DbBlock
  br label %$11
$11:
  %60 = phi i64 [%50, %$9], [%57, %$10] ; # X
; # (set $DbFile (Db:))
; # (Db:)
  store i8* %4, i8** @$DbFile
; # (when (ge0 Fd) (rdLockWait Fd 1))
; # (ge0 Fd)
  %61 = icmp sge i32 %52, 0
  br i1 %61, label %$12, label %$13
$12:
  %62 = phi i64 [%60, %$11] ; # X
; # (rdLockWait Fd 1)
  call void @rdLockWait(i32 %52, i64 1)
  br label %$13
$13:
  %63 = phi i64 [%60, %$11], [%62, %$12] ; # X
; # (prog1 (let Blk (rdBlock N) (if (<> 1 (& (val Blk) BLKTAG)) $Nil ...
; # (let Blk (rdBlock N) (if (<> 1 (& (val Blk) BLKTAG)) $Nil (set $G...
; # (rdBlock N)
  %64 = call i8* @rdBlock(i64 %32)
; # (if (<> 1 (& (val Blk) BLKTAG)) $Nil (set $GetBin (fun (i32) getB...
; # (val Blk)
  %65 = load i8, i8* %64
; # (& (val Blk) BLKTAG)
  %66 = and i8 %65, 63
; # (<> 1 (& (val Blk) BLKTAG))
  %67 = icmp ne i8 1, %66
  br i1 %67, label %$14, label %$15
$14:
  %68 = phi i64 [%63, %$13] ; # X
  br label %$16
$15:
  %69 = phi i64 [%63, %$13] ; # X
; # (set $GetBin (fun (i32) getBlock) $Extn (val $ExtN))
; # (fun (i32) getBlock)
  store i32()* @getBlock, i32()** @$GetBin
; # (val $ExtN)
  %70 = load i32, i32* @$ExtN
  store i32 %70, i32* @$Extn
; # (let (L (cons (binRead) $Nil) R (save L)) (until (nil? (binRead))...
; # (binRead)
  %71 = call i64 @binRead()
; # (cons (binRead) $Nil)
  %72 = call i64 @cons(i64 %71, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (save L)
  %73 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %74 = load i64, i64* %73
  %75 = alloca i64, i64 2, align 16
  %76 = ptrtoint i64* %75 to i64
  %77 = inttoptr i64 %76 to i64*
  store i64 %72, i64* %77
  %78 = add i64 %76, 8
  %79 = inttoptr i64 %78 to i64*
  store i64 %74, i64* %79
  %80 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %76, i64* %80
; # (until (nil? (binRead)) (setq L (set 2 L (cons @ $Nil))) (unless ...
  br label %$17
$17:
  %81 = phi i64 [%69, %$15], [%98, %$21] ; # X
  %82 = phi i64 [%72, %$15], [%99, %$21] ; # L
; # (binRead)
  %83 = call i64 @binRead()
; # (nil? (binRead))
  %84 = icmp eq i64 %83, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %84, label %$19, label %$18
$18:
  %85 = phi i64 [%81, %$17] ; # X
  %86 = phi i64 [%82, %$17] ; # L
; # (set 2 L (cons @ $Nil))
; # (cons @ $Nil)
  %87 = call i64 @cons(i64 %83, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %88 = inttoptr i64 %86 to i64*
  %89 = getelementptr i64, i64* %88, i32 1
  store i64 %87, i64* %89
; # (unless (t? (binRead)) (set L (cons @ (car L))))
; # (binRead)
  %90 = call i64 @binRead()
; # (t? (binRead))
  %91 = icmp eq i64 %90, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %91, label %$21, label %$20
$20:
  %92 = phi i64 [%85, %$18] ; # X
  %93 = phi i64 [%87, %$18] ; # L
; # (set L (cons @ (car L)))
; # (car L)
  %94 = inttoptr i64 %93 to i64*
  %95 = load i64, i64* %94
; # (cons @ (car L))
  %96 = call i64 @cons(i64 %90, i64 %95)
  %97 = inttoptr i64 %93 to i64*
  store i64 %96, i64* %97
  br label %$21
$21:
  %98 = phi i64 [%85, %$18], [%92, %$20] ; # X
  %99 = phi i64 [%87, %$18], [%93, %$20] ; # L
  br label %$17
$19:
  %100 = phi i64 [%81, %$17] ; # X
  %101 = phi i64 [%82, %$17] ; # L
; # (drop *Safe)
  %102 = inttoptr i64 %76 to i64*
  %103 = getelementptr i64, i64* %102, i32 1
  %104 = load i64, i64* %103
  %105 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %104, i64* %105
  br label %$16
$16:
  %106 = phi i64 [%68, %$14], [%100, %$19] ; # X
  %107 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$14], [%72, %$19] ; # ->
; # (when (ge0 Fd) (unLock @ 0 0))
; # (ge0 Fd)
  %108 = icmp sge i32 %52, 0
  br i1 %108, label %$22, label %$23
$22:
  %109 = phi i64 [%106, %$16] ; # X
; # (unLock @ 0 0)
  %110 = call i32 @unLock(i32 %52, i64 0, i64 0)
  br label %$23
$23:
  %111 = phi i64 [%106, %$16], [%109, %$22] ; # X
  br label %$4
$4:
  %112 = phi i64 [%20, %$6], [%111, %$23] ; # X
  %113 = phi i64 [%30, %$6], [%107, %$23] ; # ->
  ret i64 %113
}

define i64 @_Seq(i64) align 8 {
$1:
; # (let (X (eval (cadr Exe)) F (dec (i32 (int X))) N 0 Buf (b8 BLK))...
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (int X)
  %14 = lshr i64 %13, 4
; # (i32 (int X))
  %15 = trunc i64 %14 to i32
; # (dec (i32 (int X)))
  %16 = sub i32 %15, 1
; # (b8 BLK)
  %17 = alloca i8, i64 6
; # (unless (cnt? X) (unless (sym? (val (tail (needSymb Exe X)))) (ex...
; # (cnt? X)
  %18 = and i64 %13, 2
  %19 = icmp ne i64 %18, 0
  br i1 %19, label %$8, label %$7
$7:
  %20 = phi i32 [%16, %$2] ; # F
  %21 = phi i64 [0, %$2] ; # N
; # (unless (sym? (val (tail (needSymb Exe X)))) (extErr Exe X))
; # (needSymb Exe X)
  %22 = xor i64 %13, 8
  %23 = and i64 %22, 14
  %24 = icmp eq i64 %23, 0
  br i1 %24, label %$10, label %$9
$9:
  call void @symErr(i64 %0, i64 %13)
  unreachable
$10:
; # (tail (needSymb Exe X))
  %25 = add i64 %13, -8
; # (val (tail (needSymb Exe X)))
  %26 = inttoptr i64 %25 to i64*
  %27 = load i64, i64* %26
; # (sym? (val (tail (needSymb Exe X))))
  %28 = and i64 %27, 8
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %$12, label %$11
$11:
  %30 = phi i32 [%20, %$10] ; # F
  %31 = phi i64 [%21, %$10] ; # N
; # (extErr Exe X)
  call void @extErr(i64 %0, i64 %13)
  unreachable
$12:
  %32 = phi i32 [%20, %$10] ; # F
  %33 = phi i64 [%21, %$10] ; # N
; # (let Nm (name (& (val (tail X)) -9)) (setq F (objFile Nm) N (shl ...
; # (tail X)
  %34 = add i64 %13, -8
; # (val (tail X))
  %35 = inttoptr i64 %34 to i64*
  %36 = load i64, i64* %35
; # (& (val (tail X)) -9)
  %37 = and i64 %36, -9
; # (name (& (val (tail X)) -9))
  br label %$13
$13:
  %38 = phi i64 [%37, %$12], [%44, %$14] ; # Tail
  %39 = and i64 %38, 6
  %40 = icmp ne i64 %39, 0
  br i1 %40, label %$15, label %$14
$14:
  %41 = phi i64 [%38, %$13] ; # Tail
  %42 = inttoptr i64 %41 to i64*
  %43 = getelementptr i64, i64* %42, i32 1
  %44 = load i64, i64* %43
  br label %$13
$15:
  %45 = phi i64 [%38, %$13] ; # Tail
; # (objFile Nm)
  %46 = call i32 @objFile(i64 %45)
; # (objId Nm)
  %47 = call i64 @objId(i64 %45)
; # (shl (objId Nm) 6)
  %48 = shl i64 %47, 6
  br label %$8
$8:
  %49 = phi i32 [%16, %$2], [%46, %$15] ; # F
  %50 = phi i64 [0, %$2], [%48, %$15] ; # N
; # (when (>= F (val $DBs)) (dbfErr Exe))
; # (val $DBs)
  %51 = load i32, i32* @$DBs
; # (>= F (val $DBs))
  %52 = icmp sge i32 %49, %51
  br i1 %52, label %$16, label %$17
$16:
  %53 = phi i32 [%49, %$8] ; # F
  %54 = phi i64 [%50, %$8] ; # N
; # (dbfErr Exe)
  call void @dbfErr(i64 %0)
  unreachable
$17:
  %55 = phi i32 [%49, %$8] ; # F
  %56 = phi i64 [%50, %$8] ; # N
; # (let Db: (dbFile (set $DbFile (ofs (val $DbFiles) (* F (dbFile T)...
; # (set $DbFile (ofs (val $DbFiles) (* F (dbFile T))))
; # (val $DbFiles)
  %57 = load i8*, i8** @$DbFiles
; # (* F (dbFile T))
  %58 = mul i32 %55, 48
; # (ofs (val $DbFiles) (* F (dbFile T)))
  %59 = getelementptr i8, i8* %57, i32 %58
  store i8* %59, i8** @$DbFile
; # (rdLockDb)
  call void @rdLockDb()
; # (blkPeek BLK Buf BLK)
  call void @blkPeek(i64 6, i8* %17, i32 6)
; # (let Next (getAdr Buf) (prog1 (loop (? (>= (inc 'N BLKSIZE) Next)...
; # (getAdr Buf)
  %60 = call i64 @getAdr(i8* %17)
; # (prog1 (loop (? (>= (inc 'N BLKSIZE) Next) $Nil) (blkPeek (shl N ...
; # (loop (? (>= (inc 'N BLKSIZE) Next) $Nil) (blkPeek (shl N (i64 (D...
  br label %$18
$18:
  %61 = phi i32 [%55, %$17], [%82, %$22] ; # F
  %62 = phi i64 [%56, %$17], [%83, %$22] ; # N
; # (? (>= (inc 'N BLKSIZE) Next) $Nil)
; # (inc 'N BLKSIZE)
  %63 = add i64 %62, 64
; # (>= (inc 'N BLKSIZE) Next)
  %64 = icmp uge i64 %63, %60
  br i1 %64, label %$21, label %$19
$21:
  %65 = phi i32 [%61, %$18] ; # F
  %66 = phi i64 [%63, %$18] ; # N
  br label %$20
$19:
  %67 = phi i32 [%61, %$18] ; # F
  %68 = phi i64 [%63, %$18] ; # N
; # (Db: sh)
  %69 = getelementptr i8, i8* %59, i32 8
  %70 = bitcast i8* %69 to i32*
  %71 = load i32, i32* %70
; # (i64 (Db: sh))
  %72 = sext i32 %71 to i64
; # (shl N (i64 (Db: sh)))
  %73 = shl i64 %68, %72
; # (blkPeek (shl N (i64 (Db: sh))) Buf BLK)
  call void @blkPeek(i64 %73, i8* %17, i32 6)
; # (? (== 1 (& (val Buf) BLKTAG)) (extern (extNm F (shr N 6))))
; # (val Buf)
  %74 = load i8, i8* %17
; # (& (val Buf) BLKTAG)
  %75 = and i8 %74, 63
; # (== 1 (& (val Buf) BLKTAG))
  %76 = icmp eq i8 1, %75
  br i1 %76, label %$23, label %$22
$23:
  %77 = phi i32 [%67, %$19] ; # F
  %78 = phi i64 [%68, %$19] ; # N
; # (shr N 6)
  %79 = lshr i64 %78, 6
; # (extNm F (shr N 6))
  %80 = call i64 @extNm(i32 %77, i64 %79)
; # (extern (extNm F (shr N 6)))
  %81 = call i64 @extern(i64 %80)
  br label %$20
$22:
  %82 = phi i32 [%67, %$19] ; # F
  %83 = phi i64 [%68, %$19] ; # N
  br label %$18
$20:
  %84 = phi i32 [%65, %$21], [%77, %$23] ; # F
  %85 = phi i64 [%66, %$21], [%78, %$23] ; # N
  %86 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$21], [%81, %$23] ; # ->
; # (unLockDb 1)
  call void @unLockDb(i64 1)
  ret i64 %86
}

define i64 @_Lieu(i64) align 8 {
$1:
; # (let X (eval (cadr Exe)) (nond ((symb? X) $Nil) ((sym? (val (tail...
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (nond ((symb? X) $Nil) ((sym? (val (tail X))) $Nil) (NIL (let Nm ...
; # (symb? X)
  %14 = xor i64 %13, 8
  %15 = and i64 %14, 14
  %16 = icmp eq i64 %15, 0
  br i1 %16, label %$8, label %$9
$9:
  br label %$7
$8:
; # (tail X)
  %17 = add i64 %13, -8
; # (val (tail X))
  %18 = inttoptr i64 %17 to i64*
  %19 = load i64, i64* %18
; # (sym? (val (tail X)))
  %20 = and i64 %19, 8
  %21 = icmp ne i64 %20, 0
  br i1 %21, label %$10, label %$11
$11:
  br label %$7
$10:
; # (let Nm (name (& (val (tail X)) -9)) (setq Nm (add Nm Nm)) (cond ...
; # (tail X)
  %22 = add i64 %13, -8
; # (val (tail X))
  %23 = inttoptr i64 %22 to i64*
  %24 = load i64, i64* %23
; # (& (val (tail X)) -9)
  %25 = and i64 %24, -9
; # (name (& (val (tail X)) -9))
  br label %$12
$12:
  %26 = phi i64 [%25, %$10], [%32, %$13] ; # Tail
  %27 = and i64 %26, 6
  %28 = icmp ne i64 %27, 0
  br i1 %28, label %$14, label %$13
$13:
  %29 = phi i64 [%26, %$12] ; # Tail
  %30 = inttoptr i64 %29 to i64*
  %31 = getelementptr i64, i64* %30, i32 1
  %32 = load i64, i64* %31
  br label %$12
$14:
  %33 = phi i64 [%26, %$12] ; # Tail
; # (add Nm Nm)
  %34 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %33, i64 %33)
  %35 = extractvalue {i64, i1} %34, 1
  %36 = extractvalue {i64, i1} %34, 0
; # (cond (@@ (setq Nm (add Nm Nm)) (if @@ $Nil X)) (T (setq Nm (add ...
  br i1 %35, label %$17, label %$16
$17:
  %37 = phi i64 [%36, %$14] ; # Nm
; # (add Nm Nm)
  %38 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %37, i64 %37)
  %39 = extractvalue {i64, i1} %38, 1
  %40 = extractvalue {i64, i1} %38, 0
; # (if @@ $Nil X)
  br i1 %39, label %$18, label %$19
$18:
  %41 = phi i64 [%40, %$17] ; # Nm
  br label %$20
$19:
  %42 = phi i64 [%40, %$17] ; # Nm
  br label %$20
$20:
  %43 = phi i64 [%41, %$18], [%42, %$19] ; # Nm
  %44 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$18], [%13, %$19] ; # ->
  br label %$15
$16:
  %45 = phi i64 [%36, %$14] ; # Nm
; # (add Nm Nm)
  %46 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %45, i64 %45)
  %47 = extractvalue {i64, i1} %46, 1
  %48 = extractvalue {i64, i1} %46, 0
; # (if @@ X $Nil)
  br i1 %47, label %$21, label %$22
$21:
  %49 = phi i64 [%48, %$16] ; # Nm
  br label %$23
$22:
  %50 = phi i64 [%48, %$16] ; # Nm
  br label %$23
$23:
  %51 = phi i64 [%49, %$21], [%50, %$22] ; # Nm
  %52 = phi i64 [%13, %$21], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$22] ; # ->
  br label %$15
$15:
  %53 = phi i64 [%43, %$20], [%51, %$23] ; # Nm
  %54 = phi i64 [%44, %$20], [%52, %$23] ; # ->
  br label %$7
$7:
  %55 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$9], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$11], [%54, %$15] ; # ->
  ret i64 %55
}

define i64 @_Lock(i64) align 8 {
$1:
; # (if (if (nil? (eval (cadr Exe))) (tryLock (val $DbFiles) 0 0) (le...
; # (if (nil? (eval (cadr Exe))) (tryLock (val $DbFiles) 0 0) (let X ...
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (nil? (eval (cadr Exe)))
  %14 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %14, label %$7, label %$8
$7:
; # (val $DbFiles)
  %15 = load i8*, i8** @$DbFiles
; # (tryLock (val $DbFiles) 0 0)
  %16 = call i32 @tryLock(i8* %15, i64 0, i64 0)
  br label %$9
$8:
; # (let X (needSymb Exe @) (unless (sym? (val (tail (needSymb Exe X)...
; # (needSymb Exe @)
  %17 = xor i64 %13, 8
  %18 = and i64 %17, 14
  %19 = icmp eq i64 %18, 0
  br i1 %19, label %$11, label %$10
$10:
  call void @symErr(i64 %0, i64 %13)
  unreachable
$11:
; # (unless (sym? (val (tail (needSymb Exe X)))) (extErr Exe X))
; # (needSymb Exe X)
  %20 = xor i64 %13, 8
  %21 = and i64 %20, 14
  %22 = icmp eq i64 %21, 0
  br i1 %22, label %$13, label %$12
$12:
  call void @symErr(i64 %0, i64 %13)
  unreachable
$13:
; # (tail (needSymb Exe X))
  %23 = add i64 %13, -8
; # (val (tail (needSymb Exe X)))
  %24 = inttoptr i64 %23 to i64*
  %25 = load i64, i64* %24
; # (sym? (val (tail (needSymb Exe X))))
  %26 = and i64 %25, 8
  %27 = icmp ne i64 %26, 0
  br i1 %27, label %$15, label %$14
$14:
; # (extErr Exe X)
  call void @extErr(i64 %0, i64 %13)
  unreachable
$15:
; # (let (Nm (name (& (val (tail X)) -9)) F (objFile Nm) N (objId Nm)...
; # (tail X)
  %28 = add i64 %13, -8
; # (val (tail X))
  %29 = inttoptr i64 %28 to i64*
  %30 = load i64, i64* %29
; # (& (val (tail X)) -9)
  %31 = and i64 %30, -9
; # (name (& (val (tail X)) -9))
  br label %$16
$16:
  %32 = phi i64 [%31, %$15], [%38, %$17] ; # Tail
  %33 = and i64 %32, 6
  %34 = icmp ne i64 %33, 0
  br i1 %34, label %$18, label %$17
$17:
  %35 = phi i64 [%32, %$16] ; # Tail
  %36 = inttoptr i64 %35 to i64*
  %37 = getelementptr i64, i64* %36, i32 1
  %38 = load i64, i64* %37
  br label %$16
$18:
  %39 = phi i64 [%32, %$16] ; # Tail
; # (objFile Nm)
  %40 = call i32 @objFile(i64 %39)
; # (objId Nm)
  %41 = call i64 @objId(i64 %39)
; # (when (>= F (val $DBs)) (dbfErr Exe))
; # (val $DBs)
  %42 = load i32, i32* @$DBs
; # (>= F (val $DBs))
  %43 = icmp sge i32 %40, %42
  br i1 %43, label %$19, label %$20
$19:
; # (dbfErr Exe)
  call void @dbfErr(i64 %0)
  unreachable
$20:
; # (let Db: (dbFile (ofs (val $DbFiles) (* F (dbFile T)))) (tryLock ...
; # (val $DbFiles)
  %44 = load i8*, i8** @$DbFiles
; # (* F (dbFile T))
  %45 = mul i32 %40, 48
; # (ofs (val $DbFiles) (* F (dbFile T)))
  %46 = getelementptr i8, i8* %44, i32 %45
; # (Db:)
; # (Db: siz)
  %47 = getelementptr i8, i8* %46, i32 12
  %48 = bitcast i8* %47 to i32*
  %49 = load i32, i32* %48
; # (i64 (Db: siz))
  %50 = sext i32 %49 to i64
; # (* N (i64 (Db: siz)))
  %51 = mul i64 %41, %50
; # (tryLock (Db:) (* N (i64 (Db: siz))) 1)
  %52 = call i32 @tryLock(i8* %46, i64 %51, i64 1)
  br label %$9
$9:
  %53 = phi i32 [%16, %$7], [%52, %$20] ; # ->
  %54 = icmp ne i32 %53, 0
  br i1 %54, label %$21, label %$22
$21:
; # (i64 @)
  %55 = sext i32 %53 to i64
; # (cnt (i64 @))
  %56 = shl i64 %55, 4
  %57 = or i64 %56, 2
  br label %$23
$22:
  br label %$23
$23:
  %58 = phi i64 [%57, %$21], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$22] ; # ->
  ret i64 %58
}

define void @db(i64, i64, i64) align 8 {
$1:
; # (save Sym)
  %3 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %4 = load i64, i64* %3
  %5 = alloca i64, i64 2, align 16
  %6 = ptrtoint i64* %5 to i64
  %7 = inttoptr i64 %6 to i64*
  store i64 %1, i64* %7
  %8 = add i64 %6, 8
  %9 = inttoptr i64 %8 to i64*
  store i64 %4, i64* %9
  %10 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %6, i64* %10
; # (let F (objFile Nm) (if (>= F (val $DBs)) (let Ext (val $Ext) (if...
; # (objFile Nm)
  %11 = call i32 @objFile(i64 %2)
; # (if (>= F (val $DBs)) (let Ext (val $Ext) (if (or (atom Ext) (> (...
; # (val $DBs)
  %12 = load i32, i32* @$DBs
; # (>= F (val $DBs))
  %13 = icmp sge i32 %11, %12
  br i1 %13, label %$2, label %$3
$2:
  %14 = phi i64 [%2, %$1] ; # Nm
  %15 = phi i32 [%11, %$1] ; # F
; # (let Ext (val $Ext) (if (or (atom Ext) (> (i32 (int (caar @))) (i...
; # (val $Ext)
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 536) to i64) to i64*
  %17 = load i64, i64* %16
; # (if (or (atom Ext) (> (i32 (int (caar @))) (inc 'F))) (dbfErr Exe...
; # (or (atom Ext) (> (i32 (int (caar @))) (inc 'F)))
; # (atom Ext)
  %18 = and i64 %17, 15
  %19 = icmp ne i64 %18, 0
  br i1 %19, label %$5, label %$6
$6:
  %20 = phi i64 [%14, %$2] ; # Nm
  %21 = phi i32 [%15, %$2] ; # F
  %22 = phi i64 [%17, %$2] ; # Ext
; # (caar @)
  %23 = inttoptr i64 %17 to i64*
  %24 = load i64, i64* %23
  %25 = inttoptr i64 %24 to i64*
  %26 = load i64, i64* %25
; # (int (caar @))
  %27 = lshr i64 %26, 4
; # (i32 (int (caar @)))
  %28 = trunc i64 %27 to i32
; # (inc 'F)
  %29 = add i32 %21, 1
; # (> (i32 (int (caar @))) (inc 'F))
  %30 = icmp sgt i32 %28, %29
  br label %$5
$5:
  %31 = phi i64 [%14, %$2], [%20, %$6] ; # Nm
  %32 = phi i32 [%15, %$2], [%29, %$6] ; # F
  %33 = phi i64 [%17, %$2], [%22, %$6] ; # Ext
  %34 = phi i1 [1, %$2], [%30, %$6] ; # ->
  br i1 %34, label %$7, label %$8
$7:
  %35 = phi i64 [%31, %$5] ; # Nm
  %36 = phi i32 [%32, %$5] ; # F
  %37 = phi i64 [%33, %$5] ; # Ext
; # (dbfErr Exe)
  call void @dbfErr(i64 %0)
  unreachable
$8:
  %38 = phi i64 [%31, %$5] ; # Nm
  %39 = phi i32 [%32, %$5] ; # F
  %40 = phi i64 [%33, %$5] ; # Ext
; # (while (and (pair (cdr Ext)) (>= F (i32 (int (caar @))))) (shift ...
  br label %$10
$10:
  %41 = phi i64 [%38, %$8], [%63, %$13] ; # Nm
  %42 = phi i32 [%39, %$8], [%64, %$13] ; # F
  %43 = phi i64 [%40, %$8], [%68, %$13] ; # Ext
; # (and (pair (cdr Ext)) (>= F (i32 (int (caar @)))))
; # (cdr Ext)
  %44 = inttoptr i64 %43 to i64*
  %45 = getelementptr i64, i64* %44, i32 1
  %46 = load i64, i64* %45
; # (pair (cdr Ext))
  %47 = and i64 %46, 15
  %48 = icmp eq i64 %47, 0
  br i1 %48, label %$12, label %$11
$12:
  %49 = phi i64 [%41, %$10] ; # Nm
  %50 = phi i32 [%42, %$10] ; # F
  %51 = phi i64 [%43, %$10] ; # Ext
; # (caar @)
  %52 = inttoptr i64 %46 to i64*
  %53 = load i64, i64* %52
  %54 = inttoptr i64 %53 to i64*
  %55 = load i64, i64* %54
; # (int (caar @))
  %56 = lshr i64 %55, 4
; # (i32 (int (caar @)))
  %57 = trunc i64 %56 to i32
; # (>= F (i32 (int (caar @))))
  %58 = icmp sge i32 %50, %57
  br label %$11
$11:
  %59 = phi i64 [%41, %$10], [%49, %$12] ; # Nm
  %60 = phi i32 [%42, %$10], [%50, %$12] ; # F
  %61 = phi i64 [%43, %$10], [%51, %$12] ; # Ext
  %62 = phi i1 [0, %$10], [%58, %$12] ; # ->
  br i1 %62, label %$13, label %$14
$13:
  %63 = phi i64 [%59, %$11] ; # Nm
  %64 = phi i32 [%60, %$11] ; # F
  %65 = phi i64 [%61, %$11] ; # Ext
; # (shift Ext)
  %66 = inttoptr i64 %65 to i64*
  %67 = getelementptr i64, i64* %66, i32 1
  %68 = load i64, i64* %67
  br label %$10
$14:
  %69 = phi i64 [%59, %$11] ; # Nm
  %70 = phi i32 [%60, %$11] ; # F
  %71 = phi i64 [%61, %$11] ; # Ext
; # (let (V (push NIL $Nil ZERO Sym) E (push NIL V ZERO (cdar Ext))) ...
; # (push NIL $Nil ZERO Sym)
  %72 = alloca i64, i64 4, align 16
  %73 = ptrtoint i64* %72 to i64
  %74 = add i64 %73, 8
  %75 = inttoptr i64 %74 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %75
  %76 = add i64 %73, 16
  %77 = inttoptr i64 %76 to i64*
  store i64 2, i64* %77
  %78 = add i64 %73, 24
  %79 = inttoptr i64 %78 to i64*
  store i64 %1, i64* %79
; # (cdar Ext)
  %80 = inttoptr i64 %71 to i64*
  %81 = load i64, i64* %80
  %82 = inttoptr i64 %81 to i64*
  %83 = getelementptr i64, i64* %82, i32 1
  %84 = load i64, i64* %83
; # (push NIL V ZERO (cdar Ext))
  %85 = alloca i64, i64 4, align 16
  %86 = ptrtoint i64* %85 to i64
  %87 = add i64 %86, 8
  %88 = inttoptr i64 %87 to i64*
  store i64 %73, i64* %88
  %89 = add i64 %86, 16
  %90 = inttoptr i64 %89 to i64*
  store i64 2, i64* %90
  %91 = add i64 %86, 24
  %92 = inttoptr i64 %91 to i64*
  store i64 %84, i64* %92
; # (set V (ofs V 3) E (ofs E 3))
; # (ofs V 3)
  %93 = add i64 %73, 24
  %94 = inttoptr i64 %73 to i64*
  store i64 %93, i64* %94
; # (ofs E 3)
  %95 = add i64 %86, 24
  %96 = inttoptr i64 %86 to i64*
  store i64 %95, i64* %96
; # (let X (evList E) (set Sym (++ X)) (if (atom X) (set (tail Sym) N...
; # (evList E)
  %97 = call i64 @evList(i64 %86)
; # (set Sym (++ X))
; # (++ X)
  %98 = inttoptr i64 %97 to i64*
  %99 = load i64, i64* %98
  %100 = getelementptr i64, i64* %98, i32 1
  %101 = load i64, i64* %100
  %102 = inttoptr i64 %1 to i64*
  store i64 %99, i64* %102
; # (if (atom X) (set (tail Sym) Nm) (set (tail Sym) (sym X)) (while ...
; # (atom X)
  %103 = and i64 %101, 15
  %104 = icmp ne i64 %103, 0
  br i1 %104, label %$15, label %$16
$15:
  %105 = phi i64 [%69, %$14] ; # Nm
  %106 = phi i32 [%70, %$14] ; # F
  %107 = phi i64 [%71, %$14] ; # Ext
  %108 = phi i64 [%101, %$14] ; # X
; # (set (tail Sym) Nm)
; # (tail Sym)
  %109 = add i64 %1, -8
  %110 = inttoptr i64 %109 to i64*
  store i64 %105, i64* %110
  br label %$17
$16:
  %111 = phi i64 [%69, %$14] ; # Nm
  %112 = phi i32 [%70, %$14] ; # F
  %113 = phi i64 [%71, %$14] ; # Ext
  %114 = phi i64 [%101, %$14] ; # X
; # (set (tail Sym) (sym X))
; # (tail Sym)
  %115 = add i64 %1, -8
; # (sym X)
  %116 = or i64 %114, 8
  %117 = inttoptr i64 %115 to i64*
  store i64 %116, i64* %117
; # (while (pair (cdr X)) (setq X @))
  br label %$18
$18:
  %118 = phi i64 [%111, %$16], [%127, %$19] ; # Nm
  %119 = phi i32 [%112, %$16], [%128, %$19] ; # F
  %120 = phi i64 [%113, %$16], [%129, %$19] ; # Ext
  %121 = phi i64 [%114, %$16], [%124, %$19] ; # X
; # (cdr X)
  %122 = inttoptr i64 %121 to i64*
  %123 = getelementptr i64, i64* %122, i32 1
  %124 = load i64, i64* %123
; # (pair (cdr X))
  %125 = and i64 %124, 15
  %126 = icmp eq i64 %125, 0
  br i1 %126, label %$19, label %$20
$19:
  %127 = phi i64 [%118, %$18] ; # Nm
  %128 = phi i32 [%119, %$18] ; # F
  %129 = phi i64 [%120, %$18] ; # Ext
  %130 = phi i64 [%121, %$18] ; # X
  br label %$18
$20:
  %131 = phi i64 [%118, %$18] ; # Nm
  %132 = phi i32 [%119, %$18] ; # F
  %133 = phi i64 [%120, %$18] ; # Ext
  %134 = phi i64 [%121, %$18] ; # X
; # (set 2 X Nm)
  %135 = inttoptr i64 %134 to i64*
  %136 = getelementptr i64, i64* %135, i32 1
  store i64 %131, i64* %136
  br label %$17
$17:
  %137 = phi i64 [%105, %$15], [%131, %$20] ; # Nm
  %138 = phi i32 [%106, %$15], [%132, %$20] ; # F
  %139 = phi i64 [%107, %$15], [%133, %$20] ; # Ext
  %140 = phi i64 [%108, %$15], [%134, %$20] ; # X
  %141 = phi i64 [%105, %$15], [%131, %$20] ; # ->
  br label %$9
$9:
  %142 = phi i64 [%137, %$17] ; # Nm
  %143 = phi i32 [%138, %$17] ; # F
  %144 = phi i64 [%139, %$17] ; # Ext
  %145 = phi i64 [%141, %$17] ; # ->
  br label %$4
$3:
  %146 = phi i64 [%2, %$1] ; # Nm
  %147 = phi i32 [%11, %$1] ; # F
; # (set $DbFile (ofs (val $DbFiles) (* F (dbFile T))))
; # (val $DbFiles)
  %148 = load i8*, i8** @$DbFiles
; # (* F (dbFile T))
  %149 = mul i32 %147, 48
; # (ofs (val $DbFiles) (* F (dbFile T)))
  %150 = getelementptr i8, i8* %148, i32 %149
  store i8* %150, i8** @$DbFile
; # (rdLockDb)
  call void @rdLockDb()
; # (let Blk (rdBlock (shl (objId Nm) 6)) (unless (== 1 (& (val Blk) ...
; # (objId Nm)
  %151 = call i64 @objId(i64 %146)
; # (shl (objId Nm) 6)
  %152 = shl i64 %151, 6
; # (rdBlock (shl (objId Nm) 6))
  %153 = call i8* @rdBlock(i64 %152)
; # (unless (== 1 (& (val Blk) BLKTAG)) (err Exe Sym ($ "Bad ID") nul...
; # (val Blk)
  %154 = load i8, i8* %153
; # (& (val Blk) BLKTAG)
  %155 = and i8 %154, 63
; # (== 1 (& (val Blk) BLKTAG))
  %156 = icmp eq i8 1, %155
  br i1 %156, label %$22, label %$21
$21:
  %157 = phi i64 [%146, %$3] ; # Nm
  %158 = phi i32 [%147, %$3] ; # F
; # (err Exe Sym ($ "Bad ID") null)
  call void @err(i64 %0, i64 %1, i8* bitcast ([7 x i8]* @$66 to i8*), i8* null)
  unreachable
$22:
  %159 = phi i64 [%146, %$3] ; # Nm
  %160 = phi i32 [%147, %$3] ; # F
; # (set $GetBin (fun (i32) getBlock) $Extn 0)
; # (fun (i32) getBlock)
  store i32()* @getBlock, i32()** @$GetBin
  store i32 0, i32* @$Extn
; # (set Sym (binRead))
; # (binRead)
  %161 = call i64 @binRead()
  %162 = inttoptr i64 %1 to i64*
  store i64 %161, i64* %162
; # (if (nil? (binRead)) (set (tail Sym) Nm) (set (tail Sym) (sym (se...
; # (binRead)
  %163 = call i64 @binRead()
; # (nil? (binRead))
  %164 = icmp eq i64 %163, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %164, label %$23, label %$24
$23:
  %165 = phi i64 [%159, %$22] ; # Nm
  %166 = phi i32 [%160, %$22] ; # F
; # (set (tail Sym) Nm)
; # (tail Sym)
  %167 = add i64 %1, -8
  %168 = inttoptr i64 %167 to i64*
  store i64 %165, i64* %168
  br label %$25
$24:
  %169 = phi i64 [%159, %$22] ; # Nm
  %170 = phi i32 [%160, %$22] ; # F
; # (set (tail Sym) (sym (setq Nm (cons @ Nm))))
; # (tail Sym)
  %171 = add i64 %1, -8
; # (cons @ Nm)
  %172 = call i64 @cons(i64 %163, i64 %169)
; # (sym (setq Nm (cons @ Nm)))
  %173 = or i64 %172, 8
  %174 = inttoptr i64 %171 to i64*
  store i64 %173, i64* %174
; # (unless (t? (binRead)) (set Nm (cons @ (val Nm))))
; # (binRead)
  %175 = call i64 @binRead()
; # (t? (binRead))
  %176 = icmp eq i64 %175, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %176, label %$27, label %$26
$26:
  %177 = phi i64 [%172, %$24] ; # Nm
  %178 = phi i32 [%170, %$24] ; # F
; # (set Nm (cons @ (val Nm)))
; # (val Nm)
  %179 = inttoptr i64 %177 to i64*
  %180 = load i64, i64* %179
; # (cons @ (val Nm))
  %181 = call i64 @cons(i64 %175, i64 %180)
  %182 = inttoptr i64 %177 to i64*
  store i64 %181, i64* %182
  br label %$27
$27:
  %183 = phi i64 [%172, %$24], [%177, %$26] ; # Nm
  %184 = phi i32 [%170, %$24], [%178, %$26] ; # F
; # (until (nil? (binRead)) (set 2 Nm (cons @ (cdr Nm))) (shift Nm) (...
  br label %$28
$28:
  %185 = phi i64 [%183, %$27], [%208, %$32] ; # Nm
  %186 = phi i32 [%184, %$27], [%209, %$32] ; # F
; # (binRead)
  %187 = call i64 @binRead()
; # (nil? (binRead))
  %188 = icmp eq i64 %187, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %188, label %$30, label %$29
$29:
  %189 = phi i64 [%185, %$28] ; # Nm
  %190 = phi i32 [%186, %$28] ; # F
; # (set 2 Nm (cons @ (cdr Nm)))
; # (cdr Nm)
  %191 = inttoptr i64 %189 to i64*
  %192 = getelementptr i64, i64* %191, i32 1
  %193 = load i64, i64* %192
; # (cons @ (cdr Nm))
  %194 = call i64 @cons(i64 %187, i64 %193)
  %195 = inttoptr i64 %189 to i64*
  %196 = getelementptr i64, i64* %195, i32 1
  store i64 %194, i64* %196
; # (shift Nm)
  %197 = inttoptr i64 %189 to i64*
  %198 = getelementptr i64, i64* %197, i32 1
  %199 = load i64, i64* %198
; # (unless (t? (binRead)) (set Nm (cons @ (val Nm))))
; # (binRead)
  %200 = call i64 @binRead()
; # (t? (binRead))
  %201 = icmp eq i64 %200, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %201, label %$32, label %$31
$31:
  %202 = phi i64 [%199, %$29] ; # Nm
  %203 = phi i32 [%190, %$29] ; # F
; # (set Nm (cons @ (val Nm)))
; # (val Nm)
  %204 = inttoptr i64 %202 to i64*
  %205 = load i64, i64* %204
; # (cons @ (val Nm))
  %206 = call i64 @cons(i64 %200, i64 %205)
  %207 = inttoptr i64 %202 to i64*
  store i64 %206, i64* %207
  br label %$32
$32:
  %208 = phi i64 [%199, %$29], [%202, %$31] ; # Nm
  %209 = phi i32 [%190, %$29], [%203, %$31] ; # F
  br label %$28
$30:
  %210 = phi i64 [%185, %$28] ; # Nm
  %211 = phi i32 [%186, %$28] ; # F
  br label %$25
$25:
  %212 = phi i64 [%165, %$23], [%210, %$30] ; # Nm
  %213 = phi i32 [%166, %$23], [%211, %$30] ; # F
; # (unLockDb 1)
  call void @unLockDb(i64 1)
  br label %$4
$4:
  %214 = phi i64 [%142, %$9], [%212, %$25] ; # Nm
  %215 = phi i32 [%143, %$9], [%213, %$25] ; # F
; # (drop *Safe)
  %216 = inttoptr i64 %6 to i64*
  %217 = getelementptr i64, i64* %216, i32 1
  %218 = load i64, i64* %217
  %219 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %218, i64* %219
  ret void
}

define void @dbFetch(i64, i64) align 8 {
$1:
; # (let Nm (val (tail Sym)) (when (and (num? Nm) (prog (setq Nm (add...
; # (tail Sym)
  %2 = add i64 %1, -8
; # (val (tail Sym))
  %3 = inttoptr i64 %2 to i64*
  %4 = load i64, i64* %3
; # (when (and (num? Nm) (prog (setq Nm (add Nm Nm)) (not @@)) (prog ...
; # (and (num? Nm) (prog (setq Nm (add Nm Nm)) (not @@)) (prog (setq ...
; # (num? Nm)
  %5 = and i64 %4, 6
  %6 = icmp ne i64 %5, 0
  br i1 %6, label %$3, label %$2
$3:
  %7 = phi i64 [%4, %$1] ; # Nm
; # (add Nm Nm)
  %8 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %7, i64 %7)
  %9 = extractvalue {i64, i1} %8, 1
  %10 = extractvalue {i64, i1} %8, 0
; # (not @@)
  %11 = icmp eq i1 %9, 0
  br i1 %11, label %$4, label %$2
$4:
  %12 = phi i64 [%10, %$3] ; # Nm
; # (add Nm Nm)
  %13 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %12, i64 %12)
  %14 = extractvalue {i64, i1} %13, 1
  %15 = extractvalue {i64, i1} %13, 0
; # (not @@)
  %16 = icmp eq i1 %14, 0
  br label %$2
$2:
  %17 = phi i64 [%4, %$1], [%10, %$3], [%15, %$4] ; # Nm
  %18 = phi i1 [0, %$1], [0, %$3], [%16, %$4] ; # ->
  br i1 %18, label %$5, label %$6
$5:
  %19 = phi i64 [%17, %$2] ; # Nm
; # (set (tail Sym) (setq Nm (shr 1 Nm 2)))
; # (tail Sym)
  %20 = add i64 %1, -8
; # (shr 1 Nm 2)
  %21 = call i64 @llvm.fshr.i64(i64 1, i64 %19, i64 2)
  %22 = inttoptr i64 %20 to i64*
  store i64 %21, i64* %22
; # (db Exe Sym Nm)
  tail call void @db(i64 %0, i64 %1, i64 %21)
  br label %$6
$6:
  %23 = phi i64 [%17, %$2], [%21, %$5] ; # Nm
  ret void
}

define void @dbTouch(i64, i64) align 8 {
$1:
; # (let (Q (tail Sym) Nm (val Q)) (unless (num? Nm) (setq Nm (any (&...
; # (tail Sym)
  %2 = add i64 %1, -8
; # (val Q)
  %3 = inttoptr i64 %2 to i64*
  %4 = load i64, i64* %3
; # (unless (num? Nm) (setq Nm (any (& Nm -9))) (loop (setq Q (ofs Nm...
; # (num? Nm)
  %5 = and i64 %4, 6
  %6 = icmp ne i64 %5, 0
  br i1 %6, label %$3, label %$2
$2:
  %7 = phi i64 [%2, %$1] ; # Q
  %8 = phi i64 [%4, %$1] ; # Nm
; # (& Nm -9)
  %9 = and i64 %8, -9
; # (any (& Nm -9))
; # (loop (setq Q (ofs Nm 1)) (? (num? (setq Nm (val Q)))))
  br label %$4
$4:
  %10 = phi i64 [%7, %$2], [%17, %$5] ; # Q
  %11 = phi i64 [%9, %$2], [%18, %$5] ; # Nm
; # (ofs Nm 1)
  %12 = add i64 %11, 8
; # (? (num? (setq Nm (val Q))))
; # (val Q)
  %13 = inttoptr i64 %12 to i64*
  %14 = load i64, i64* %13
; # (num? (setq Nm (val Q)))
  %15 = and i64 %14, 6
  %16 = icmp ne i64 %15, 0
  br i1 %16, label %$6, label %$5
$5:
  %17 = phi i64 [%12, %$4] ; # Q
  %18 = phi i64 [%14, %$4] ; # Nm
  br label %$4
$6:
  %19 = phi i64 [%12, %$4] ; # Q
  %20 = phi i64 [%14, %$4] ; # Nm
  %21 = phi i64 [0, %$4] ; # ->
  br label %$3
$3:
  %22 = phi i64 [%2, %$1], [%19, %$6] ; # Q
  %23 = phi i64 [%4, %$1], [%20, %$6] ; # Nm
; # (add Nm Nm)
  %24 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %23, i64 %23)
  %25 = extractvalue {i64, i1} %24, 1
  %26 = extractvalue {i64, i1} %24, 0
; # (unless @@ (setq Nm (add Nm Nm)) (set Q (setq Nm (shr 2 Nm 2))) (...
  br i1 %25, label %$8, label %$7
$7:
  %27 = phi i64 [%22, %$3] ; # Q
  %28 = phi i64 [%26, %$3] ; # Nm
; # (add Nm Nm)
  %29 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %28, i64 %28)
  %30 = extractvalue {i64, i1} %29, 1
  %31 = extractvalue {i64, i1} %29, 0
; # (set Q (setq Nm (shr 2 Nm 2)))
; # (shr 2 Nm 2)
  %32 = call i64 @llvm.fshr.i64(i64 2, i64 %31, i64 2)
  %33 = inttoptr i64 %27 to i64*
  store i64 %32, i64* %33
; # (unless @@ (tailcall (db Exe Sym Nm)))
  br i1 %30, label %$10, label %$9
$9:
  %34 = phi i64 [%27, %$7] ; # Q
  %35 = phi i64 [%32, %$7] ; # Nm
; # (db Exe Sym Nm)
  tail call void @db(i64 %0, i64 %1, i64 %35)
  br label %$10
$10:
  %36 = phi i64 [%27, %$7], [%34, %$9] ; # Q
  %37 = phi i64 [%32, %$7], [%35, %$9] ; # Nm
  br label %$8
$8:
  %38 = phi i64 [%22, %$3], [%36, %$10] ; # Q
  %39 = phi i64 [%26, %$3], [%37, %$10] ; # Nm
  ret void
}

define i64 @_Touch(i64) align 8 {
$1:
; # (let X (eval (cadr Exe)) (when (and (symb? X) (sym? (val (tail X)...
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (when (and (symb? X) (sym? (val (tail X)))) (dbTouch Exe X))
; # (and (symb? X) (sym? (val (tail X))))
; # (symb? X)
  %14 = xor i64 %13, 8
  %15 = and i64 %14, 14
  %16 = icmp eq i64 %15, 0
  br i1 %16, label %$8, label %$7
$8:
; # (tail X)
  %17 = add i64 %13, -8
; # (val (tail X))
  %18 = inttoptr i64 %17 to i64*
  %19 = load i64, i64* %18
; # (sym? (val (tail X)))
  %20 = and i64 %19, 8
  %21 = icmp ne i64 %20, 0
  br label %$7
$7:
  %22 = phi i1 [0, %$2], [%21, %$8] ; # ->
  br i1 %22, label %$9, label %$10
$9:
; # (dbTouch Exe X)
  call void @dbTouch(i64 %0, i64 %13)
  br label %$10
$10:
  ret i64 %13
}

define void @dbZap(i64) align 8 {
$1:
; # (let Tail (val (tail Sym)) (unless (num? Tail) (setq Tail (& Tail...
; # (tail Sym)
  %1 = add i64 %0, -8
; # (val (tail Sym))
  %2 = inttoptr i64 %1 to i64*
  %3 = load i64, i64* %2
; # (unless (num? Tail) (setq Tail (& Tail -9)) (loop (? (num? (shift...
; # (num? Tail)
  %4 = and i64 %3, 6
  %5 = icmp ne i64 %4, 0
  br i1 %5, label %$3, label %$2
$2:
  %6 = phi i64 [%3, %$1] ; # Tail
; # (& Tail -9)
  %7 = and i64 %6, -9
; # (loop (? (num? (shift Tail))))
  br label %$4
$4:
  %8 = phi i64 [%7, %$2], [%14, %$5] ; # Tail
; # (? (num? (shift Tail)))
; # (shift Tail)
  %9 = inttoptr i64 %8 to i64*
  %10 = getelementptr i64, i64* %9, i32 1
  %11 = load i64, i64* %10
; # (num? (shift Tail))
  %12 = and i64 %11, 6
  %13 = icmp ne i64 %12, 0
  br i1 %13, label %$6, label %$5
$5:
  %14 = phi i64 [%11, %$4] ; # Tail
  br label %$4
$6:
  %15 = phi i64 [%11, %$4] ; # Tail
  %16 = phi i64 [0, %$4] ; # ->
; # (sym Tail)
  %17 = or i64 %15, 8
  br label %$3
$3:
  %18 = phi i64 [%3, %$1], [%17, %$6] ; # Tail
; # (set (tail Sym) (shr 3 (shl Tail 2) 2))
; # (tail Sym)
  %19 = add i64 %0, -8
; # (shl Tail 2)
  %20 = shl i64 %18, 2
; # (shr 3 (shl Tail 2) 2)
  %21 = call i64 @llvm.fshr.i64(i64 3, i64 %20, i64 2)
  %22 = inttoptr i64 %19 to i64*
  store i64 %21, i64* %22
; # (set Sym $Nil)
  %23 = inttoptr i64 %0 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %23
  ret void
}

define i64 @_Commit(i64) align 8 {
$1:
; # (let (Args (cdr Exe) Rpc (save (eval (++ Args))) Notify NO) (set ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ Args)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ Args))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (save (eval (++ Args)))
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %17 = load i64, i64* %16
  %18 = alloca i64, i64 2, align 16
  %19 = ptrtoint i64* %18 to i64
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = add i64 %19, 8
  %22 = inttoptr i64 %21 to i64*
  store i64 %17, i64* %22
  %23 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %19, i64* %23
; # (set $Protect (inc (val $Protect)))
; # (val $Protect)
  %24 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 176) to i32*)
; # (inc (val $Protect))
  %25 = add i32 %24, 1
  store i32 %25, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 176) to i32*)
; # (wrLockDb)
  call void @wrLockDb()
; # (when (val $DbJnl) (lockJnl))
; # (val $DbJnl)
  %26 = load i8*, i8** @$DbJnl
  %27 = icmp ne i8* %26, null
  br i1 %27, label %$7, label %$8
$7:
  %28 = phi i64 [%7, %$2] ; # Args
  %29 = phi i1 [0, %$2] ; # Notify
; # (lockJnl)
  call void @lockJnl()
  br label %$8
$8:
  %30 = phi i64 [%7, %$2], [%28, %$7] ; # Args
  %31 = phi i1 [0, %$2], [%29, %$7] ; # Notify
; # (when (val $DbLog) (let (Db (val $DbFiles) C (val $DBs)) (loop (l...
; # (val $DbLog)
  %32 = load i8*, i8** @$DbLog
  %33 = icmp ne i8* %32, null
  br i1 %33, label %$9, label %$10
$9:
  %34 = phi i64 [%30, %$8] ; # Args
  %35 = phi i1 [%31, %$8] ; # Notify
; # (let (Db (val $DbFiles) C (val $DBs)) (loop (let Db: (dbFile Db) ...
; # (val $DbFiles)
  %36 = load i8*, i8** @$DbFiles
; # (val $DBs)
  %37 = load i32, i32* @$DBs
; # (loop (let Db: (dbFile Db) (Db: drt NO) (Db: flu 0)) (? (=0 (dec ...
  br label %$11
$11:
  %38 = phi i64 [%34, %$9], [%48, %$12] ; # Args
  %39 = phi i1 [%35, %$9], [%49, %$12] ; # Notify
  %40 = phi i8* [%36, %$9], [%52, %$12] ; # Db
  %41 = phi i32 [%37, %$9], [%51, %$12] ; # C
; # (let Db: (dbFile Db) (Db: drt NO) (Db: flu 0))
; # (Db: drt NO)
  %42 = getelementptr i8, i8* %40, i32 41
  %43 = bitcast i8* %42 to i1*
  store i1 0, i1* %43
; # (Db: flu 0)
  %44 = getelementptr i8, i8* %40, i32 32
  %45 = bitcast i8* %44 to i64*
  store i64 0, i64* %45
; # (? (=0 (dec 'C)))
; # (dec 'C)
  %46 = sub i32 %41, 1
; # (=0 (dec 'C))
  %47 = icmp eq i32 %46, 0
  br i1 %47, label %$13, label %$12
$12:
  %48 = phi i64 [%38, %$11] ; # Args
  %49 = phi i1 [%39, %$11] ; # Notify
  %50 = phi i8* [%40, %$11] ; # Db
  %51 = phi i32 [%46, %$11] ; # C
; # (ofs Db (dbFile T))
  %52 = getelementptr i8, i8* %50, i32 48
  br label %$11
$13:
  %53 = phi i64 [%38, %$11] ; # Args
  %54 = phi i1 [%39, %$11] ; # Notify
  %55 = phi i8* [%40, %$11] ; # Db
  %56 = phi i32 [%46, %$11] ; # C
  %57 = phi i64 [0, %$11] ; # ->
; # (let (Tos 0 P (val $Extern)) (loop (loop (let X (cdr P) (? (atom ...
; # (val $Extern)
  %58 = load i64, i64* @$Extern
; # (loop (loop (let X (cdr P) (? (atom (car X))) (let Y P (setq P @)...
  br label %$14
$14:
  %59 = phi i64 [%53, %$13], [%228, %$32] ; # Args
  %60 = phi i1 [%54, %$13], [%229, %$32] ; # Notify
  %61 = phi i64 [0, %$13], [%230, %$32] ; # Tos
  %62 = phi i64 [%58, %$13], [%231, %$32] ; # P
; # (loop (let X (cdr P) (? (atom (car X))) (let Y P (setq P @) (set ...
  br label %$15
$15:
  %63 = phi i64 [%59, %$14], [%74, %$16] ; # Args
  %64 = phi i1 [%60, %$14], [%75, %$16] ; # Notify
  %65 = phi i64 [%61, %$14], [%77, %$16] ; # Tos
  %66 = phi i64 [%62, %$14], [%71, %$16] ; # P
; # (let X (cdr P) (? (atom (car X))) (let Y P (setq P @) (set X Tos)...
; # (cdr P)
  %67 = inttoptr i64 %66 to i64*
  %68 = getelementptr i64, i64* %67, i32 1
  %69 = load i64, i64* %68
; # (? (atom (car X)))
; # (car X)
  %70 = inttoptr i64 %69 to i64*
  %71 = load i64, i64* %70
; # (atom (car X))
  %72 = and i64 %71, 15
  %73 = icmp ne i64 %72, 0
  br i1 %73, label %$17, label %$16
$16:
  %74 = phi i64 [%63, %$15] ; # Args
  %75 = phi i1 [%64, %$15] ; # Notify
  %76 = phi i64 [%65, %$15] ; # Tos
  %77 = phi i64 [%66, %$15] ; # P
; # (let Y P (setq P @) (set X Tos) (setq Tos Y))
; # (set X Tos)
  %78 = inttoptr i64 %69 to i64*
  store i64 %76, i64* %78
  br label %$15
$17:
  %79 = phi i64 [%63, %$15] ; # Args
  %80 = phi i1 [%64, %$15] ; # Notify
  %81 = phi i64 [%65, %$15] ; # Tos
  %82 = phi i64 [%66, %$15] ; # P
  %83 = phi i64 [0, %$15] ; # ->
; # (loop (let (Nm (name (& (val (tail (val P))) -9)) N (add Nm Nm)) ...
  br label %$18
$18:
  %84 = phi i64 [%79, %$17], [%223, %$38] ; # Args
  %85 = phi i1 [%80, %$17], [%224, %$38] ; # Notify
  %86 = phi i64 [%81, %$17], [%225, %$38] ; # Tos
  %87 = phi i64 [%82, %$17], [%226, %$38] ; # P
; # (let (Nm (name (& (val (tail (val P))) -9)) N (add Nm Nm)) (when ...
; # (val P)
  %88 = inttoptr i64 %87 to i64*
  %89 = load i64, i64* %88
; # (tail (val P))
  %90 = add i64 %89, -8
; # (val (tail (val P)))
  %91 = inttoptr i64 %90 to i64*
  %92 = load i64, i64* %91
; # (& (val (tail (val P))) -9)
  %93 = and i64 %92, -9
; # (name (& (val (tail (val P))) -9))
  br label %$19
$19:
  %94 = phi i64 [%93, %$18], [%100, %$20] ; # Tail
  %95 = and i64 %94, 6
  %96 = icmp ne i64 %95, 0
  br i1 %96, label %$21, label %$20
$20:
  %97 = phi i64 [%94, %$19] ; # Tail
  %98 = inttoptr i64 %97 to i64*
  %99 = getelementptr i64, i64* %98, i32 1
  %100 = load i64, i64* %99
  br label %$19
$21:
  %101 = phi i64 [%94, %$19] ; # Tail
; # (add Nm Nm)
  %102 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %101, i64 %101)
  %103 = extractvalue {i64, i1} %102, 1
  %104 = extractvalue {i64, i1} %102, 0
; # (when @@ (let F (objFile Nm) (when (> (val $DBs) F) (set $DbFile ...
  br i1 %103, label %$22, label %$23
$22:
  %105 = phi i64 [%84, %$21] ; # Args
  %106 = phi i1 [%85, %$21] ; # Notify
  %107 = phi i64 [%86, %$21] ; # Tos
  %108 = phi i64 [%87, %$21] ; # P
; # (let F (objFile Nm) (when (> (val $DBs) F) (set $DbFile (ofs (val...
; # (objFile Nm)
  %109 = call i32 @objFile(i64 %101)
; # (when (> (val $DBs) F) (set $DbFile (ofs (val $DbFiles) (* F (dbF...
; # (val $DBs)
  %110 = load i32, i32* @$DBs
; # (> (val $DBs) F)
  %111 = icmp sgt i32 %110, %109
  br i1 %111, label %$24, label %$25
$24:
  %112 = phi i64 [%105, %$22] ; # Args
  %113 = phi i1 [%106, %$22] ; # Notify
  %114 = phi i64 [%107, %$22] ; # Tos
  %115 = phi i64 [%108, %$22] ; # P
; # (set $DbFile (ofs (val $DbFiles) (* F (dbFile T))))
; # (val $DbFiles)
  %116 = load i8*, i8** @$DbFiles
; # (* F (dbFile T))
  %117 = mul i32 %109, 48
; # (ofs (val $DbFiles) (* F (dbFile T)))
  %118 = getelementptr i8, i8* %116, i32 %117
  store i8* %118, i8** @$DbFile
; # (objId Nm)
  %119 = call i64 @objId(i64 %101)
; # (shl (objId Nm) 6)
  %120 = shl i64 %119, 6
; # (rdBlock (shl (objId Nm) 6))
  %121 = call i8* @rdBlock(i64 %120)
; # (loop (logBlock) (? (=0 (val $BlkLink))) (rdBlock @))
  br label %$26
$26:
  %122 = phi i64 [%112, %$24], [%128, %$27] ; # Args
  %123 = phi i1 [%113, %$24], [%129, %$27] ; # Notify
  %124 = phi i64 [%114, %$24], [%130, %$27] ; # Tos
  %125 = phi i64 [%115, %$24], [%131, %$27] ; # P
; # (logBlock)
  call void @logBlock()
; # (? (=0 (val $BlkLink)))
; # (val $BlkLink)
  %126 = load i64, i64* @$BlkLink
; # (=0 (val $BlkLink))
  %127 = icmp eq i64 %126, 0
  br i1 %127, label %$28, label %$27
$27:
  %128 = phi i64 [%122, %$26] ; # Args
  %129 = phi i1 [%123, %$26] ; # Notify
  %130 = phi i64 [%124, %$26] ; # Tos
  %131 = phi i64 [%125, %$26] ; # P
; # (rdBlock @)
  %132 = call i8* @rdBlock(i64 %126)
  br label %$26
$28:
  %133 = phi i64 [%122, %$26] ; # Args
  %134 = phi i1 [%123, %$26] ; # Notify
  %135 = phi i64 [%124, %$26] ; # Tos
  %136 = phi i64 [%125, %$26] ; # P
  %137 = phi i64 [0, %$26] ; # ->
; # (let Db: (dbFile (val $DbFile)) (Db: drt YES) (add N N) (unless @...
; # (val $DbFile)
  %138 = load i8*, i8** @$DbFile
; # (Db: drt YES)
  %139 = getelementptr i8, i8* %138, i32 41
  %140 = bitcast i8* %139 to i1*
  store i1 1, i1* %140
; # (add N N)
  %141 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %104, i64 %104)
  %142 = extractvalue {i64, i1} %141, 1
  %143 = extractvalue {i64, i1} %141, 0
; # (unless @@ (Db: flu (inc (Db: flu))))
  br i1 %142, label %$30, label %$29
$29:
  %144 = phi i64 [%133, %$28] ; # Args
  %145 = phi i1 [%134, %$28] ; # Notify
  %146 = phi i64 [%135, %$28] ; # Tos
  %147 = phi i64 [%136, %$28] ; # P
; # (Db: flu (inc (Db: flu)))
  %148 = getelementptr i8, i8* %138, i32 32
  %149 = bitcast i8* %148 to i64*
  %150 = getelementptr i8, i8* %138, i32 32
  %151 = bitcast i8* %150 to i64*
  %152 = load i64, i64* %151
  %153 = add i64 %152, 1
  store i64 %153, i64* %149
  br label %$30
$30:
  %154 = phi i64 [%133, %$28], [%144, %$29] ; # Args
  %155 = phi i1 [%134, %$28], [%145, %$29] ; # Notify
  %156 = phi i64 [%135, %$28], [%146, %$29] ; # Tos
  %157 = phi i64 [%136, %$28], [%147, %$29] ; # P
  br label %$25
$25:
  %158 = phi i64 [%105, %$22], [%154, %$30] ; # Args
  %159 = phi i1 [%106, %$22], [%155, %$30] ; # Notify
  %160 = phi i64 [%107, %$22], [%156, %$30] ; # Tos
  %161 = phi i64 [%108, %$22], [%157, %$30] ; # P
  br label %$23
$23:
  %162 = phi i64 [%84, %$21], [%158, %$25] ; # Args
  %163 = phi i1 [%85, %$21], [%159, %$25] ; # Notify
  %164 = phi i64 [%86, %$21], [%160, %$25] ; # Tos
  %165 = phi i64 [%87, %$21], [%161, %$25] ; # P
; # (let X (cdr P) (? (pair (cdr X)) (let Y P (setq P @) (set 2 X Tos...
; # (cdr P)
  %166 = inttoptr i64 %165 to i64*
  %167 = getelementptr i64, i64* %166, i32 1
  %168 = load i64, i64* %167
; # (? (pair (cdr X)) (let Y P (setq P @) (set 2 X Tos) (setq Tos (| ...
; # (cdr X)
  %169 = inttoptr i64 %168 to i64*
  %170 = getelementptr i64, i64* %169, i32 1
  %171 = load i64, i64* %170
; # (pair (cdr X))
  %172 = and i64 %171, 15
  %173 = icmp eq i64 %172, 0
  br i1 %173, label %$33, label %$31
$33:
  %174 = phi i64 [%162, %$23] ; # Args
  %175 = phi i1 [%163, %$23] ; # Notify
  %176 = phi i64 [%164, %$23] ; # Tos
  %177 = phi i64 [%165, %$23] ; # P
; # (let Y P (setq P @) (set 2 X Tos) (setq Tos (| Y 8)))
; # (set 2 X Tos)
  %178 = inttoptr i64 %168 to i64*
  %179 = getelementptr i64, i64* %178, i32 1
  store i64 %176, i64* %179
; # (| Y 8)
  %180 = or i64 %177, 8
  br label %$32
$31:
  %181 = phi i64 [%162, %$23] ; # Args
  %182 = phi i1 [%163, %$23] ; # Notify
  %183 = phi i64 [%164, %$23] ; # Tos
  %184 = phi i64 [%165, %$23] ; # P
; # (loop (unless Tos (goto 1)) (? (=0 (& Tos 8)) (let (X Tos Y (cdr ...
  br label %$34
$34:
  %185 = phi i64 [%181, %$31], [%210, %$37] ; # Args
  %186 = phi i1 [%182, %$31], [%211, %$37] ; # Notify
  %187 = phi i64 [%183, %$31], [%220, %$37] ; # Tos
  %188 = phi i64 [%184, %$31], [%214, %$37] ; # P
; # (unless Tos (goto 1))
  %189 = icmp ne i64 %187, 0
  br i1 %189, label %$36, label %$35
$35:
  %190 = phi i64 [%185, %$34] ; # Args
  %191 = phi i1 [%186, %$34] ; # Notify
  %192 = phi i64 [%187, %$34] ; # Tos
  %193 = phi i64 [%188, %$34] ; # P
; # (goto 1)
  br label %$-1
$36:
  %194 = phi i64 [%185, %$34] ; # Args
  %195 = phi i1 [%186, %$34] ; # Notify
  %196 = phi i64 [%187, %$34] ; # Tos
  %197 = phi i64 [%188, %$34] ; # P
; # (? (=0 (& Tos 8)) (let (X Tos Y (cdr X)) (setq Tos (car Y)) (set ...
; # (& Tos 8)
  %198 = and i64 %196, 8
; # (=0 (& Tos 8))
  %199 = icmp eq i64 %198, 0
  br i1 %199, label %$39, label %$37
$39:
  %200 = phi i64 [%194, %$36] ; # Args
  %201 = phi i1 [%195, %$36] ; # Notify
  %202 = phi i64 [%196, %$36] ; # Tos
  %203 = phi i64 [%197, %$36] ; # P
; # (let (X Tos Y (cdr X)) (setq Tos (car Y)) (set Y P) (setq P X))
; # (cdr X)
  %204 = inttoptr i64 %202 to i64*
  %205 = getelementptr i64, i64* %204, i32 1
  %206 = load i64, i64* %205
; # (car Y)
  %207 = inttoptr i64 %206 to i64*
  %208 = load i64, i64* %207
; # (set Y P)
  %209 = inttoptr i64 %206 to i64*
  store i64 %203, i64* %209
  br label %$38
$37:
  %210 = phi i64 [%194, %$36] ; # Args
  %211 = phi i1 [%195, %$36] ; # Notify
  %212 = phi i64 [%196, %$36] ; # Tos
  %213 = phi i64 [%197, %$36] ; # P
; # (& Tos -9)
  %214 = and i64 %212, -9
; # (let (X Tos Y (cdr X)) (setq Tos (cdr Y)) (set 2 Y P) (setq P X))...
; # (cdr X)
  %215 = inttoptr i64 %214 to i64*
  %216 = getelementptr i64, i64* %215, i32 1
  %217 = load i64, i64* %216
; # (cdr Y)
  %218 = inttoptr i64 %217 to i64*
  %219 = getelementptr i64, i64* %218, i32 1
  %220 = load i64, i64* %219
; # (set 2 Y P)
  %221 = inttoptr i64 %217 to i64*
  %222 = getelementptr i64, i64* %221, i32 1
  store i64 %213, i64* %222
  br label %$34
$38:
  %223 = phi i64 [%200, %$39] ; # Args
  %224 = phi i1 [%201, %$39] ; # Notify
  %225 = phi i64 [%208, %$39] ; # Tos
  %226 = phi i64 [%202, %$39] ; # P
  %227 = phi i64 [%202, %$39] ; # ->
  br label %$18
$32:
  %228 = phi i64 [%174, %$33] ; # Args
  %229 = phi i1 [%175, %$33] ; # Notify
  %230 = phi i64 [%180, %$33] ; # Tos
  %231 = phi i64 [%171, %$33] ; # P
  %232 = phi i64 [%180, %$33] ; # ->
  br label %$14
$40:
; # (: 1 (let (P (val $DbFiles) C (val $DBs)) (loop (when ((dbFile P)...
  br label %$-1
$-1:
  %233 = phi i64 [%190, %$35], [%228, %$40] ; # Args
  %234 = phi i1 [%191, %$35], [%229, %$40] ; # Notify
; # (let (P (val $DbFiles) C (val $DBs)) (loop (when ((dbFile P) flu)...
; # (val $DbFiles)
  %235 = load i8*, i8** @$DbFiles
; # (val $DBs)
  %236 = load i32, i32* @$DBs
; # (loop (when ((dbFile P) flu) (let N @ (set $DbFile P) (rdBlock 0)...
  br label %$41
$41:
  %237 = phi i64 [%233, %$-1], [%282, %$48] ; # Args
  %238 = phi i1 [%234, %$-1], [%283, %$48] ; # Notify
  %239 = phi i8* [%235, %$-1], [%286, %$48] ; # P
  %240 = phi i32 [%236, %$-1], [%285, %$48] ; # C
; # (when ((dbFile P) flu) (let N @ (set $DbFile P) (rdBlock 0) (loop...
; # ((dbFile P) flu)
  %241 = getelementptr i8, i8* %239, i32 32
  %242 = bitcast i8* %241 to i64*
  %243 = load i64, i64* %242
  %244 = icmp ne i64 %243, 0
  br i1 %244, label %$42, label %$43
$42:
  %245 = phi i64 [%237, %$41] ; # Args
  %246 = phi i1 [%238, %$41] ; # Notify
  %247 = phi i8* [%239, %$41] ; # P
  %248 = phi i32 [%240, %$41] ; # C
; # (let N @ (set $DbFile P) (rdBlock 0) (loop (logBlock) (? (=0 (dec...
; # (set $DbFile P)
  store i8* %247, i8** @$DbFile
; # (rdBlock 0)
  %249 = call i8* @rdBlock(i64 0)
; # (loop (logBlock) (? (=0 (dec 'N))) (? (=0 (val $BlkLink))) (rdBlo...
  br label %$44
$44:
  %250 = phi i64 [%245, %$42], [%264, %$47] ; # Args
  %251 = phi i1 [%246, %$42], [%265, %$47] ; # Notify
  %252 = phi i8* [%247, %$42], [%266, %$47] ; # P
  %253 = phi i32 [%248, %$42], [%267, %$47] ; # C
  %254 = phi i64 [%243, %$42], [%268, %$47] ; # N
; # (logBlock)
  call void @logBlock()
; # (? (=0 (dec 'N)))
; # (dec 'N)
  %255 = sub i64 %254, 1
; # (=0 (dec 'N))
  %256 = icmp eq i64 %255, 0
  br i1 %256, label %$46, label %$45
$45:
  %257 = phi i64 [%250, %$44] ; # Args
  %258 = phi i1 [%251, %$44] ; # Notify
  %259 = phi i8* [%252, %$44] ; # P
  %260 = phi i32 [%253, %$44] ; # C
  %261 = phi i64 [%255, %$44] ; # N
; # (? (=0 (val $BlkLink)))
; # (val $BlkLink)
  %262 = load i64, i64* @$BlkLink
; # (=0 (val $BlkLink))
  %263 = icmp eq i64 %262, 0
  br i1 %263, label %$46, label %$47
$47:
  %264 = phi i64 [%257, %$45] ; # Args
  %265 = phi i1 [%258, %$45] ; # Notify
  %266 = phi i8* [%259, %$45] ; # P
  %267 = phi i32 [%260, %$45] ; # C
  %268 = phi i64 [%261, %$45] ; # N
; # (rdBlock @)
  %269 = call i8* @rdBlock(i64 %262)
  br label %$44
$46:
  %270 = phi i64 [%250, %$44], [%257, %$45] ; # Args
  %271 = phi i1 [%251, %$44], [%258, %$45] ; # Notify
  %272 = phi i8* [%252, %$44], [%259, %$45] ; # P
  %273 = phi i32 [%253, %$44], [%260, %$45] ; # C
  %274 = phi i64 [%255, %$44], [%261, %$45] ; # N
  %275 = phi i64 [0, %$44], [0, %$45] ; # ->
  br label %$43
$43:
  %276 = phi i64 [%237, %$41], [%270, %$46] ; # Args
  %277 = phi i1 [%238, %$41], [%271, %$46] ; # Notify
  %278 = phi i8* [%239, %$41], [%272, %$46] ; # P
  %279 = phi i32 [%240, %$41], [%273, %$46] ; # C
; # (? (=0 (dec 'C)))
; # (dec 'C)
  %280 = sub i32 %279, 1
; # (=0 (dec 'C))
  %281 = icmp eq i32 %280, 0
  br i1 %281, label %$49, label %$48
$48:
  %282 = phi i64 [%276, %$43] ; # Args
  %283 = phi i1 [%277, %$43] ; # Notify
  %284 = phi i8* [%278, %$43] ; # P
  %285 = phi i32 [%280, %$43] ; # C
; # (ofs P (dbFile T))
  %286 = getelementptr i8, i8* %284, i32 48
  br label %$41
$49:
  %287 = phi i64 [%276, %$43] ; # Args
  %288 = phi i1 [%277, %$43] ; # Notify
  %289 = phi i8* [%278, %$43] ; # P
  %290 = phi i32 [%280, %$43] ; # C
  %291 = phi i64 [0, %$43] ; # ->
; # (let Log (val $DbLog) (putc_unlocked (hex "FF") Log) (putc_unlock...
; # (val $DbLog)
  %292 = load i8*, i8** @$DbLog
; # (putc_unlocked (hex "FF") Log)
  %293 = call i32 @putc_unlocked(i32 255, i8* %292)
; # (putc_unlocked (hex "FF") Log)
  %294 = call i32 @putc_unlocked(i32 255, i8* %292)
; # (fflush Log)
  %295 = call i32 @fflush(i8* %292)
; # (when (lt0 (fsync (fileno Log))) (err Exe 0 ($ "Transaction fsync...
; # (fileno Log)
  %296 = call i32 @fileno(i8* %292)
; # (fsync (fileno Log))
  %297 = call i32 @fsync(i32 %296)
; # (lt0 (fsync (fileno Log)))
  %298 = icmp slt i32 %297, 0
  br i1 %298, label %$50, label %$51
$50:
  %299 = phi i64 [%287, %$49] ; # Args
  %300 = phi i1 [%288, %$49] ; # Notify
; # (strErrno)
  %301 = call i8* @strErrno()
; # (err Exe 0 ($ "Transaction fsync error: %s") (strErrno))
  call void @err(i64 %0, i64 0, i8* bitcast ([28 x i8]* @$67 to i8*), i8* %301)
  unreachable
$51:
  %302 = phi i64 [%287, %$49] ; # Args
  %303 = phi i1 [%288, %$49] ; # Notify
  br label %$10
$10:
  %304 = phi i64 [%30, %$8], [%302, %$51] ; # Args
  %305 = phi i1 [%31, %$8], [%303, %$51] ; # Notify
; # (++ Args)
  %306 = inttoptr i64 %304 to i64*
  %307 = load i64, i64* %306
  %308 = getelementptr i64, i64* %306, i32 1
  %309 = load i64, i64* %308
; # (eval (++ Args))
  %310 = and i64 %307, 6
  %311 = icmp ne i64 %310, 0
  br i1 %311, label %$54, label %$53
$54:
  br label %$52
$53:
  %312 = and i64 %307, 8
  %313 = icmp ne i64 %312, 0
  br i1 %313, label %$56, label %$55
$56:
  %314 = inttoptr i64 %307 to i64*
  %315 = load i64, i64* %314
  br label %$52
$55:
  %316 = call i64 @evList(i64 %307)
  br label %$52
$52:
  %317 = phi i64 [%307, %$54], [%315, %$56], [%316, %$55] ; # ->
; # (when (and (not (nil? Rpc)) (or (val $Tell) (val $Children))) (se...
; # (and (not (nil? Rpc)) (or (val $Tell) (val $Children)))
; # (nil? Rpc)
  %318 = icmp eq i64 %15, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
; # (not (nil? Rpc))
  %319 = icmp eq i1 %318, 0
  br i1 %319, label %$58, label %$57
$58:
  %320 = phi i64 [%309, %$52] ; # Args
  %321 = phi i1 [%305, %$52] ; # Notify
; # (or (val $Tell) (val $Children))
; # (val $Tell)
  %322 = load i32, i32* @$Tell
  %323 = icmp ne i32 %322, 0
  br i1 %323, label %$59, label %$60
$60:
  %324 = phi i64 [%320, %$58] ; # Args
  %325 = phi i1 [%321, %$58] ; # Notify
; # (val $Children)
  %326 = load i32, i32* @$Children
  %327 = icmp ne i32 %326, 0
  br label %$59
$59:
  %328 = phi i64 [%320, %$58], [%324, %$60] ; # Args
  %329 = phi i1 [%321, %$58], [%325, %$60] ; # Notify
  %330 = phi i1 [1, %$58], [%327, %$60] ; # ->
  br label %$57
$57:
  %331 = phi i64 [%309, %$52], [%328, %$59] ; # Args
  %332 = phi i1 [%305, %$52], [%329, %$59] ; # Notify
  %333 = phi i1 [0, %$52], [%330, %$59] ; # ->
  br i1 %333, label %$61, label %$62
$61:
  %334 = phi i64 [%331, %$57] ; # Args
  %335 = phi i1 [%332, %$57] ; # Notify
; # (set $BufX (val $TellBuf) $PtrX (val $Ptr) $EndX (val $End))
; # (val $TellBuf)
  %336 = load i8*, i8** @$TellBuf
  store i8* %336, i8** @$BufX
; # (val $Ptr)
  %337 = load i8*, i8** @$Ptr
  store i8* %337, i8** @$PtrX
; # (val $End)
  %338 = load i8*, i8** @$End
  store i8* %338, i8** @$EndX
; # (val PipeBufSize)
  %339 = load i32, i32* @PipeBufSize
; # (b8 (val PipeBufSize))
  %340 = alloca i8, i32 %339
; # (tellBeg (b8 (val PipeBufSize)))
  call void @tellBeg(i8* %340)
; # (prTell Rpc)
  call void @prTell(i64 %15)
  br label %$62
$62:
  %341 = phi i64 [%331, %$57], [%334, %$61] ; # Args
  %342 = phi i1 [%332, %$57], [1, %$61] ; # Notify
; # (let (Tos 0 P (val $Extern)) (loop (loop (let X (cdr P) (? (atom ...
; # (val $Extern)
  %343 = load i64, i64* @$Extern
; # (loop (loop (let X (cdr P) (? (atom (car X))) (let Y P (setq P @)...
  br label %$63
$63:
  %344 = phi i64 [%341, %$62], [%763, %$103] ; # Args
  %345 = phi i1 [%342, %$62], [%764, %$103] ; # Notify
  %346 = phi i64 [0, %$62], [%765, %$103] ; # Tos
  %347 = phi i64 [%343, %$62], [%766, %$103] ; # P
; # (loop (let X (cdr P) (? (atom (car X))) (let Y P (setq P @) (set ...
  br label %$64
$64:
  %348 = phi i64 [%344, %$63], [%359, %$65] ; # Args
  %349 = phi i1 [%345, %$63], [%360, %$65] ; # Notify
  %350 = phi i64 [%346, %$63], [%362, %$65] ; # Tos
  %351 = phi i64 [%347, %$63], [%356, %$65] ; # P
; # (let X (cdr P) (? (atom (car X))) (let Y P (setq P @) (set X Tos)...
; # (cdr P)
  %352 = inttoptr i64 %351 to i64*
  %353 = getelementptr i64, i64* %352, i32 1
  %354 = load i64, i64* %353
; # (? (atom (car X)))
; # (car X)
  %355 = inttoptr i64 %354 to i64*
  %356 = load i64, i64* %355
; # (atom (car X))
  %357 = and i64 %356, 15
  %358 = icmp ne i64 %357, 0
  br i1 %358, label %$66, label %$65
$65:
  %359 = phi i64 [%348, %$64] ; # Args
  %360 = phi i1 [%349, %$64] ; # Notify
  %361 = phi i64 [%350, %$64] ; # Tos
  %362 = phi i64 [%351, %$64] ; # P
; # (let Y P (setq P @) (set X Tos) (setq Tos Y))
; # (set X Tos)
  %363 = inttoptr i64 %354 to i64*
  store i64 %361, i64* %363
  br label %$64
$66:
  %364 = phi i64 [%348, %$64] ; # Args
  %365 = phi i1 [%349, %$64] ; # Notify
  %366 = phi i64 [%350, %$64] ; # Tos
  %367 = phi i64 [%351, %$64] ; # P
  %368 = phi i64 [0, %$64] ; # ->
; # (loop (let (Sym (val P) Q (tail Sym) Nm (val Q)) (unless (num? Nm...
  br label %$67
$67:
  %369 = phi i64 [%364, %$66], [%758, %$109] ; # Args
  %370 = phi i1 [%365, %$66], [%759, %$109] ; # Notify
  %371 = phi i64 [%366, %$66], [%760, %$109] ; # Tos
  %372 = phi i64 [%367, %$66], [%761, %$109] ; # P
; # (let (Sym (val P) Q (tail Sym) Nm (val Q)) (unless (num? Nm) (set...
; # (val P)
  %373 = inttoptr i64 %372 to i64*
  %374 = load i64, i64* %373
; # (tail Sym)
  %375 = add i64 %374, -8
; # (val Q)
  %376 = inttoptr i64 %375 to i64*
  %377 = load i64, i64* %376
; # (unless (num? Nm) (setq Nm (any (& Nm -9))) (loop (setq Q (ofs Nm...
; # (num? Nm)
  %378 = and i64 %377, 6
  %379 = icmp ne i64 %378, 0
  br i1 %379, label %$69, label %$68
$68:
  %380 = phi i64 [%369, %$67] ; # Args
  %381 = phi i1 [%370, %$67] ; # Notify
  %382 = phi i64 [%371, %$67] ; # Tos
  %383 = phi i64 [%372, %$67] ; # P
  %384 = phi i64 [%375, %$67] ; # Q
  %385 = phi i64 [%377, %$67] ; # Nm
; # (& Nm -9)
  %386 = and i64 %385, -9
; # (any (& Nm -9))
; # (loop (setq Q (ofs Nm 1)) (? (num? (setq Nm (val Q)))))
  br label %$70
$70:
  %387 = phi i64 [%380, %$68], [%398, %$71] ; # Args
  %388 = phi i1 [%381, %$68], [%399, %$71] ; # Notify
  %389 = phi i64 [%382, %$68], [%400, %$71] ; # Tos
  %390 = phi i64 [%383, %$68], [%401, %$71] ; # P
  %391 = phi i64 [%384, %$68], [%402, %$71] ; # Q
  %392 = phi i64 [%386, %$68], [%403, %$71] ; # Nm
; # (ofs Nm 1)
  %393 = add i64 %392, 8
; # (? (num? (setq Nm (val Q))))
; # (val Q)
  %394 = inttoptr i64 %393 to i64*
  %395 = load i64, i64* %394
; # (num? (setq Nm (val Q)))
  %396 = and i64 %395, 6
  %397 = icmp ne i64 %396, 0
  br i1 %397, label %$72, label %$71
$71:
  %398 = phi i64 [%387, %$70] ; # Args
  %399 = phi i1 [%388, %$70] ; # Notify
  %400 = phi i64 [%389, %$70] ; # Tos
  %401 = phi i64 [%390, %$70] ; # P
  %402 = phi i64 [%393, %$70] ; # Q
  %403 = phi i64 [%395, %$70] ; # Nm
  br label %$70
$72:
  %404 = phi i64 [%387, %$70] ; # Args
  %405 = phi i1 [%388, %$70] ; # Notify
  %406 = phi i64 [%389, %$70] ; # Tos
  %407 = phi i64 [%390, %$70] ; # P
  %408 = phi i64 [%393, %$70] ; # Q
  %409 = phi i64 [%395, %$70] ; # Nm
  %410 = phi i64 [0, %$70] ; # ->
  br label %$69
$69:
  %411 = phi i64 [%369, %$67], [%404, %$72] ; # Args
  %412 = phi i1 [%370, %$67], [%405, %$72] ; # Notify
  %413 = phi i64 [%371, %$67], [%406, %$72] ; # Tos
  %414 = phi i64 [%372, %$67], [%407, %$72] ; # P
  %415 = phi i64 [%375, %$67], [%408, %$72] ; # Q
  %416 = phi i64 [%377, %$67], [%409, %$72] ; # Nm
; # (let N (add Nm Nm) (when @@ (let F (objFile Nm) (setq N (add N N)...
; # (add Nm Nm)
  %417 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %416, i64 %416)
  %418 = extractvalue {i64, i1} %417, 1
  %419 = extractvalue {i64, i1} %417, 0
; # (when @@ (let F (objFile Nm) (setq N (add N N)) (cond (@@ (set Q ...
  br i1 %418, label %$73, label %$74
$73:
  %420 = phi i64 [%411, %$69] ; # Args
  %421 = phi i1 [%412, %$69] ; # Notify
  %422 = phi i64 [%413, %$69] ; # Tos
  %423 = phi i64 [%414, %$69] ; # P
  %424 = phi i64 [%415, %$69] ; # Q
  %425 = phi i64 [%416, %$69] ; # Nm
  %426 = phi i64 [%419, %$69] ; # N
; # (let F (objFile Nm) (setq N (add N N)) (cond (@@ (set Q (shr N 2)...
; # (objFile Nm)
  %427 = call i32 @objFile(i64 %425)
; # (add N N)
  %428 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %426, i64 %426)
  %429 = extractvalue {i64, i1} %428, 1
  %430 = extractvalue {i64, i1} %428, 0
; # (cond (@@ (set Q (shr N 2)) (when (> (val $DBs) F) (set $DbFile (...
  br i1 %429, label %$77, label %$76
$77:
  %431 = phi i64 [%420, %$73] ; # Args
  %432 = phi i1 [%421, %$73] ; # Notify
  %433 = phi i64 [%422, %$73] ; # Tos
  %434 = phi i64 [%423, %$73] ; # P
  %435 = phi i64 [%424, %$73] ; # Q
  %436 = phi i64 [%425, %$73] ; # Nm
  %437 = phi i64 [%430, %$73] ; # N
; # (set Q (shr N 2))
; # (shr N 2)
  %438 = lshr i64 %437, 2
  %439 = inttoptr i64 %435 to i64*
  store i64 %438, i64* %439
; # (when (> (val $DBs) F) (set $DbFile (ofs (val $DbFiles) (* F (dbF...
; # (val $DBs)
  %440 = load i32, i32* @$DBs
; # (> (val $DBs) F)
  %441 = icmp sgt i32 %440, %427
  br i1 %441, label %$78, label %$79
$78:
  %442 = phi i64 [%431, %$77] ; # Args
  %443 = phi i1 [%432, %$77] ; # Notify
  %444 = phi i64 [%433, %$77] ; # Tos
  %445 = phi i64 [%434, %$77] ; # P
  %446 = phi i64 [%435, %$77] ; # Q
  %447 = phi i64 [%436, %$77] ; # Nm
  %448 = phi i64 [%437, %$77] ; # N
; # (set $DbFile (ofs (val $DbFiles) (* F (dbFile T))))
; # (val $DbFiles)
  %449 = load i8*, i8** @$DbFiles
; # (* F (dbFile T))
  %450 = mul i32 %427, 48
; # (ofs (val $DbFiles) (* F (dbFile T)))
  %451 = getelementptr i8, i8* %449, i32 %450
  store i8* %451, i8** @$DbFile
; # (objId Nm)
  %452 = call i64 @objId(i64 %447)
; # (shl (objId Nm) 6)
  %453 = shl i64 %452, 6
; # (cleanUp (shl (objId Nm) 6))
  call void @cleanUp(i64 %453)
; # (when Notify (let P (val $TellBuf) (when (>= (val $Ptr) (ofs P (-...
  br i1 %443, label %$80, label %$81
$80:
  %454 = phi i64 [%442, %$78] ; # Args
  %455 = phi i1 [%443, %$78] ; # Notify
  %456 = phi i64 [%444, %$78] ; # Tos
  %457 = phi i64 [%445, %$78] ; # P
  %458 = phi i64 [%446, %$78] ; # Q
  %459 = phi i64 [%447, %$78] ; # Nm
  %460 = phi i64 [%448, %$78] ; # N
; # (let P (val $TellBuf) (when (>= (val $Ptr) (ofs P (- (val PipeBuf...
; # (val $TellBuf)
  %461 = load i8*, i8** @$TellBuf
; # (when (>= (val $Ptr) (ofs P (- (val PipeBufSize) 10))) (tellEnd -...
; # (val $Ptr)
  %462 = load i8*, i8** @$Ptr
; # (val PipeBufSize)
  %463 = load i32, i32* @PipeBufSize
; # (- (val PipeBufSize) 10)
  %464 = sub i32 %463, 10
; # (ofs P (- (val PipeBufSize) 10))
  %465 = getelementptr i8, i8* %461, i32 %464
; # (>= (val $Ptr) (ofs P (- (val PipeBufSize) 10)))
  %466 = icmp uge i8* %462, %465
  br i1 %466, label %$82, label %$83
$82:
  %467 = phi i64 [%454, %$80] ; # Args
  %468 = phi i1 [%455, %$80] ; # Notify
  %469 = phi i64 [%456, %$80] ; # Tos
  %470 = phi i64 [%458, %$80] ; # Q
  %471 = phi i64 [%459, %$80] ; # Nm
  %472 = phi i64 [%460, %$80] ; # N
  %473 = phi i8* [%461, %$80] ; # P
; # (tellEnd -1)
  call void @tellEnd(i32 -1)
; # (set (inc 'P 8) BEG $Ptr (inc P))
; # (inc 'P 8)
  %474 = getelementptr i8, i8* %473, i32 8
  store i8 1, i8* %474
; # (inc P)
  %475 = getelementptr i8, i8* %474, i32 1
  store i8* %475, i8** @$Ptr
; # (prTell Rpc)
  call void @prTell(i64 %15)
  br label %$83
$83:
  %476 = phi i64 [%454, %$80], [%467, %$82] ; # Args
  %477 = phi i1 [%455, %$80], [%468, %$82] ; # Notify
  %478 = phi i64 [%456, %$80], [%469, %$82] ; # Tos
  %479 = phi i64 [%458, %$80], [%470, %$82] ; # Q
  %480 = phi i64 [%459, %$80], [%471, %$82] ; # Nm
  %481 = phi i64 [%460, %$80], [%472, %$82] ; # N
  %482 = phi i8* [%461, %$80], [%474, %$82] ; # P
; # (prTell Sym)
  call void @prTell(i64 %374)
  br label %$81
$81:
  %483 = phi i64 [%442, %$78], [%476, %$83] ; # Args
  %484 = phi i1 [%443, %$78], [%477, %$83] ; # Notify
  %485 = phi i64 [%444, %$78], [%478, %$83] ; # Tos
  %486 = phi i64 [%445, %$78], [%457, %$83] ; # P
  %487 = phi i64 [%446, %$78], [%479, %$83] ; # Q
  %488 = phi i64 [%447, %$78], [%480, %$83] ; # Nm
  %489 = phi i64 [%448, %$78], [%481, %$83] ; # N
  br label %$79
$79:
  %490 = phi i64 [%431, %$77], [%483, %$81] ; # Args
  %491 = phi i1 [%432, %$77], [%484, %$81] ; # Notify
  %492 = phi i64 [%433, %$77], [%485, %$81] ; # Tos
  %493 = phi i64 [%434, %$77], [%486, %$81] ; # P
  %494 = phi i64 [%435, %$77], [%487, %$81] ; # Q
  %495 = phi i64 [%436, %$77], [%488, %$81] ; # Nm
  %496 = phi i64 [%437, %$77], [%489, %$81] ; # N
  br label %$75
$76:
  %497 = phi i64 [%420, %$73] ; # Args
  %498 = phi i1 [%421, %$73] ; # Notify
  %499 = phi i64 [%422, %$73] ; # Tos
  %500 = phi i64 [%423, %$73] ; # P
  %501 = phi i64 [%424, %$73] ; # Q
  %502 = phi i64 [%425, %$73] ; # Nm
  %503 = phi i64 [%430, %$73] ; # N
; # (set Q (shr 1 N 2))
; # (shr 1 N 2)
  %504 = call i64 @llvm.fshr.i64(i64 1, i64 %503, i64 2)
  %505 = inttoptr i64 %501 to i64*
  store i64 %504, i64* %505
; # (when (> (val $DBs) F) (set $DbFile (ofs (val $DbFiles) (* F (dbF...
; # (val $DBs)
  %506 = load i32, i32* @$DBs
; # (> (val $DBs) F)
  %507 = icmp sgt i32 %506, %427
  br i1 %507, label %$84, label %$85
$84:
  %508 = phi i64 [%497, %$76] ; # Args
  %509 = phi i1 [%498, %$76] ; # Notify
  %510 = phi i64 [%499, %$76] ; # Tos
  %511 = phi i64 [%500, %$76] ; # P
  %512 = phi i64 [%501, %$76] ; # Q
  %513 = phi i64 [%502, %$76] ; # Nm
  %514 = phi i64 [%503, %$76] ; # N
; # (set $DbFile (ofs (val $DbFiles) (* F (dbFile T))))
; # (val $DbFiles)
  %515 = load i8*, i8** @$DbFiles
; # (* F (dbFile T))
  %516 = mul i32 %427, 48
; # (ofs (val $DbFiles) (* F (dbFile T)))
  %517 = getelementptr i8, i8* %515, i32 %516
  store i8* %517, i8** @$DbFile
; # (let Blk (rdBlock (shl (objId Nm) 6)) (set Blk (| (val Blk) 1) $P...
; # (objId Nm)
  %518 = call i64 @objId(i64 %513)
; # (shl (objId Nm) 6)
  %519 = shl i64 %518, 6
; # (rdBlock (shl (objId Nm) 6))
  %520 = call i8* @rdBlock(i64 %519)
; # (set Blk (| (val Blk) 1) $PutBin (fun (void i8) putBlock) $Extn 0...
; # (val Blk)
  %521 = load i8, i8* %520
; # (| (val Blk) 1)
  %522 = or i8 %521, 1
  store i8 %522, i8* %520
; # (fun (void i8) putBlock)
  store void(i8)* @putBlock, void(i8)** @$PutBin
  store i32 0, i32* @$Extn
; # (val Sym)
  %523 = inttoptr i64 %374 to i64*
  %524 = load i64, i64* %523
; # (binPrint (val Sym))
  call void @binPrint(i64 %524)
; # (let L (& (val (tail Sym)) -9) (until (num? L) (let V (++ L) (non...
; # (tail Sym)
  %525 = add i64 %374, -8
; # (val (tail Sym))
  %526 = inttoptr i64 %525 to i64*
  %527 = load i64, i64* %526
; # (& (val (tail Sym)) -9)
  %528 = and i64 %527, -9
; # (until (num? L) (let V (++ L) (nond ((atom V) (unless (nil? (cdr ...
  br label %$86
$86:
  %529 = phi i64 [%508, %$84], [%608, %$89] ; # Args
  %530 = phi i1 [%509, %$84], [%609, %$89] ; # Notify
  %531 = phi i64 [%510, %$84], [%610, %$89] ; # Tos
  %532 = phi i64 [%511, %$84], [%611, %$89] ; # P
  %533 = phi i64 [%512, %$84], [%612, %$89] ; # Q
  %534 = phi i64 [%513, %$84], [%613, %$89] ; # Nm
  %535 = phi i64 [%514, %$84], [%614, %$89] ; # N
  %536 = phi i64 [%528, %$84], [%615, %$89] ; # L
; # (num? L)
  %537 = and i64 %536, 6
  %538 = icmp ne i64 %537, 0
  br i1 %538, label %$88, label %$87
$87:
  %539 = phi i64 [%529, %$86] ; # Args
  %540 = phi i1 [%530, %$86] ; # Notify
  %541 = phi i64 [%531, %$86] ; # Tos
  %542 = phi i64 [%532, %$86] ; # P
  %543 = phi i64 [%533, %$86] ; # Q
  %544 = phi i64 [%534, %$86] ; # Nm
  %545 = phi i64 [%535, %$86] ; # N
  %546 = phi i64 [%536, %$86] ; # L
; # (let V (++ L) (nond ((atom V) (unless (nil? (cdr V)) (binPrint @)...
; # (++ L)
  %547 = inttoptr i64 %546 to i64*
  %548 = load i64, i64* %547
  %549 = getelementptr i64, i64* %547, i32 1
  %550 = load i64, i64* %549
; # (nond ((atom V) (unless (nil? (cdr V)) (binPrint @) (binPrint (ca...
; # (atom V)
  %551 = and i64 %548, 15
  %552 = icmp ne i64 %551, 0
  br i1 %552, label %$90, label %$91
$91:
  %553 = phi i64 [%539, %$87] ; # Args
  %554 = phi i1 [%540, %$87] ; # Notify
  %555 = phi i64 [%541, %$87] ; # Tos
  %556 = phi i64 [%542, %$87] ; # P
  %557 = phi i64 [%543, %$87] ; # Q
  %558 = phi i64 [%544, %$87] ; # Nm
  %559 = phi i64 [%545, %$87] ; # N
  %560 = phi i64 [%550, %$87] ; # L
; # (unless (nil? (cdr V)) (binPrint @) (binPrint (car V)))
; # (cdr V)
  %561 = inttoptr i64 %548 to i64*
  %562 = getelementptr i64, i64* %561, i32 1
  %563 = load i64, i64* %562
; # (nil? (cdr V))
  %564 = icmp eq i64 %563, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %564, label %$93, label %$92
$92:
  %565 = phi i64 [%553, %$91] ; # Args
  %566 = phi i1 [%554, %$91] ; # Notify
  %567 = phi i64 [%555, %$91] ; # Tos
  %568 = phi i64 [%556, %$91] ; # P
  %569 = phi i64 [%557, %$91] ; # Q
  %570 = phi i64 [%558, %$91] ; # Nm
  %571 = phi i64 [%559, %$91] ; # N
  %572 = phi i64 [%560, %$91] ; # L
; # (binPrint @)
  call void @binPrint(i64 %563)
; # (car V)
  %573 = inttoptr i64 %548 to i64*
  %574 = load i64, i64* %573
; # (binPrint (car V))
  call void @binPrint(i64 %574)
  br label %$93
$93:
  %575 = phi i64 [%553, %$91], [%565, %$92] ; # Args
  %576 = phi i1 [%554, %$91], [%566, %$92] ; # Notify
  %577 = phi i64 [%555, %$91], [%567, %$92] ; # Tos
  %578 = phi i64 [%556, %$91], [%568, %$92] ; # P
  %579 = phi i64 [%557, %$91], [%569, %$92] ; # Q
  %580 = phi i64 [%558, %$91], [%570, %$92] ; # Nm
  %581 = phi i64 [%559, %$91], [%571, %$92] ; # N
  %582 = phi i64 [%560, %$91], [%572, %$92] ; # L
  br label %$89
$90:
  %583 = phi i64 [%539, %$87] ; # Args
  %584 = phi i1 [%540, %$87] ; # Notify
  %585 = phi i64 [%541, %$87] ; # Tos
  %586 = phi i64 [%542, %$87] ; # P
  %587 = phi i64 [%543, %$87] ; # Q
  %588 = phi i64 [%544, %$87] ; # Nm
  %589 = phi i64 [%545, %$87] ; # N
  %590 = phi i64 [%550, %$87] ; # L
; # (nil? V)
  %591 = icmp eq i64 %548, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %591, label %$94, label %$95
$95:
  %592 = phi i64 [%583, %$90] ; # Args
  %593 = phi i1 [%584, %$90] ; # Notify
  %594 = phi i64 [%585, %$90] ; # Tos
  %595 = phi i64 [%586, %$90] ; # P
  %596 = phi i64 [%587, %$90] ; # Q
  %597 = phi i64 [%588, %$90] ; # Nm
  %598 = phi i64 [%589, %$90] ; # N
  %599 = phi i64 [%590, %$90] ; # L
; # (binPrint V)
  call void @binPrint(i64 %548)
; # (binPrint $T)
  call void @binPrint(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64))
  br label %$89
$94:
  %600 = phi i64 [%583, %$90] ; # Args
  %601 = phi i1 [%584, %$90] ; # Notify
  %602 = phi i64 [%585, %$90] ; # Tos
  %603 = phi i64 [%586, %$90] ; # P
  %604 = phi i64 [%587, %$90] ; # Q
  %605 = phi i64 [%588, %$90] ; # Nm
  %606 = phi i64 [%589, %$90] ; # N
  %607 = phi i64 [%590, %$90] ; # L
  br label %$89
$89:
  %608 = phi i64 [%575, %$93], [%592, %$95], [%600, %$94] ; # Args
  %609 = phi i1 [%576, %$93], [%593, %$95], [%601, %$94] ; # Notify
  %610 = phi i64 [%577, %$93], [%594, %$95], [%602, %$94] ; # Tos
  %611 = phi i64 [%578, %$93], [%595, %$95], [%603, %$94] ; # P
  %612 = phi i64 [%579, %$93], [%596, %$95], [%604, %$94] ; # Q
  %613 = phi i64 [%580, %$93], [%597, %$95], [%605, %$94] ; # Nm
  %614 = phi i64 [%581, %$93], [%598, %$95], [%606, %$94] ; # N
  %615 = phi i64 [%582, %$93], [%599, %$95], [%607, %$94] ; # L
  br label %$86
$88:
  %616 = phi i64 [%529, %$86] ; # Args
  %617 = phi i1 [%530, %$86] ; # Notify
  %618 = phi i64 [%531, %$86] ; # Tos
  %619 = phi i64 [%532, %$86] ; # P
  %620 = phi i64 [%533, %$86] ; # Q
  %621 = phi i64 [%534, %$86] ; # Nm
  %622 = phi i64 [%535, %$86] ; # N
  %623 = phi i64 [%536, %$86] ; # L
; # (putBlock NIX)
  call void @putBlock(i8 0)
; # (val $DbBlock)
  %624 = load i8*, i8** @$DbBlock
; # (val (val $DbBlock))
  %625 = load i8, i8* %624
; # (& (val (val $DbBlock)) BLKTAG)
  %626 = and i8 %625, 63
; # (i64 (& (val (val $DbBlock)) BLKTAG))
  %627 = zext i8 %626 to i64
; # (setAdr (i64 (& (val (val $DbBlock)) BLKTAG)) Blk)
  call void @setAdr(i64 %627, i8* %520)
; # (wrBlock)
  call void @wrBlock()
; # (when (val $BlkLink) (cleanUp @))
; # (val $BlkLink)
  %628 = load i64, i64* @$BlkLink
  %629 = icmp ne i64 %628, 0
  br i1 %629, label %$96, label %$97
$96:
  %630 = phi i64 [%616, %$88] ; # Args
  %631 = phi i1 [%617, %$88] ; # Notify
  %632 = phi i64 [%618, %$88] ; # Tos
  %633 = phi i64 [%619, %$88] ; # P
  %634 = phi i64 [%620, %$88] ; # Q
  %635 = phi i64 [%621, %$88] ; # Nm
  %636 = phi i64 [%622, %$88] ; # N
; # (cleanUp @)
  call void @cleanUp(i64 %628)
  br label %$97
$97:
  %637 = phi i64 [%616, %$88], [%630, %$96] ; # Args
  %638 = phi i1 [%617, %$88], [%631, %$96] ; # Notify
  %639 = phi i64 [%618, %$88], [%632, %$96] ; # Tos
  %640 = phi i64 [%619, %$88], [%633, %$96] ; # P
  %641 = phi i64 [%620, %$88], [%634, %$96] ; # Q
  %642 = phi i64 [%621, %$88], [%635, %$96] ; # Nm
  %643 = phi i64 [%622, %$88], [%636, %$96] ; # N
; # (when Notify (let P (val $TellBuf) (when (>= (val $Ptr) (ofs P (-...
  br i1 %638, label %$98, label %$99
$98:
  %644 = phi i64 [%637, %$97] ; # Args
  %645 = phi i1 [%638, %$97] ; # Notify
  %646 = phi i64 [%639, %$97] ; # Tos
  %647 = phi i64 [%640, %$97] ; # P
  %648 = phi i64 [%641, %$97] ; # Q
  %649 = phi i64 [%642, %$97] ; # Nm
  %650 = phi i64 [%643, %$97] ; # N
; # (let P (val $TellBuf) (when (>= (val $Ptr) (ofs P (- (val PipeBuf...
; # (val $TellBuf)
  %651 = load i8*, i8** @$TellBuf
; # (when (>= (val $Ptr) (ofs P (- (val PipeBufSize) 10))) (tellEnd -...
; # (val $Ptr)
  %652 = load i8*, i8** @$Ptr
; # (val PipeBufSize)
  %653 = load i32, i32* @PipeBufSize
; # (- (val PipeBufSize) 10)
  %654 = sub i32 %653, 10
; # (ofs P (- (val PipeBufSize) 10))
  %655 = getelementptr i8, i8* %651, i32 %654
; # (>= (val $Ptr) (ofs P (- (val PipeBufSize) 10)))
  %656 = icmp uge i8* %652, %655
  br i1 %656, label %$100, label %$101
$100:
  %657 = phi i64 [%644, %$98] ; # Args
  %658 = phi i1 [%645, %$98] ; # Notify
  %659 = phi i64 [%646, %$98] ; # Tos
  %660 = phi i64 [%648, %$98] ; # Q
  %661 = phi i64 [%649, %$98] ; # Nm
  %662 = phi i64 [%650, %$98] ; # N
  %663 = phi i8* [%651, %$98] ; # P
; # (tellEnd -1)
  call void @tellEnd(i32 -1)
; # (set (inc 'P 8) BEG $Ptr (inc P))
; # (inc 'P 8)
  %664 = getelementptr i8, i8* %663, i32 8
  store i8 1, i8* %664
; # (inc P)
  %665 = getelementptr i8, i8* %664, i32 1
  store i8* %665, i8** @$Ptr
; # (prTell Rpc)
  call void @prTell(i64 %15)
  br label %$101
$101:
  %666 = phi i64 [%644, %$98], [%657, %$100] ; # Args
  %667 = phi i1 [%645, %$98], [%658, %$100] ; # Notify
  %668 = phi i64 [%646, %$98], [%659, %$100] ; # Tos
  %669 = phi i64 [%648, %$98], [%660, %$100] ; # Q
  %670 = phi i64 [%649, %$98], [%661, %$100] ; # Nm
  %671 = phi i64 [%650, %$98], [%662, %$100] ; # N
  %672 = phi i8* [%651, %$98], [%664, %$100] ; # P
; # (prTell Sym)
  call void @prTell(i64 %374)
  br label %$99
$99:
  %673 = phi i64 [%637, %$97], [%666, %$101] ; # Args
  %674 = phi i1 [%638, %$97], [%667, %$101] ; # Notify
  %675 = phi i64 [%639, %$97], [%668, %$101] ; # Tos
  %676 = phi i64 [%640, %$97], [%647, %$101] ; # P
  %677 = phi i64 [%641, %$97], [%669, %$101] ; # Q
  %678 = phi i64 [%642, %$97], [%670, %$101] ; # Nm
  %679 = phi i64 [%643, %$97], [%671, %$101] ; # N
  br label %$85
$85:
  %680 = phi i64 [%497, %$76], [%673, %$99] ; # Args
  %681 = phi i1 [%498, %$76], [%674, %$99] ; # Notify
  %682 = phi i64 [%499, %$76], [%675, %$99] ; # Tos
  %683 = phi i64 [%500, %$76], [%676, %$99] ; # P
  %684 = phi i64 [%501, %$76], [%677, %$99] ; # Q
  %685 = phi i64 [%502, %$76], [%678, %$99] ; # Nm
  %686 = phi i64 [%503, %$76], [%679, %$99] ; # N
  br label %$75
$75:
  %687 = phi i64 [%490, %$79], [%680, %$85] ; # Args
  %688 = phi i1 [%491, %$79], [%681, %$85] ; # Notify
  %689 = phi i64 [%492, %$79], [%682, %$85] ; # Tos
  %690 = phi i64 [%493, %$79], [%683, %$85] ; # P
  %691 = phi i64 [%494, %$79], [%684, %$85] ; # Q
  %692 = phi i64 [%495, %$79], [%685, %$85] ; # Nm
  %693 = phi i64 [%496, %$79], [%686, %$85] ; # N
  br label %$74
$74:
  %694 = phi i64 [%411, %$69], [%687, %$75] ; # Args
  %695 = phi i1 [%412, %$69], [%688, %$75] ; # Notify
  %696 = phi i64 [%413, %$69], [%689, %$75] ; # Tos
  %697 = phi i64 [%414, %$69], [%690, %$75] ; # P
  %698 = phi i64 [%415, %$69], [%691, %$75] ; # Q
  %699 = phi i64 [%416, %$69], [%692, %$75] ; # Nm
  %700 = phi i64 [%419, %$69], [%693, %$75] ; # N
; # (let X (cdr P) (? (pair (cdr X)) (let Y P (setq P @) (set 2 X Tos...
; # (cdr P)
  %701 = inttoptr i64 %697 to i64*
  %702 = getelementptr i64, i64* %701, i32 1
  %703 = load i64, i64* %702
; # (? (pair (cdr X)) (let Y P (setq P @) (set 2 X Tos) (setq Tos (| ...
; # (cdr X)
  %704 = inttoptr i64 %703 to i64*
  %705 = getelementptr i64, i64* %704, i32 1
  %706 = load i64, i64* %705
; # (pair (cdr X))
  %707 = and i64 %706, 15
  %708 = icmp eq i64 %707, 0
  br i1 %708, label %$104, label %$102
$104:
  %709 = phi i64 [%694, %$74] ; # Args
  %710 = phi i1 [%695, %$74] ; # Notify
  %711 = phi i64 [%696, %$74] ; # Tos
  %712 = phi i64 [%697, %$74] ; # P
; # (let Y P (setq P @) (set 2 X Tos) (setq Tos (| Y 8)))
; # (set 2 X Tos)
  %713 = inttoptr i64 %703 to i64*
  %714 = getelementptr i64, i64* %713, i32 1
  store i64 %711, i64* %714
; # (| Y 8)
  %715 = or i64 %712, 8
  br label %$103
$102:
  %716 = phi i64 [%694, %$74] ; # Args
  %717 = phi i1 [%695, %$74] ; # Notify
  %718 = phi i64 [%696, %$74] ; # Tos
  %719 = phi i64 [%697, %$74] ; # P
; # (loop (unless Tos (goto 2)) (? (=0 (& Tos 8)) (let (X Tos Y (cdr ...
  br label %$105
$105:
  %720 = phi i64 [%716, %$102], [%745, %$108] ; # Args
  %721 = phi i1 [%717, %$102], [%746, %$108] ; # Notify
  %722 = phi i64 [%718, %$102], [%755, %$108] ; # Tos
  %723 = phi i64 [%719, %$102], [%749, %$108] ; # P
; # (unless Tos (goto 2))
  %724 = icmp ne i64 %722, 0
  br i1 %724, label %$107, label %$106
$106:
  %725 = phi i64 [%720, %$105] ; # Args
  %726 = phi i1 [%721, %$105] ; # Notify
  %727 = phi i64 [%722, %$105] ; # Tos
  %728 = phi i64 [%723, %$105] ; # P
; # (goto 2)
  br label %$-2
$107:
  %729 = phi i64 [%720, %$105] ; # Args
  %730 = phi i1 [%721, %$105] ; # Notify
  %731 = phi i64 [%722, %$105] ; # Tos
  %732 = phi i64 [%723, %$105] ; # P
; # (? (=0 (& Tos 8)) (let (X Tos Y (cdr X)) (setq Tos (car Y)) (set ...
; # (& Tos 8)
  %733 = and i64 %731, 8
; # (=0 (& Tos 8))
  %734 = icmp eq i64 %733, 0
  br i1 %734, label %$110, label %$108
$110:
  %735 = phi i64 [%729, %$107] ; # Args
  %736 = phi i1 [%730, %$107] ; # Notify
  %737 = phi i64 [%731, %$107] ; # Tos
  %738 = phi i64 [%732, %$107] ; # P
; # (let (X Tos Y (cdr X)) (setq Tos (car Y)) (set Y P) (setq P X))
; # (cdr X)
  %739 = inttoptr i64 %737 to i64*
  %740 = getelementptr i64, i64* %739, i32 1
  %741 = load i64, i64* %740
; # (car Y)
  %742 = inttoptr i64 %741 to i64*
  %743 = load i64, i64* %742
; # (set Y P)
  %744 = inttoptr i64 %741 to i64*
  store i64 %738, i64* %744
  br label %$109
$108:
  %745 = phi i64 [%729, %$107] ; # Args
  %746 = phi i1 [%730, %$107] ; # Notify
  %747 = phi i64 [%731, %$107] ; # Tos
  %748 = phi i64 [%732, %$107] ; # P
; # (& Tos -9)
  %749 = and i64 %747, -9
; # (let (X Tos Y (cdr X)) (setq Tos (cdr Y)) (set 2 Y P) (setq P X))...
; # (cdr X)
  %750 = inttoptr i64 %749 to i64*
  %751 = getelementptr i64, i64* %750, i32 1
  %752 = load i64, i64* %751
; # (cdr Y)
  %753 = inttoptr i64 %752 to i64*
  %754 = getelementptr i64, i64* %753, i32 1
  %755 = load i64, i64* %754
; # (set 2 Y P)
  %756 = inttoptr i64 %752 to i64*
  %757 = getelementptr i64, i64* %756, i32 1
  store i64 %748, i64* %757
  br label %$105
$109:
  %758 = phi i64 [%735, %$110] ; # Args
  %759 = phi i1 [%736, %$110] ; # Notify
  %760 = phi i64 [%743, %$110] ; # Tos
  %761 = phi i64 [%737, %$110] ; # P
  %762 = phi i64 [%737, %$110] ; # ->
  br label %$67
$103:
  %763 = phi i64 [%709, %$104] ; # Args
  %764 = phi i1 [%710, %$104] ; # Notify
  %765 = phi i64 [%715, %$104] ; # Tos
  %766 = phi i64 [%706, %$104] ; # P
  %767 = phi i64 [%715, %$104] ; # ->
  br label %$63
$111:
; # (: 2 (when Notify (tellEnd -1) (set $TellBuf (val $BufX) $Ptr (va...
  br label %$-2
$-2:
  %768 = phi i64 [%725, %$106], [%763, %$111] ; # Args
  %769 = phi i1 [%726, %$106], [%764, %$111] ; # Notify
; # (when Notify (tellEnd -1) (set $TellBuf (val $BufX) $Ptr (val $Pt...
  br i1 %769, label %$112, label %$113
$112:
  %770 = phi i64 [%768, %$-2] ; # Args
  %771 = phi i1 [%769, %$-2] ; # Notify
; # (tellEnd -1)
  call void @tellEnd(i32 -1)
; # (set $TellBuf (val $BufX) $Ptr (val $PtrX) $End (val $EndX))
; # (val $BufX)
  %772 = load i8*, i8** @$BufX
  store i8* %772, i8** @$TellBuf
; # (val $PtrX)
  %773 = load i8*, i8** @$PtrX
  store i8* %773, i8** @$Ptr
; # (val $EndX)
  %774 = load i8*, i8** @$EndX
  store i8* %774, i8** @$End
  br label %$113
$113:
  %775 = phi i64 [%768, %$-2], [%770, %$112] ; # Args
  %776 = phi i1 [%769, %$-2], [%771, %$112] ; # Notify
; # (car Args)
  %777 = inttoptr i64 %775 to i64*
  %778 = load i64, i64* %777
; # (eval (car Args))
  %779 = and i64 %778, 6
  %780 = icmp ne i64 %779, 0
  br i1 %780, label %$116, label %$115
$116:
  br label %$114
$115:
  %781 = and i64 %778, 8
  %782 = icmp ne i64 %781, 0
  br i1 %782, label %$118, label %$117
$118:
  %783 = inttoptr i64 %778 to i64*
  %784 = load i64, i64* %783
  br label %$114
$117:
  %785 = call i64 @evList(i64 %778)
  br label %$114
$114:
  %786 = phi i64 [%778, %$116], [%784, %$118], [%785, %$117] ; # ->
; # (when (val $DbJnl) (unLockJnl))
; # (val $DbJnl)
  %787 = load i8*, i8** @$DbJnl
  %788 = icmp ne i8* %787, null
  br i1 %788, label %$119, label %$120
$119:
  %789 = phi i64 [%775, %$114] ; # Args
  %790 = phi i1 [%776, %$114] ; # Notify
; # (unLockJnl)
  call void @unLockJnl()
  br label %$120
$120:
  %791 = phi i64 [%775, %$114], [%789, %$119] ; # Args
  %792 = phi i1 [%776, %$114], [%790, %$119] ; # Notify
; # (when (pair (val $Zap)) (let (Z @ Out (val $OutFile) Nm (xName (c...
; # (val $Zap)
  %793 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 520) to i64) to i64*
  %794 = load i64, i64* %793
; # (pair (val $Zap))
  %795 = and i64 %794, 15
  %796 = icmp eq i64 %795, 0
  br i1 %796, label %$121, label %$122
$121:
  %797 = phi i64 [%791, %$120] ; # Args
  %798 = phi i1 [%792, %$120] ; # Notify
; # (let (Z @ Out (val $OutFile) Nm (xName (cdr Z)) S (pathString Nm ...
; # (val $OutFile)
  %799 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 80) to i8**)
; # (cdr Z)
  %800 = inttoptr i64 %794 to i64*
  %801 = getelementptr i64, i64* %800, i32 1
  %802 = load i64, i64* %801
; # (xName (cdr Z))
  %803 = call i64 @xName(i64 %802)
; # (pathSize Nm)
  %804 = call i64 @pathSize(i64 %803)
; # (b8 (pathSize Nm))
  %805 = alloca i8, i64 %804
; # (pathString Nm (b8 (pathSize Nm)))
  %806 = call i8* @pathString(i64 %803, i8* %805)
; # (b8+ (outFile T))
  %807 = alloca i8, i64 4105, align 8
; # (when (lt0 (openWrAppend S)) (openErr Exe (cdr Z)))
; # (openWrAppend S)
  %808 = call i32 @openWrAppend(i8* %806)
; # (lt0 (openWrAppend S))
  %809 = icmp slt i32 %808, 0
  br i1 %809, label %$123, label %$124
$123:
  %810 = phi i64 [%797, %$121] ; # Args
  %811 = phi i1 [%798, %$121] ; # Notify
; # (cdr Z)
  %812 = inttoptr i64 %794 to i64*
  %813 = getelementptr i64, i64* %812, i32 1
  %814 = load i64, i64* %813
; # (openErr Exe (cdr Z))
  call void @openErr(i64 %0, i64 %814)
  unreachable
$124:
  %815 = phi i64 [%797, %$121] ; # Args
  %816 = phi i1 [%798, %$121] ; # Notify
; # (Out: fd @)
  %817 = bitcast i8* %807 to i32*
  store i32 %808, i32* %817
; # (Out: ix 0)
  %818 = getelementptr i8, i8* %807, i32 4
  %819 = bitcast i8* %818 to i32*
  store i32 0, i32* %819
; # (Out: tty NO)
  %820 = getelementptr i8, i8* %807, i32 4104
  %821 = bitcast i8* %820 to i1*
  store i1 0, i1* %821
; # (set $OutFile (Out:) $PutBin (fun (void i8) _putStdout) $Extn 0)
; # (Out:)
  store i8* %807, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 80) to i8**)
; # (fun (void i8) _putStdout)
  store void(i8)* @_putStdout, void(i8)** @$PutBin
  store i32 0, i32* @$Extn
; # (let Y (car Z) (while (pair Y) (binPrint (++ Y))) (flush (Out:)) ...
; # (car Z)
  %822 = inttoptr i64 %794 to i64*
  %823 = load i64, i64* %822
; # (while (pair Y) (binPrint (++ Y)))
  br label %$125
$125:
  %824 = phi i64 [%815, %$124], [%829, %$126] ; # Args
  %825 = phi i1 [%816, %$124], [%830, %$126] ; # Notify
  %826 = phi i64 [%823, %$124], [%835, %$126] ; # Y
; # (pair Y)
  %827 = and i64 %826, 15
  %828 = icmp eq i64 %827, 0
  br i1 %828, label %$126, label %$127
$126:
  %829 = phi i64 [%824, %$125] ; # Args
  %830 = phi i1 [%825, %$125] ; # Notify
  %831 = phi i64 [%826, %$125] ; # Y
; # (++ Y)
  %832 = inttoptr i64 %831 to i64*
  %833 = load i64, i64* %832
  %834 = getelementptr i64, i64* %832, i32 1
  %835 = load i64, i64* %834
; # (binPrint (++ Y))
  call void @binPrint(i64 %833)
  br label %$125
$127:
  %836 = phi i64 [%824, %$125] ; # Args
  %837 = phi i1 [%825, %$125] ; # Notify
  %838 = phi i64 [%826, %$125] ; # Y
; # (Out:)
; # (flush (Out:))
  %839 = call i1 @flush(i8* %807)
; # (Out: fd)
  %840 = bitcast i8* %807 to i32*
  %841 = load i32, i32* %840
; # (close (Out: fd))
  %842 = call i32 @close(i32 %841)
; # (set Z $Nil)
  %843 = inttoptr i64 %794 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %843
; # (set $OutFile Out)
  store i8* %799, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 80) to i8**)
  br label %$122
$122:
  %844 = phi i64 [%791, %$120], [%836, %$127] ; # Args
  %845 = phi i1 [%792, %$120], [%837, %$127] ; # Notify
; # (when (val $DbLog) (fsyncDB Exe) (truncLog Exe))
; # (val $DbLog)
  %846 = load i8*, i8** @$DbLog
  %847 = icmp ne i8* %846, null
  br i1 %847, label %$128, label %$129
$128:
  %848 = phi i64 [%844, %$122] ; # Args
  %849 = phi i1 [%845, %$122] ; # Notify
; # (fsyncDB Exe)
  call void @fsyncDB(i64 %0)
; # (truncLog Exe)
  call void @truncLog(i64 %0)
  br label %$129
$129:
  %850 = phi i64 [%844, %$122], [%848, %$128] ; # Args
  %851 = phi i1 [%845, %$122], [%849, %$128] ; # Notify
; # (unLockDb 0)
  call void @unLockDb(i64 0)
; # (unsync)
  call void @unsync()
; # (set $Protect (dec (val $Protect)))
; # (val $Protect)
  %852 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 176) to i32*)
; # (dec (val $Protect))
  %853 = sub i32 %852, 1
  store i32 %853, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 176) to i32*)
; # (let (P (val $DbFiles) C (val $DBs)) (loop ((dbFile P) flu -1) (?...
; # (val $DbFiles)
  %854 = load i8*, i8** @$DbFiles
; # (val $DBs)
  %855 = load i32, i32* @$DBs
; # (loop ((dbFile P) flu -1) (? (=0 (dec 'C))) (setq P (ofs P (dbFil...
  br label %$130
$130:
  %856 = phi i64 [%850, %$129], [%864, %$131] ; # Args
  %857 = phi i1 [%851, %$129], [%865, %$131] ; # Notify
  %858 = phi i8* [%854, %$129], [%868, %$131] ; # P
  %859 = phi i32 [%855, %$129], [%867, %$131] ; # C
; # ((dbFile P) flu -1)
  %860 = getelementptr i8, i8* %858, i32 32
  %861 = bitcast i8* %860 to i64*
  store i64 -1, i64* %861
; # (? (=0 (dec 'C)))
; # (dec 'C)
  %862 = sub i32 %859, 1
; # (=0 (dec 'C))
  %863 = icmp eq i32 %862, 0
  br i1 %863, label %$132, label %$131
$131:
  %864 = phi i64 [%856, %$130] ; # Args
  %865 = phi i1 [%857, %$130] ; # Notify
  %866 = phi i8* [%858, %$130] ; # P
  %867 = phi i32 [%862, %$130] ; # C
; # (ofs P (dbFile T))
  %868 = getelementptr i8, i8* %866, i32 48
  br label %$130
$132:
  %869 = phi i64 [%856, %$130] ; # Args
  %870 = phi i1 [%857, %$130] ; # Notify
  %871 = phi i8* [%858, %$130] ; # P
  %872 = phi i32 [%862, %$130] ; # C
  %873 = phi i64 [0, %$130] ; # ->
; # (drop *Safe)
  %874 = inttoptr i64 %19 to i64*
  %875 = getelementptr i64, i64* %874, i32 1
  %876 = load i64, i64* %875
  %877 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %876, i64* %877
  ret i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
}

define i64 @_Mark(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (eval (++ X))) (if (== Y ZERO) (let (Db (val ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (if (== Y ZERO) (let (Db (val $DbFiles) C (val $DBs)) (while (ge0...
; # (== Y ZERO)
  %16 = icmp eq i64 %15, 2
  br i1 %16, label %$7, label %$8
$7:
; # (let (Db (val $DbFiles) C (val $DBs)) (while (ge0 (dec 'C)) (let ...
; # (val $DbFiles)
  %17 = load i8*, i8** @$DbFiles
; # (val $DBs)
  %18 = load i32, i32* @$DBs
; # (while (ge0 (dec 'C)) (let Db: (dbFile Db) (Db: mrks 0) (free (Db...
  br label %$10
$10:
  %19 = phi i8* [%17, %$7], [%32, %$11] ; # Db
  %20 = phi i32 [%18, %$7], [%24, %$11] ; # C
; # (dec 'C)
  %21 = sub i32 %20, 1
; # (ge0 (dec 'C))
  %22 = icmp sge i32 %21, 0
  br i1 %22, label %$11, label %$12
$11:
  %23 = phi i8* [%19, %$10] ; # Db
  %24 = phi i32 [%21, %$10] ; # C
; # (let Db: (dbFile Db) (Db: mrks 0) (free (Db: mark)) (Db: mark nul...
; # (Db: mrks 0)
  %25 = getelementptr i8, i8* %23, i32 24
  %26 = bitcast i8* %25 to i64*
  store i64 0, i64* %26
; # (Db: mark)
  %27 = getelementptr i8, i8* %23, i32 16
  %28 = bitcast i8* %27 to i8**
  %29 = load i8*, i8** %28
; # (free (Db: mark))
  call void @free(i8* %29)
; # (Db: mark null)
  %30 = getelementptr i8, i8* %23, i32 16
  %31 = bitcast i8* %30 to i8**
  store i8* null, i8** %31
; # (ofs Db (dbFile T))
  %32 = getelementptr i8, i8* %23, i32 48
  br label %$10
$12:
  %33 = phi i8* [%19, %$10] ; # Db
  %34 = phi i32 [%21, %$10] ; # C
  br label %$9
$8:
; # (unless (sym? (val (tail (needSymb Exe Y)))) (extErr Exe Y))
; # (needSymb Exe Y)
  %35 = xor i64 %15, 8
  %36 = and i64 %35, 14
  %37 = icmp eq i64 %36, 0
  br i1 %37, label %$14, label %$13
$13:
  call void @symErr(i64 %0, i64 %15)
  unreachable
$14:
; # (tail (needSymb Exe Y))
  %38 = add i64 %15, -8
; # (val (tail (needSymb Exe Y)))
  %39 = inttoptr i64 %38 to i64*
  %40 = load i64, i64* %39
; # (sym? (val (tail (needSymb Exe Y))))
  %41 = and i64 %40, 8
  %42 = icmp ne i64 %41, 0
  br i1 %42, label %$16, label %$15
$15:
; # (extErr Exe Y)
  call void @extErr(i64 %0, i64 %15)
  unreachable
$16:
; # (let (Nm (name (& (val (tail Y)) -9)) F (objFile Nm) N (objId Nm)...
; # (tail Y)
  %43 = add i64 %15, -8
; # (val (tail Y))
  %44 = inttoptr i64 %43 to i64*
  %45 = load i64, i64* %44
; # (& (val (tail Y)) -9)
  %46 = and i64 %45, -9
; # (name (& (val (tail Y)) -9))
  br label %$17
$17:
  %47 = phi i64 [%46, %$16], [%53, %$18] ; # Tail
  %48 = and i64 %47, 6
  %49 = icmp ne i64 %48, 0
  br i1 %49, label %$19, label %$18
$18:
  %50 = phi i64 [%47, %$17] ; # Tail
  %51 = inttoptr i64 %50 to i64*
  %52 = getelementptr i64, i64* %51, i32 1
  %53 = load i64, i64* %52
  br label %$17
$19:
  %54 = phi i64 [%47, %$17] ; # Tail
; # (objFile Nm)
  %55 = call i32 @objFile(i64 %54)
; # (objId Nm)
  %56 = call i64 @objId(i64 %54)
; # (if (>= F (val $DBs)) $T (let (Flg (eval (car X)) Db: (dbFile (of...
; # (val $DBs)
  %57 = load i32, i32* @$DBs
; # (>= F (val $DBs))
  %58 = icmp sge i32 %55, %57
  br i1 %58, label %$20, label %$21
$20:
  %59 = phi i64 [%56, %$19] ; # N
  br label %$22
$21:
  %60 = phi i64 [%56, %$19] ; # N
; # (let (Flg (eval (car X)) Db: (dbFile (ofs (val $DbFiles) (* F (db...
; # (car X)
  %61 = inttoptr i64 %7 to i64*
  %62 = load i64, i64* %61
; # (eval (car X))
  %63 = and i64 %62, 6
  %64 = icmp ne i64 %63, 0
  br i1 %64, label %$25, label %$24
$25:
  br label %$23
$24:
  %65 = and i64 %62, 8
  %66 = icmp ne i64 %65, 0
  br i1 %66, label %$27, label %$26
$27:
  %67 = inttoptr i64 %62 to i64*
  %68 = load i64, i64* %67
  br label %$23
$26:
  %69 = call i64 @evList(i64 %62)
  br label %$23
$23:
  %70 = phi i64 [%62, %$25], [%68, %$27], [%69, %$26] ; # ->
; # (val $DbFiles)
  %71 = load i8*, i8** @$DbFiles
; # (* F (dbFile T))
  %72 = mul i32 %55, 48
; # (ofs (val $DbFiles) (* F (dbFile T)))
  %73 = getelementptr i8, i8* %71, i32 %72
; # (Db: mark)
  %74 = getelementptr i8, i8* %73, i32 16
  %75 = bitcast i8* %74 to i8**
  %76 = load i8*, i8** %75
; # (shr N 3)
  %77 = lshr i64 %60, 3
; # (when (>= I (Db: mrks)) (let J (inc I) (memset (ofs (setq P (Db: ...
; # (Db: mrks)
  %78 = getelementptr i8, i8* %73, i32 24
  %79 = bitcast i8* %78 to i64*
  %80 = load i64, i64* %79
; # (>= I (Db: mrks))
  %81 = icmp uge i64 %77, %80
  br i1 %81, label %$28, label %$29
$28:
  %82 = phi i64 [%60, %$23] ; # N
  %83 = phi i8* [%76, %$23] ; # P
; # (let J (inc I) (memset (ofs (setq P (Db: mark (alloc P J))) (Db: ...
; # (inc I)
  %84 = add i64 %77, 1
; # (Db: mark (alloc P J))
  %85 = getelementptr i8, i8* %73, i32 16
  %86 = bitcast i8* %85 to i8**
  %87 = call i8* @alloc(i8* %83, i64 %84)
  store i8* %87, i8** %86
; # (Db: mrks)
  %88 = getelementptr i8, i8* %73, i32 24
  %89 = bitcast i8* %88 to i64*
  %90 = load i64, i64* %89
; # (ofs (setq P (Db: mark (alloc P J))) (Db: mrks))
  %91 = getelementptr i8, i8* %87, i64 %90
; # (Db: mrks)
  %92 = getelementptr i8, i8* %73, i32 24
  %93 = bitcast i8* %92 to i64*
  %94 = load i64, i64* %93
; # (- J (Db: mrks))
  %95 = sub i64 %84, %94
; # (memset (ofs (setq P (Db: mark (alloc P J))) (Db: mrks)) 0 (- J (...
  call void @llvm.memset.p0i8.i64(i8* %91, i8 0, i64 %95, i1 0)
; # (Db: mrks J)
  %96 = getelementptr i8, i8* %73, i32 24
  %97 = bitcast i8* %96 to i64*
  store i64 %84, i64* %97
  br label %$29
$29:
  %98 = phi i64 [%60, %$23], [%82, %$28] ; # N
  %99 = phi i8* [%76, %$23], [%87, %$28] ; # P
; # (ofs P I)
  %100 = getelementptr i8, i8* %99, i64 %77
; # (& N 7)
  %101 = and i64 %98, 7
; # (shl 1 (& N 7))
  %102 = shl i64 1, %101
; # (i8 (shl 1 (& N 7)))
  %103 = trunc i64 %102 to i8
; # (let B (val P) (cond ((& B N) (when (== ZERO Flg) (set P (& B (x|...
; # (val P)
  %104 = load i8, i8* %100
; # (cond ((& B N) (when (== ZERO Flg) (set P (& B (x| N -1)))) $T) (...
; # (& B N)
  %105 = and i8 %104, %103
  %106 = icmp ne i8 %105, 0
  br i1 %106, label %$32, label %$31
$32:
  %107 = phi i8 [%103, %$29] ; # N
  %108 = phi i8* [%100, %$29] ; # P
; # (when (== ZERO Flg) (set P (& B (x| N -1))))
; # (== ZERO Flg)
  %109 = icmp eq i64 2, %70
  br i1 %109, label %$33, label %$34
$33:
  %110 = phi i8 [%107, %$32] ; # N
  %111 = phi i8* [%108, %$32] ; # P
; # (set P (& B (x| N -1)))
; # (x| N -1)
  %112 = xor i8 %110, -1
; # (& B (x| N -1))
  %113 = and i8 %104, %112
  store i8 %113, i8* %111
  br label %$34
$34:
  %114 = phi i8 [%107, %$32], [%110, %$33] ; # N
  %115 = phi i8* [%108, %$32], [%111, %$33] ; # P
  br label %$30
$31:
  %116 = phi i8 [%103, %$29] ; # N
  %117 = phi i8* [%100, %$29] ; # P
; # (when (== $T Flg) (set P (| B N)))
; # (== $T Flg)
  %118 = icmp eq i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %70
  br i1 %118, label %$35, label %$36
$35:
  %119 = phi i8 [%116, %$31] ; # N
  %120 = phi i8* [%117, %$31] ; # P
; # (set P (| B N))
; # (| B N)
  %121 = or i8 %104, %119
  store i8 %121, i8* %120
  br label %$36
$36:
  %122 = phi i8 [%116, %$31], [%119, %$35] ; # N
  %123 = phi i8* [%117, %$31], [%120, %$35] ; # P
  br label %$30
$30:
  %124 = phi i8 [%114, %$34], [%122, %$36] ; # N
  %125 = phi i8* [%115, %$34], [%123, %$36] ; # P
  %126 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$34], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$36] ; # ->
  br label %$22
$22:
  %127 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$20], [%126, %$30] ; # ->
  br label %$9
$9:
  %128 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$12], [%127, %$22] ; # ->
  ret i64 %128
}

define i64 @_Free(i64) align 8 {
$1:
; # (let (X (cdr Exe) F (dec (i32 (evCnt Exe X))) Buf (b8 (* BLK 2)))...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (evCnt Exe X)
  %4 = call i64 @evCnt(i64 %0, i64 %3)
; # (i32 (evCnt Exe X))
  %5 = trunc i64 %4 to i32
; # (dec (i32 (evCnt Exe X)))
  %6 = sub i32 %5, 1
; # (* BLK 2)
; # (b8 (* BLK 2))
  %7 = alloca i8, i64 12
; # (when (>= F (val $DBs)) (dbfErr Exe))
; # (val $DBs)
  %8 = load i32, i32* @$DBs
; # (>= F (val $DBs))
  %9 = icmp sge i32 %6, %8
  br i1 %9, label %$2, label %$3
$2:
; # (dbfErr Exe)
  call void @dbfErr(i64 %0)
  unreachable
$3:
; # (set $DbFile (ofs (val $DbFiles) (* F (dbFile T))))
; # (val $DbFiles)
  %10 = load i8*, i8** @$DbFiles
; # (* F (dbFile T))
  %11 = mul i32 %6, 48
; # (ofs (val $DbFiles) (* F (dbFile T)))
  %12 = getelementptr i8, i8* %10, i32 %11
  store i8* %12, i8** @$DbFile
; # (rdLockDb)
  call void @rdLockDb()
; # (* 2 BLK)
; # (blkPeek 0 Buf (* 2 BLK))
  call void @blkPeek(i64 0, i8* %7, i32 12)
; # (set $BlkLink (getAdr Buf))
; # (getAdr Buf)
  %13 = call i64 @getAdr(i8* %7)
  store i64 %13, i64* @$BlkLink
; # (let (Y (cons (extern (extNm F (shr (getAdr (ofs Buf BLK)) 6))) $...
; # (ofs Buf BLK)
  %14 = getelementptr i8, i8* %7, i32 6
; # (getAdr (ofs Buf BLK))
  %15 = call i64 @getAdr(i8* %14)
; # (shr (getAdr (ofs Buf BLK)) 6)
  %16 = lshr i64 %15, 6
; # (extNm F (shr (getAdr (ofs Buf BLK)) 6))
  %17 = call i64 @extNm(i32 %6, i64 %16)
; # (extern (extNm F (shr (getAdr (ofs Buf BLK)) 6)))
  %18 = call i64 @extern(i64 %17)
; # (cons (extern (extNm F (shr (getAdr (ofs Buf BLK)) 6))) $Nil)
  %19 = call i64 @cons(i64 %18, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (save Y)
  %20 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %21 = load i64, i64* %20
  %22 = alloca i64, i64 2, align 16
  %23 = ptrtoint i64* %22 to i64
  %24 = inttoptr i64 %23 to i64*
  store i64 %19, i64* %24
  %25 = add i64 %23, 8
  %26 = inttoptr i64 %25 to i64*
  store i64 %21, i64* %26
  %27 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %23, i64* %27
; # (while (val $BlkLink) (setq Y (set 2 Y (cons (extern (extNm F (sh...
  br label %$4
$4:
  %28 = phi i64 [%19, %$3], [%35, %$5] ; # Y
; # (val $BlkLink)
  %29 = load i64, i64* @$BlkLink
  %30 = icmp ne i64 %29, 0
  br i1 %30, label %$5, label %$6
$5:
  %31 = phi i64 [%28, %$4] ; # Y
; # (set 2 Y (cons (extern (extNm F (shr @ 6))) $Nil))
; # (shr @ 6)
  %32 = lshr i64 %29, 6
; # (extNm F (shr @ 6))
  %33 = call i64 @extNm(i32 %6, i64 %32)
; # (extern (extNm F (shr @ 6)))
  %34 = call i64 @extern(i64 %33)
; # (cons (extern (extNm F (shr @ 6))) $Nil)
  %35 = call i64 @cons(i64 %34, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %36 = inttoptr i64 %31 to i64*
  %37 = getelementptr i64, i64* %36, i32 1
  store i64 %35, i64* %37
; # (rdBlock @)
  %38 = call i8* @rdBlock(i64 %29)
  br label %$4
$6:
  %39 = phi i64 [%28, %$4] ; # Y
; # (unLockDb 1)
  call void @unLockDb(i64 1)
; # (drop *Safe)
  %40 = inttoptr i64 %23 to i64*
  %41 = getelementptr i64, i64* %40, i32 1
  %42 = load i64, i64* %41
  %43 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %42, i64* %43
  ret i64 %19
}

define i64 @_Dbck(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (eval (car X)) Jnl (val $DbJnl) Buf (b8 (* BL...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (car X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (car X))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (val $DbJnl)
  %14 = load i8*, i8** @$DbJnl
; # (* BLK 2)
; # (b8 (* BLK 2))
  %15 = alloca i8, i64 12
; # (if (cnt? Y) (let F (dec (i32 (int Y))) (when (>= F (val $DBs)) (...
; # (cnt? Y)
  %16 = and i64 %13, 2
  %17 = icmp ne i64 %16, 0
  br i1 %17, label %$7, label %$8
$7:
  %18 = phi i64 [%13, %$2] ; # Y
  %19 = phi i64 [64, %$2] ; # Cnt
  %20 = phi i64 [0, %$2] ; # Syms
  %21 = phi i64 [0, %$2] ; # Blks
; # (let F (dec (i32 (int Y))) (when (>= F (val $DBs)) (dbfErr Exe)) ...
; # (int Y)
  %22 = lshr i64 %18, 4
; # (i32 (int Y))
  %23 = trunc i64 %22 to i32
; # (dec (i32 (int Y)))
  %24 = sub i32 %23, 1
; # (when (>= F (val $DBs)) (dbfErr Exe))
; # (val $DBs)
  %25 = load i32, i32* @$DBs
; # (>= F (val $DBs))
  %26 = icmp sge i32 %24, %25
  br i1 %26, label %$10, label %$11
$10:
  %27 = phi i64 [%18, %$7] ; # Y
  %28 = phi i64 [%19, %$7] ; # Cnt
  %29 = phi i64 [%20, %$7] ; # Syms
  %30 = phi i64 [%21, %$7] ; # Blks
; # (dbfErr Exe)
  call void @dbfErr(i64 %0)
  unreachable
$11:
  %31 = phi i64 [%18, %$7] ; # Y
  %32 = phi i64 [%19, %$7] ; # Cnt
  %33 = phi i64 [%20, %$7] ; # Syms
  %34 = phi i64 [%21, %$7] ; # Blks
; # (set $DbFile (ofs (val $DbFiles) (* F (dbFile T))))
; # (val $DbFiles)
  %35 = load i8*, i8** @$DbFiles
; # (* F (dbFile T))
  %36 = mul i32 %24, 48
; # (ofs (val $DbFiles) (* F (dbFile T)))
  %37 = getelementptr i8, i8* %35, i32 %36
  store i8* %37, i8** @$DbFile
; # (cadr X)
  %38 = inttoptr i64 %3 to i64*
  %39 = getelementptr i64, i64* %38, i32 1
  %40 = load i64, i64* %39
  %41 = inttoptr i64 %40 to i64*
  %42 = load i64, i64* %41
; # (eval (cadr X))
  %43 = and i64 %42, 6
  %44 = icmp ne i64 %43, 0
  br i1 %44, label %$14, label %$13
$14:
  br label %$12
$13:
  %45 = and i64 %42, 8
  %46 = icmp ne i64 %45, 0
  br i1 %46, label %$16, label %$15
$16:
  %47 = inttoptr i64 %42 to i64*
  %48 = load i64, i64* %47
  br label %$12
$15:
  %49 = call i64 @evList(i64 %42)
  br label %$12
$12:
  %50 = phi i64 [%42, %$14], [%48, %$16], [%49, %$15] ; # ->
  br label %$9
$8:
  %51 = phi i64 [%13, %$2] ; # Y
  %52 = phi i64 [64, %$2] ; # Cnt
  %53 = phi i64 [0, %$2] ; # Syms
  %54 = phi i64 [0, %$2] ; # Blks
; # (set $DbFile (val $DbFiles))
; # (val $DbFiles)
  %55 = load i8*, i8** @$DbFiles
  store i8* %55, i8** @$DbFile
  br label %$9
$9:
  %56 = phi i64 [%50, %$12], [%51, %$8] ; # Y
  %57 = phi i64 [%32, %$12], [%52, %$8] ; # Cnt
  %58 = phi i64 [%33, %$12], [%53, %$8] ; # Syms
  %59 = phi i64 [%34, %$12], [%54, %$8] ; # Blks
; # (set $Protect (inc (val $Protect)))
; # (val $Protect)
  %60 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 176) to i32*)
; # (inc (val $Protect))
  %61 = add i32 %60, 1
  store i32 %61, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 176) to i32*)
; # (wrLockDb)
  call void @wrLockDb()
; # (when Jnl (lockJnl) (set $DbJnl null))
  %62 = icmp ne i8* %14, null
  br i1 %62, label %$17, label %$18
$17:
  %63 = phi i64 [%56, %$9] ; # Y
  %64 = phi i64 [%57, %$9] ; # Cnt
  %65 = phi i64 [%58, %$9] ; # Syms
  %66 = phi i64 [%59, %$9] ; # Blks
; # (lockJnl)
  call void @lockJnl()
; # (set $DbJnl null)
  store i8* null, i8** @$DbJnl
  br label %$18
$18:
  %67 = phi i64 [%56, %$9], [%63, %$17] ; # Y
  %68 = phi i64 [%57, %$9], [%64, %$17] ; # Cnt
  %69 = phi i64 [%58, %$9], [%65, %$17] ; # Syms
  %70 = phi i64 [%59, %$9], [%66, %$17] ; # Blks
; # (* 2 BLK)
; # (blkPeek 0 Buf (* 2 BLK))
  call void @blkPeek(i64 0, i8* %15, i32 12)
; # (set $BlkLink (getAdr Buf))
; # (getAdr Buf)
  %71 = call i64 @getAdr(i8* %15)
  store i64 %71, i64* @$BlkLink
; # (let Next (getAdr (ofs Buf BLK)) (while (val $BlkLink) (let Blk (...
; # (ofs Buf BLK)
  %72 = getelementptr i8, i8* %15, i32 6
; # (getAdr (ofs Buf BLK))
  %73 = call i64 @getAdr(i8* %72)
; # (while (val $BlkLink) (let Blk (rdBlock @) (set Blk (| (val Blk) ...
  br label %$19
$19:
  %74 = phi i64 [%67, %$18], [%94, %$23] ; # Y
  %75 = phi i64 [%68, %$18], [%95, %$23] ; # Cnt
  %76 = phi i64 [%69, %$18], [%96, %$23] ; # Syms
  %77 = phi i64 [%70, %$18], [%97, %$23] ; # Blks
; # (val $BlkLink)
  %78 = load i64, i64* @$BlkLink
  %79 = icmp ne i64 %78, 0
  br i1 %79, label %$20, label %$21
$20:
  %80 = phi i64 [%74, %$19] ; # Y
  %81 = phi i64 [%75, %$19] ; # Cnt
  %82 = phi i64 [%76, %$19] ; # Syms
  %83 = phi i64 [%77, %$19] ; # Blks
; # (let Blk (rdBlock @) (set Blk (| (val Blk) BLKTAG)))
; # (rdBlock @)
  %84 = call i8* @rdBlock(i64 %78)
; # (set Blk (| (val Blk) BLKTAG))
; # (val Blk)
  %85 = load i8, i8* %84
; # (| (val Blk) BLKTAG)
  %86 = or i8 %85, 63
  store i8 %86, i8* %84
; # (when (> (inc 'Cnt BLKSIZE) Next) (setq Y (mkStr ($ "Circular fre...
; # (inc 'Cnt BLKSIZE)
  %87 = add i64 %81, 64
; # (> (inc 'Cnt BLKSIZE) Next)
  %88 = icmp ugt i64 %87, %73
  br i1 %88, label %$22, label %$23
$22:
  %89 = phi i64 [%80, %$20] ; # Y
  %90 = phi i64 [%87, %$20] ; # Cnt
  %91 = phi i64 [%82, %$20] ; # Syms
  %92 = phi i64 [%83, %$20] ; # Blks
; # (mkStr ($ "Circular free list"))
  %93 = call i64 @mkStr(i8* bitcast ([19 x i8]* @$68 to i8*))
; # (goto 9)
  br label %$-9
$23:
  %94 = phi i64 [%80, %$20] ; # Y
  %95 = phi i64 [%87, %$20] ; # Cnt
  %96 = phi i64 [%82, %$20] ; # Syms
  %97 = phi i64 [%83, %$20] ; # Blks
; # (wrBlock)
  call void @wrBlock()
  br label %$19
$21:
  %98 = phi i64 [%74, %$19] ; # Y
  %99 = phi i64 [%75, %$19] ; # Cnt
  %100 = phi i64 [%76, %$19] ; # Syms
  %101 = phi i64 [%77, %$19] ; # Blks
; # (set $DbJnl Jnl)
  store i8* %14, i8** @$DbJnl
; # (let P BLKSIZE (until (== P Next) (let Blk (rdBlock P) (case (& (...
; # (until (== P Next) (let Blk (rdBlock P) (case (& (val Blk) BLKTAG...
  br label %$24
$24:
  %102 = phi i64 [%98, %$21], [%182, %$27] ; # Y
  %103 = phi i64 [%99, %$21], [%183, %$27] ; # Cnt
  %104 = phi i64 [%100, %$21], [%184, %$27] ; # Syms
  %105 = phi i64 [%101, %$21], [%185, %$27] ; # Blks
  %106 = phi i64 [64, %$21], [%187, %$27] ; # P
; # (== P Next)
  %107 = icmp eq i64 %106, %73
  br i1 %107, label %$26, label %$25
$25:
  %108 = phi i64 [%102, %$24] ; # Y
  %109 = phi i64 [%103, %$24] ; # Cnt
  %110 = phi i64 [%104, %$24] ; # Syms
  %111 = phi i64 [%105, %$24] ; # Blks
  %112 = phi i64 [%106, %$24] ; # P
; # (let Blk (rdBlock P) (case (& (val Blk) BLKTAG) (0 (inc 'Cnt BLKS...
; # (rdBlock P)
  %113 = call i8* @rdBlock(i64 %112)
; # (case (& (val Blk) BLKTAG) (0 (inc 'Cnt BLKSIZE) (memcpy Blk Buf ...
; # (val Blk)
  %114 = load i8, i8* %113
; # (& (val Blk) BLKTAG)
  %115 = and i8 %114, 63
  switch i8 %115, label %$27 [
    i8 0, label %$28
    i8 1, label %$29
  ]
$28:
  %116 = phi i64 [%108, %$25] ; # Y
  %117 = phi i64 [%109, %$25] ; # Cnt
  %118 = phi i64 [%110, %$25] ; # Syms
  %119 = phi i64 [%111, %$25] ; # Blks
  %120 = phi i64 [%112, %$25] ; # P
; # (inc 'Cnt BLKSIZE)
  %121 = add i64 %117, 64
; # (memcpy Blk Buf BLK T)
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %113, i8* %15, i64 6, i1 0)
; # (wrBlock)
  call void @wrBlock()
; # (setAdr P Buf)
  call void @setAdr(i64 %120, i8* %15)
; # (blkPoke 0 Buf BLK)
  call void @blkPoke(i64 0, i8* %15, i32 6)
  br label %$27
$29:
  %122 = phi i64 [%108, %$25] ; # Y
  %123 = phi i64 [%109, %$25] ; # Cnt
  %124 = phi i64 [%110, %$25] ; # Syms
  %125 = phi i64 [%111, %$25] ; # Blks
  %126 = phi i64 [%112, %$25] ; # P
; # (inc 'Syms)
  %127 = add i64 %124, 1
; # (let I (i8 2) (loop (inc 'Blks) (inc 'Cnt BLKSIZE) (? (=0 (val $B...
; # (i8 2)
; # (loop (inc 'Blks) (inc 'Cnt BLKSIZE) (? (=0 (val $BlkLink))) (unl...
  br label %$30
$30:
  %128 = phi i64 [%122, %$29], [%169, %$36] ; # Y
  %129 = phi i64 [%123, %$29], [%170, %$36] ; # Cnt
  %130 = phi i64 [%127, %$29], [%171, %$36] ; # Syms
  %131 = phi i64 [%125, %$29], [%172, %$36] ; # Blks
  %132 = phi i64 [%126, %$29], [%173, %$36] ; # P
  %133 = phi i8 [2, %$29], [%174, %$36] ; # I
; # (inc 'Blks)
  %134 = add i64 %131, 1
; # (inc 'Cnt BLKSIZE)
  %135 = add i64 %129, 64
; # (? (=0 (val $BlkLink)))
; # (val $BlkLink)
  %136 = load i64, i64* @$BlkLink
; # (=0 (val $BlkLink))
  %137 = icmp eq i64 %136, 0
  br i1 %137, label %$32, label %$31
$31:
  %138 = phi i64 [%128, %$30] ; # Y
  %139 = phi i64 [%135, %$30] ; # Cnt
  %140 = phi i64 [%130, %$30] ; # Syms
  %141 = phi i64 [%134, %$30] ; # Blks
  %142 = phi i64 [%132, %$30] ; # P
  %143 = phi i8 [%133, %$30] ; # I
; # (unless (== I (& (val (rdBlock @)) BLKTAG)) (setq Y (mkStr ($ "Ba...
; # (rdBlock @)
  %144 = call i8* @rdBlock(i64 %136)
; # (val (rdBlock @))
  %145 = load i8, i8* %144
; # (& (val (rdBlock @)) BLKTAG)
  %146 = and i8 %145, 63
; # (== I (& (val (rdBlock @)) BLKTAG))
  %147 = icmp eq i8 %143, %146
  br i1 %147, label %$34, label %$33
$33:
  %148 = phi i64 [%138, %$31] ; # Y
  %149 = phi i64 [%139, %$31] ; # Cnt
  %150 = phi i64 [%140, %$31] ; # Syms
  %151 = phi i64 [%141, %$31] ; # Blks
  %152 = phi i64 [%142, %$31] ; # P
  %153 = phi i8 [%143, %$31] ; # I
; # (mkStr ($ "Bad chain"))
  %154 = call i64 @mkStr(i8* bitcast ([10 x i8]* @$69 to i8*))
; # (goto 9)
  br label %$-9
$34:
  %155 = phi i64 [%138, %$31] ; # Y
  %156 = phi i64 [%139, %$31] ; # Cnt
  %157 = phi i64 [%140, %$31] ; # Syms
  %158 = phi i64 [%141, %$31] ; # Blks
  %159 = phi i64 [%142, %$31] ; # P
  %160 = phi i8 [%143, %$31] ; # I
; # (when (> BLKTAG I) (inc 'I))
; # (> BLKTAG I)
  %161 = icmp ugt i8 63, %160
  br i1 %161, label %$35, label %$36
$35:
  %162 = phi i64 [%155, %$34] ; # Y
  %163 = phi i64 [%156, %$34] ; # Cnt
  %164 = phi i64 [%157, %$34] ; # Syms
  %165 = phi i64 [%158, %$34] ; # Blks
  %166 = phi i64 [%159, %$34] ; # P
  %167 = phi i8 [%160, %$34] ; # I
; # (inc 'I)
  %168 = add i8 %167, 1
  br label %$36
$36:
  %169 = phi i64 [%155, %$34], [%162, %$35] ; # Y
  %170 = phi i64 [%156, %$34], [%163, %$35] ; # Cnt
  %171 = phi i64 [%157, %$34], [%164, %$35] ; # Syms
  %172 = phi i64 [%158, %$34], [%165, %$35] ; # Blks
  %173 = phi i64 [%159, %$34], [%166, %$35] ; # P
  %174 = phi i8 [%160, %$34], [%168, %$35] ; # I
  br label %$30
$32:
  %175 = phi i64 [%128, %$30] ; # Y
  %176 = phi i64 [%135, %$30] ; # Cnt
  %177 = phi i64 [%130, %$30] ; # Syms
  %178 = phi i64 [%134, %$30] ; # Blks
  %179 = phi i64 [%132, %$30] ; # P
  %180 = phi i8 [%133, %$30] ; # I
  %181 = phi i64 [0, %$30] ; # ->
  br label %$27
$27:
  %182 = phi i64 [%108, %$25], [%116, %$28], [%175, %$32] ; # Y
  %183 = phi i64 [%109, %$25], [%121, %$28], [%176, %$32] ; # Cnt
  %184 = phi i64 [%110, %$25], [%118, %$28], [%177, %$32] ; # Syms
  %185 = phi i64 [%111, %$25], [%119, %$28], [%178, %$32] ; # Blks
  %186 = phi i64 [%112, %$25], [%120, %$28], [%179, %$32] ; # P
; # (inc 'P BLKSIZE)
  %187 = add i64 %186, 64
  br label %$24
$26:
  %188 = phi i64 [%102, %$24] ; # Y
  %189 = phi i64 [%103, %$24] ; # Cnt
  %190 = phi i64 [%104, %$24] ; # Syms
  %191 = phi i64 [%105, %$24] ; # Blks
  %192 = phi i64 [%106, %$24] ; # P
; # (set $BlkLink (getAdr Buf))
; # (getAdr Buf)
  %193 = call i64 @getAdr(i8* %15)
  store i64 %193, i64* @$BlkLink
; # (set $DbJnl null)
  store i8* null, i8** @$DbJnl
; # (while (val $BlkLink) (let Blk (rdBlock @) (when (& (val Blk) BLK...
  br label %$37
$37:
  %194 = phi i64 [%188, %$26], [%214, %$41] ; # Y
  %195 = phi i64 [%189, %$26], [%215, %$41] ; # Cnt
  %196 = phi i64 [%190, %$26], [%216, %$41] ; # Syms
  %197 = phi i64 [%191, %$26], [%217, %$41] ; # Blks
; # (val $BlkLink)
  %198 = load i64, i64* @$BlkLink
  %199 = icmp ne i64 %198, 0
  br i1 %199, label %$38, label %$39
$38:
  %200 = phi i64 [%194, %$37] ; # Y
  %201 = phi i64 [%195, %$37] ; # Cnt
  %202 = phi i64 [%196, %$37] ; # Syms
  %203 = phi i64 [%197, %$37] ; # Blks
; # (let Blk (rdBlock @) (when (& (val Blk) BLKTAG) (set Blk (& (val ...
; # (rdBlock @)
  %204 = call i8* @rdBlock(i64 %198)
; # (when (& (val Blk) BLKTAG) (set Blk (& (val Blk) BLKMASK)) (wrBlo...
; # (val Blk)
  %205 = load i8, i8* %204
; # (& (val Blk) BLKTAG)
  %206 = and i8 %205, 63
  %207 = icmp ne i8 %206, 0
  br i1 %207, label %$40, label %$41
$40:
  %208 = phi i64 [%200, %$38] ; # Y
  %209 = phi i64 [%201, %$38] ; # Cnt
  %210 = phi i64 [%202, %$38] ; # Syms
  %211 = phi i64 [%203, %$38] ; # Blks
; # (set Blk (& (val Blk) BLKMASK))
; # (val Blk)
  %212 = load i8, i8* %204
; # (& (val Blk) BLKMASK)
  %213 = and i8 %212, -64
  store i8 %213, i8* %204
; # (wrBlock)
  call void @wrBlock()
  br label %$41
$41:
  %214 = phi i64 [%200, %$38], [%208, %$40] ; # Y
  %215 = phi i64 [%201, %$38], [%209, %$40] ; # Cnt
  %216 = phi i64 [%202, %$38], [%210, %$40] ; # Syms
  %217 = phi i64 [%203, %$38], [%211, %$40] ; # Blks
  br label %$37
$39:
  %218 = phi i64 [%194, %$37] ; # Y
  %219 = phi i64 [%195, %$37] ; # Cnt
  %220 = phi i64 [%196, %$37] ; # Syms
  %221 = phi i64 [%197, %$37] ; # Blks
; # (nond ((== Cnt Next) (setq Y (mkStr ($ "Bad count")))) ((nil? Y) ...
; # (== Cnt Next)
  %222 = icmp eq i64 %219, %73
  br i1 %222, label %$43, label %$44
$44:
  %223 = phi i64 [%218, %$39] ; # Y
  %224 = phi i64 [%219, %$39] ; # Cnt
  %225 = phi i64 [%220, %$39] ; # Syms
  %226 = phi i64 [%221, %$39] ; # Blks
; # (mkStr ($ "Bad count"))
  %227 = call i64 @mkStr(i8* bitcast ([10 x i8]* @$70 to i8*))
  br label %$42
$43:
  %228 = phi i64 [%218, %$39] ; # Y
  %229 = phi i64 [%219, %$39] ; # Cnt
  %230 = phi i64 [%220, %$39] ; # Syms
  %231 = phi i64 [%221, %$39] ; # Blks
; # (nil? Y)
  %232 = icmp eq i64 %228, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %232, label %$45, label %$46
$46:
  %233 = phi i64 [%228, %$43] ; # Y
  %234 = phi i64 [%229, %$43] ; # Cnt
  %235 = phi i64 [%230, %$43] ; # Syms
  %236 = phi i64 [%231, %$43] ; # Blks
; # (cnt Blks)
  %237 = shl i64 %236, 4
  %238 = or i64 %237, 2
; # (cnt Syms)
  %239 = shl i64 %235, 4
  %240 = or i64 %239, 2
; # (cons (cnt Blks) (cnt Syms))
  %241 = call i64 @cons(i64 %238, i64 %240)
  br label %$42
$45:
  %242 = phi i64 [%228, %$43] ; # Y
  %243 = phi i64 [%229, %$43] ; # Cnt
  %244 = phi i64 [%230, %$43] ; # Syms
  %245 = phi i64 [%231, %$43] ; # Blks
  br label %$42
$42:
  %246 = phi i64 [%227, %$44], [%241, %$46], [%242, %$45] ; # Y
  %247 = phi i64 [%224, %$44], [%234, %$46], [%243, %$45] ; # Cnt
  %248 = phi i64 [%225, %$44], [%235, %$46], [%244, %$45] ; # Syms
  %249 = phi i64 [%226, %$44], [%236, %$46], [%245, %$45] ; # Blks
  %250 = phi i64 [%227, %$44], [%241, %$46], [0, %$45] ; # ->
; # (: 9 (when (set $DbJnl Jnl) (unLockJnl)) (unLockDb 1) (set $Prote...
  br label %$-9
$-9:
  %251 = phi i64 [%93, %$22], [%154, %$33], [%246, %$42] ; # Y
  %252 = phi i64 [%90, %$22], [%149, %$33], [%247, %$42] ; # Cnt
  %253 = phi i64 [%91, %$22], [%150, %$33], [%248, %$42] ; # Syms
  %254 = phi i64 [%92, %$22], [%151, %$33], [%249, %$42] ; # Blks
; # (when (set $DbJnl Jnl) (unLockJnl))
; # (set $DbJnl Jnl)
  store i8* %14, i8** @$DbJnl
  %255 = icmp ne i8* %14, null
  br i1 %255, label %$47, label %$48
$47:
  %256 = phi i64 [%251, %$-9] ; # Y
  %257 = phi i64 [%252, %$-9] ; # Cnt
  %258 = phi i64 [%253, %$-9] ; # Syms
  %259 = phi i64 [%254, %$-9] ; # Blks
; # (unLockJnl)
  call void @unLockJnl()
  br label %$48
$48:
  %260 = phi i64 [%251, %$-9], [%256, %$47] ; # Y
  %261 = phi i64 [%252, %$-9], [%257, %$47] ; # Cnt
  %262 = phi i64 [%253, %$-9], [%258, %$47] ; # Syms
  %263 = phi i64 [%254, %$-9], [%259, %$47] ; # Blks
; # (unLockDb 1)
  call void @unLockDb(i64 1)
; # (set $Protect (dec (val $Protect)))
; # (val $Protect)
  %264 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 176) to i32*)
; # (dec (val $Protect))
  %265 = sub i32 %264, 1
  store i32 %265, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 176) to i32*)
  ret i64 %260
}

define i64 @_Apply(i64) align 8 {
$1:
; # (let (X (cdr Exe) E (push NIL $Nil ZERO (eval (++ X)) NIL)) (set ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (push NIL $Nil ZERO (eval (++ X)) NIL)
  %16 = alloca i64, i64 5, align 16
  %17 = ptrtoint i64* %16 to i64
  %18 = add i64 %17, 8
  %19 = inttoptr i64 %18 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %19
  %20 = add i64 %17, 16
  %21 = inttoptr i64 %20 to i64*
  store i64 2, i64* %21
  %22 = add i64 %17, 24
  %23 = inttoptr i64 %22 to i64*
  store i64 %15, i64* %23
; # (set E (link (ofs E 3) T))
; # (ofs E 3)
  %24 = add i64 %17, 24
; # (link (ofs E 3) T)
  %25 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %26 = load i64, i64* %25
  %27 = inttoptr i64 %24 to i64*
  %28 = getelementptr i64, i64* %27, i32 1
  store i64 %26, i64* %28
  %29 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %24, i64* %29
  %30 = inttoptr i64 %17 to i64*
  store i64 %24, i64* %30
; # (let (L (save (eval (car X))) P E) (while (pair (shift X)) (setq ...
; # (car X)
  %31 = inttoptr i64 %7 to i64*
  %32 = load i64, i64* %31
; # (eval (car X))
  %33 = and i64 %32, 6
  %34 = icmp ne i64 %33, 0
  br i1 %34, label %$9, label %$8
$9:
  br label %$7
$8:
  %35 = and i64 %32, 8
  %36 = icmp ne i64 %35, 0
  br i1 %36, label %$11, label %$10
$11:
  %37 = inttoptr i64 %32 to i64*
  %38 = load i64, i64* %37
  br label %$7
$10:
  %39 = call i64 @evList(i64 %32)
  br label %$7
$7:
  %40 = phi i64 [%32, %$9], [%38, %$11], [%39, %$10] ; # ->
; # (save (eval (car X)))
  %41 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %42 = load i64, i64* %41
  %43 = alloca i64, i64 2, align 16
  %44 = ptrtoint i64* %43 to i64
  %45 = inttoptr i64 %44 to i64*
  store i64 %40, i64* %45
  %46 = add i64 %44, 8
  %47 = inttoptr i64 %46 to i64*
  store i64 %42, i64* %47
  %48 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %44, i64* %48
; # (while (pair (shift X)) (setq P (set 2 P (push NIL $Nil ZERO (eva...
  br label %$12
$12:
  %49 = phi i64 [%7, %$7], [%57, %$15] ; # X
  %50 = phi i64 [%40, %$7], [%58, %$15] ; # L
  %51 = phi i64 [%17, %$7], [%71, %$15] ; # P
; # (shift X)
  %52 = inttoptr i64 %49 to i64*
  %53 = getelementptr i64, i64* %52, i32 1
  %54 = load i64, i64* %53
; # (pair (shift X))
  %55 = and i64 %54, 15
  %56 = icmp eq i64 %55, 0
  br i1 %56, label %$13, label %$14
$13:
  %57 = phi i64 [%54, %$12] ; # X
  %58 = phi i64 [%50, %$12] ; # L
  %59 = phi i64 [%51, %$12] ; # P
; # (set 2 P (push NIL $Nil ZERO (eval (car X)) NIL))
; # (car X)
  %60 = inttoptr i64 %57 to i64*
  %61 = load i64, i64* %60
; # (eval (car X))
  %62 = and i64 %61, 6
  %63 = icmp ne i64 %62, 0
  br i1 %63, label %$17, label %$16
$17:
  br label %$15
$16:
  %64 = and i64 %61, 8
  %65 = icmp ne i64 %64, 0
  br i1 %65, label %$19, label %$18
$19:
  %66 = inttoptr i64 %61 to i64*
  %67 = load i64, i64* %66
  br label %$15
$18:
  %68 = call i64 @evList(i64 %61)
  br label %$15
$15:
  %69 = phi i64 [%61, %$17], [%67, %$19], [%68, %$18] ; # ->
; # (push NIL $Nil ZERO (eval (car X)) NIL)
  %70 = alloca i64, i64 5, align 16
  %71 = ptrtoint i64* %70 to i64
  %72 = add i64 %71, 8
  %73 = inttoptr i64 %72 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %73
  %74 = add i64 %71, 16
  %75 = inttoptr i64 %74 to i64*
  store i64 2, i64* %75
  %76 = add i64 %71, 24
  %77 = inttoptr i64 %76 to i64*
  store i64 %69, i64* %77
  %78 = inttoptr i64 %59 to i64*
  %79 = getelementptr i64, i64* %78, i32 1
  store i64 %71, i64* %79
; # (set P (link (ofs P 3)))
; # (ofs P 3)
  %80 = add i64 %71, 24
; # (link (ofs P 3))
  %81 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %82 = load i64, i64* %81
  %83 = inttoptr i64 %80 to i64*
  %84 = getelementptr i64, i64* %83, i32 1
  store i64 %82, i64* %84
  %85 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %80, i64* %85
  %86 = inttoptr i64 %71 to i64*
  store i64 %80, i64* %86
  br label %$12
$14:
  %87 = phi i64 [%54, %$12] ; # X
  %88 = phi i64 [%50, %$12] ; # L
  %89 = phi i64 [%51, %$12] ; # P
; # (while (pair L) (stkChk Exe) (setq P (set 2 P (push NIL $Nil ZERO...
  br label %$20
$20:
  %90 = phi i64 [%87, %$14], [%95, %$24] ; # X
  %91 = phi i64 [%88, %$14], [%104, %$24] ; # L
  %92 = phi i64 [%89, %$14], [%106, %$24] ; # P
; # (pair L)
  %93 = and i64 %91, 15
  %94 = icmp eq i64 %93, 0
  br i1 %94, label %$21, label %$22
$21:
  %95 = phi i64 [%90, %$20] ; # X
  %96 = phi i64 [%91, %$20] ; # L
  %97 = phi i64 [%92, %$20] ; # P
; # (stkChk Exe)
  %98 = load i8*, i8** @$StkLimit
  %99 = call i8* @llvm.stacksave()
  %100 = icmp ugt i8* %98, %99
  br i1 %100, label %$23, label %$24
$23:
  call void @stkErr(i64 %0)
  unreachable
$24:
; # (set 2 P (push NIL $Nil ZERO (++ L) NIL))
; # (++ L)
  %101 = inttoptr i64 %96 to i64*
  %102 = load i64, i64* %101
  %103 = getelementptr i64, i64* %101, i32 1
  %104 = load i64, i64* %103
; # (push NIL $Nil ZERO (++ L) NIL)
  %105 = alloca i64, i64 5, align 16
  %106 = ptrtoint i64* %105 to i64
  %107 = add i64 %106, 8
  %108 = inttoptr i64 %107 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %108
  %109 = add i64 %106, 16
  %110 = inttoptr i64 %109 to i64*
  store i64 2, i64* %110
  %111 = add i64 %106, 24
  %112 = inttoptr i64 %111 to i64*
  store i64 %102, i64* %112
  %113 = inttoptr i64 %97 to i64*
  %114 = getelementptr i64, i64* %113, i32 1
  store i64 %106, i64* %114
; # (set P (link (ofs P 3)))
; # (ofs P 3)
  %115 = add i64 %106, 24
; # (link (ofs P 3))
  %116 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %117 = load i64, i64* %116
  %118 = inttoptr i64 %115 to i64*
  %119 = getelementptr i64, i64* %118, i32 1
  store i64 %117, i64* %119
  %120 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %115, i64* %120
  %121 = inttoptr i64 %106 to i64*
  store i64 %115, i64* %121
  br label %$20
$22:
  %122 = phi i64 [%90, %$20] ; # X
  %123 = phi i64 [%91, %$20] ; # L
  %124 = phi i64 [%92, %$20] ; # P
; # (evList E)
  %125 = call i64 @evList(i64 %17)
; # (drop *Safe)
  %126 = inttoptr i64 %24 to i64*
  %127 = getelementptr i64, i64* %126, i32 1
  %128 = load i64, i64* %127
  %129 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %128, i64* %129
  ret i64 %125
}

define i64 @_Pass(i64) align 8 {
$1:
; # (let (X (cdr Exe) E (push NIL $Nil ZERO (eval (++ X)) NIL)) (set ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (push NIL $Nil ZERO (eval (++ X)) NIL)
  %16 = alloca i64, i64 5, align 16
  %17 = ptrtoint i64* %16 to i64
  %18 = add i64 %17, 8
  %19 = inttoptr i64 %18 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %19
  %20 = add i64 %17, 16
  %21 = inttoptr i64 %20 to i64*
  store i64 2, i64* %21
  %22 = add i64 %17, 24
  %23 = inttoptr i64 %22 to i64*
  store i64 %15, i64* %23
; # (set E (link (ofs E 3) T))
; # (ofs E 3)
  %24 = add i64 %17, 24
; # (link (ofs E 3) T)
  %25 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %26 = load i64, i64* %25
  %27 = inttoptr i64 %24 to i64*
  %28 = getelementptr i64, i64* %27, i32 1
  store i64 %26, i64* %28
  %29 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %24, i64* %29
  %30 = inttoptr i64 %17 to i64*
  store i64 %24, i64* %30
; # (let P E (while (pair X) (setq P (set 2 P (push NIL $Nil ZERO (ev...
; # (while (pair X) (setq P (set 2 P (push NIL $Nil ZERO (eval (++ X)...
  br label %$7
$7:
  %31 = phi i64 [%7, %$2], [%40, %$10] ; # X
  %32 = phi i64 [%17, %$2], [%50, %$10] ; # P
; # (pair X)
  %33 = and i64 %31, 15
  %34 = icmp eq i64 %33, 0
  br i1 %34, label %$8, label %$9
$8:
  %35 = phi i64 [%31, %$7] ; # X
  %36 = phi i64 [%32, %$7] ; # P
; # (set 2 P (push NIL $Nil ZERO (eval (++ X)) NIL))
; # (++ X)
  %37 = inttoptr i64 %35 to i64*
  %38 = load i64, i64* %37
  %39 = getelementptr i64, i64* %37, i32 1
  %40 = load i64, i64* %39
; # (eval (++ X))
  %41 = and i64 %38, 6
  %42 = icmp ne i64 %41, 0
  br i1 %42, label %$12, label %$11
$12:
  br label %$10
$11:
  %43 = and i64 %38, 8
  %44 = icmp ne i64 %43, 0
  br i1 %44, label %$14, label %$13
$14:
  %45 = inttoptr i64 %38 to i64*
  %46 = load i64, i64* %45
  br label %$10
$13:
  %47 = call i64 @evList(i64 %38)
  br label %$10
$10:
  %48 = phi i64 [%38, %$12], [%46, %$14], [%47, %$13] ; # ->
; # (push NIL $Nil ZERO (eval (++ X)) NIL)
  %49 = alloca i64, i64 5, align 16
  %50 = ptrtoint i64* %49 to i64
  %51 = add i64 %50, 8
  %52 = inttoptr i64 %51 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %52
  %53 = add i64 %50, 16
  %54 = inttoptr i64 %53 to i64*
  store i64 2, i64* %54
  %55 = add i64 %50, 24
  %56 = inttoptr i64 %55 to i64*
  store i64 %48, i64* %56
  %57 = inttoptr i64 %36 to i64*
  %58 = getelementptr i64, i64* %57, i32 1
  store i64 %50, i64* %58
; # (set P (link (ofs P 3)))
; # (ofs P 3)
  %59 = add i64 %50, 24
; # (link (ofs P 3))
  %60 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %61 = load i64, i64* %60
  %62 = inttoptr i64 %59 to i64*
  %63 = getelementptr i64, i64* %62, i32 1
  store i64 %61, i64* %63
  %64 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %59, i64* %64
  %65 = inttoptr i64 %50 to i64*
  store i64 %59, i64* %65
  br label %$7
$9:
  %66 = phi i64 [%31, %$7] ; # X
  %67 = phi i64 [%32, %$7] ; # P
; # (let L (val $Next) (while (pair L) (setq P (set 2 P (push NIL $Ni...
; # (val $Next)
  %68 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 128) to i64) to i64*
  %69 = load i64, i64* %68
; # (while (pair L) (setq P (set 2 P (push NIL $Nil ZERO (cdr L) NIL)...
  br label %$15
$15:
  %70 = phi i64 [%66, %$9], [%75, %$16] ; # X
  %71 = phi i64 [%67, %$9], [%82, %$16] ; # P
  %72 = phi i64 [%69, %$9], [%99, %$16] ; # L
; # (pair L)
  %73 = and i64 %72, 15
  %74 = icmp eq i64 %73, 0
  br i1 %74, label %$16, label %$17
$16:
  %75 = phi i64 [%70, %$15] ; # X
  %76 = phi i64 [%71, %$15] ; # P
  %77 = phi i64 [%72, %$15] ; # L
; # (set 2 P (push NIL $Nil ZERO (cdr L) NIL))
; # (cdr L)
  %78 = inttoptr i64 %77 to i64*
  %79 = getelementptr i64, i64* %78, i32 1
  %80 = load i64, i64* %79
; # (push NIL $Nil ZERO (cdr L) NIL)
  %81 = alloca i64, i64 5, align 16
  %82 = ptrtoint i64* %81 to i64
  %83 = add i64 %82, 8
  %84 = inttoptr i64 %83 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %84
  %85 = add i64 %82, 16
  %86 = inttoptr i64 %85 to i64*
  store i64 2, i64* %86
  %87 = add i64 %82, 24
  %88 = inttoptr i64 %87 to i64*
  store i64 %80, i64* %88
  %89 = inttoptr i64 %76 to i64*
  %90 = getelementptr i64, i64* %89, i32 1
  store i64 %82, i64* %90
; # (set P (link (ofs P 3)))
; # (ofs P 3)
  %91 = add i64 %82, 24
; # (link (ofs P 3))
  %92 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %93 = load i64, i64* %92
  %94 = inttoptr i64 %91 to i64*
  %95 = getelementptr i64, i64* %94, i32 1
  store i64 %93, i64* %95
  %96 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %91, i64* %96
  %97 = inttoptr i64 %82 to i64*
  store i64 %91, i64* %97
; # (car L)
  %98 = inttoptr i64 %77 to i64*
  %99 = load i64, i64* %98
  br label %$15
$17:
  %100 = phi i64 [%70, %$15] ; # X
  %101 = phi i64 [%71, %$15] ; # P
  %102 = phi i64 [%72, %$15] ; # L
; # (evList E)
  %103 = call i64 @evList(i64 %17)
; # (drop *Safe)
  %104 = inttoptr i64 %24 to i64*
  %105 = getelementptr i64, i64* %104, i32 1
  %106 = load i64, i64* %105
  %107 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %106, i64* %107
  ret i64 %103
}

define i64 @_Fun(i64) align 8 {
$1:
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (evList (cdr Exe))
  %4 = call i64 @evList(i64 %3)
  ret i64 %4
}

define i64 @_Maps(i64) align 8 {
$1:
; # (let (X (cdr Exe) R $Nil E (push NIL $Nil ZERO (eval (++ X)) NIL)...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (push NIL $Nil ZERO (eval (++ X)) NIL)
  %16 = alloca i64, i64 5, align 16
  %17 = ptrtoint i64* %16 to i64
  %18 = add i64 %17, 8
  %19 = inttoptr i64 %18 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %19
  %20 = add i64 %17, 16
  %21 = inttoptr i64 %20 to i64*
  store i64 2, i64* %21
  %22 = add i64 %17, 24
  %23 = inttoptr i64 %22 to i64*
  store i64 %15, i64* %23
; # (push NIL NIL)
  %24 = alloca i64, i64 2, align 16
  %25 = ptrtoint i64* %24 to i64
; # (set E (link (ofs E 3) T))
; # (ofs E 3)
  %26 = add i64 %17, 24
; # (link (ofs E 3) T)
  %27 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %28 = load i64, i64* %27
  %29 = inttoptr i64 %26 to i64*
  %30 = getelementptr i64, i64* %29, i32 1
  store i64 %28, i64* %30
  %31 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %26, i64* %31
  %32 = inttoptr i64 %17 to i64*
  store i64 %26, i64* %32
; # (let (P E Q A Sym (save (needSymb Exe (eval (car X)))) V Sym) (se...
; # (car X)
  %33 = inttoptr i64 %7 to i64*
  %34 = load i64, i64* %33
; # (eval (car X))
  %35 = and i64 %34, 6
  %36 = icmp ne i64 %35, 0
  br i1 %36, label %$9, label %$8
$9:
  br label %$7
$8:
  %37 = and i64 %34, 8
  %38 = icmp ne i64 %37, 0
  br i1 %38, label %$11, label %$10
$11:
  %39 = inttoptr i64 %34 to i64*
  %40 = load i64, i64* %39
  br label %$7
$10:
  %41 = call i64 @evList(i64 %34)
  br label %$7
$7:
  %42 = phi i64 [%34, %$9], [%40, %$11], [%41, %$10] ; # ->
; # (needSymb Exe (eval (car X)))
  %43 = xor i64 %42, 8
  %44 = and i64 %43, 14
  %45 = icmp eq i64 %44, 0
  br i1 %45, label %$13, label %$12
$12:
  call void @symErr(i64 %0, i64 %42)
  unreachable
$13:
; # (save (needSymb Exe (eval (car X))))
  %46 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %47 = load i64, i64* %46
  %48 = alloca i64, i64 2, align 16
  %49 = ptrtoint i64* %48 to i64
  %50 = inttoptr i64 %49 to i64*
  store i64 %42, i64* %50
  %51 = add i64 %49, 8
  %52 = inttoptr i64 %51 to i64*
  store i64 %47, i64* %52
  %53 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %49, i64* %53
; # (set Q V)
  %54 = inttoptr i64 %25 to i64*
  store i64 %42, i64* %54
; # (loop (setq P (set 2 P (push NIL $Nil ZERO V NIL))) (set P (link ...
  br label %$14
$14:
  %55 = phi i64 [%7, %$13], [%119, %$23] ; # X
  %56 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$13], [%120, %$23] ; # R
  %57 = phi i64 [%17, %$13], [%121, %$23] ; # P
  %58 = phi i64 [%25, %$13], [%122, %$23] ; # Q
  %59 = phi i64 [%42, %$13], [%123, %$23] ; # V
; # (set 2 P (push NIL $Nil ZERO V NIL))
; # (push NIL $Nil ZERO V NIL)
  %60 = alloca i64, i64 5, align 16
  %61 = ptrtoint i64* %60 to i64
  %62 = add i64 %61, 8
  %63 = inttoptr i64 %62 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %63
  %64 = add i64 %61, 16
  %65 = inttoptr i64 %64 to i64*
  store i64 2, i64* %65
  %66 = add i64 %61, 24
  %67 = inttoptr i64 %66 to i64*
  store i64 %59, i64* %67
  %68 = inttoptr i64 %57 to i64*
  %69 = getelementptr i64, i64* %68, i32 1
  store i64 %61, i64* %69
; # (set P (link (ofs P 3)))
; # (ofs P 3)
  %70 = add i64 %61, 24
; # (link (ofs P 3))
  %71 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %72 = load i64, i64* %71
  %73 = inttoptr i64 %70 to i64*
  %74 = getelementptr i64, i64* %73, i32 1
  store i64 %72, i64* %74
  %75 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %70, i64* %75
  %76 = inttoptr i64 %61 to i64*
  store i64 %70, i64* %76
; # (? (atom (shift X)))
; # (shift X)
  %77 = inttoptr i64 %55 to i64*
  %78 = getelementptr i64, i64* %77, i32 1
  %79 = load i64, i64* %78
; # (atom (shift X))
  %80 = and i64 %79, 15
  %81 = icmp ne i64 %80, 0
  br i1 %81, label %$16, label %$15
$15:
  %82 = phi i64 [%79, %$14] ; # X
  %83 = phi i64 [%56, %$14] ; # R
  %84 = phi i64 [%61, %$14] ; # P
  %85 = phi i64 [%58, %$14] ; # Q
  %86 = phi i64 [%59, %$14] ; # V
; # (set 2 Q (push NIL NIL))
; # (push NIL NIL)
  %87 = alloca i64, i64 2, align 16
  %88 = ptrtoint i64* %87 to i64
  %89 = inttoptr i64 %85 to i64*
  %90 = getelementptr i64, i64* %89, i32 1
  store i64 %88, i64* %90
; # (car X)
  %91 = inttoptr i64 %82 to i64*
  %92 = load i64, i64* %91
; # (eval (car X))
  %93 = and i64 %92, 6
  %94 = icmp ne i64 %93, 0
  br i1 %94, label %$19, label %$18
$19:
  br label %$17
$18:
  %95 = and i64 %92, 8
  %96 = icmp ne i64 %95, 0
  br i1 %96, label %$21, label %$20
$21:
  %97 = inttoptr i64 %92 to i64*
  %98 = load i64, i64* %97
  br label %$17
$20:
  %99 = call i64 @evList(i64 %92)
  br label %$17
$17:
  %100 = phi i64 [%92, %$19], [%98, %$21], [%99, %$20] ; # ->
; # (save (eval (car X)))
  %101 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %102 = load i64, i64* %101
  %103 = alloca i64, i64 2, align 16
  %104 = ptrtoint i64* %103 to i64
  %105 = inttoptr i64 %104 to i64*
  store i64 %100, i64* %105
  %106 = add i64 %104, 8
  %107 = inttoptr i64 %106 to i64*
  store i64 %102, i64* %107
  %108 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %104, i64* %108
; # (set Q V)
  %109 = inttoptr i64 %88 to i64*
  store i64 %100, i64* %109
; # (when (pair V) (setq V (car V)))
; # (pair V)
  %110 = and i64 %100, 15
  %111 = icmp eq i64 %110, 0
  br i1 %111, label %$22, label %$23
$22:
  %112 = phi i64 [%82, %$17] ; # X
  %113 = phi i64 [%83, %$17] ; # R
  %114 = phi i64 [%84, %$17] ; # P
  %115 = phi i64 [%88, %$17] ; # Q
  %116 = phi i64 [%100, %$17] ; # V
; # (car V)
  %117 = inttoptr i64 %116 to i64*
  %118 = load i64, i64* %117
  br label %$23
$23:
  %119 = phi i64 [%82, %$17], [%112, %$22] ; # X
  %120 = phi i64 [%83, %$17], [%113, %$22] ; # R
  %121 = phi i64 [%84, %$17], [%114, %$22] ; # P
  %122 = phi i64 [%88, %$17], [%115, %$22] ; # Q
  %123 = phi i64 [%100, %$17], [%118, %$22] ; # V
  br label %$14
$16:
  %124 = phi i64 [%79, %$14] ; # X
  %125 = phi i64 [%56, %$14] ; # R
  %126 = phi i64 [%61, %$14] ; # P
  %127 = phi i64 [%58, %$14] ; # Q
  %128 = phi i64 [%59, %$14] ; # V
  %129 = phi i64 [0, %$14] ; # ->
; # (when (sym? (setq V (val (tail Sym)))) (dbFetch Exe Sym) (setq V ...
; # (tail Sym)
  %130 = add i64 %42, -8
; # (val (tail Sym))
  %131 = inttoptr i64 %130 to i64*
  %132 = load i64, i64* %131
; # (sym? (setq V (val (tail Sym))))
  %133 = and i64 %132, 8
  %134 = icmp ne i64 %133, 0
  br i1 %134, label %$24, label %$25
$24:
  %135 = phi i64 [%124, %$16] ; # X
  %136 = phi i64 [%125, %$16] ; # R
  %137 = phi i64 [%126, %$16] ; # P
  %138 = phi i64 [%127, %$16] ; # Q
  %139 = phi i64 [%132, %$16] ; # V
; # (dbFetch Exe Sym)
  call void @dbFetch(i64 %0, i64 %42)
; # (tail Sym)
  %140 = add i64 %42, -8
; # (val (tail Sym))
  %141 = inttoptr i64 %140 to i64*
  %142 = load i64, i64* %141
; # (& (val (tail Sym)) -9)
  %143 = and i64 %142, -9
  br label %$25
$25:
  %144 = phi i64 [%124, %$16], [%135, %$24] ; # X
  %145 = phi i64 [%125, %$16], [%136, %$24] ; # R
  %146 = phi i64 [%126, %$16], [%137, %$24] ; # P
  %147 = phi i64 [%127, %$16], [%138, %$24] ; # Q
  %148 = phi i64 [%132, %$16], [%143, %$24] ; # V
; # (set 4 (cdr E) (if (pair V) (car V) V))
; # (cdr E)
  %149 = inttoptr i64 %17 to i64*
  %150 = getelementptr i64, i64* %149, i32 1
  %151 = load i64, i64* %150
; # (if (pair V) (car V) V)
; # (pair V)
  %152 = and i64 %148, 15
  %153 = icmp eq i64 %152, 0
  br i1 %153, label %$26, label %$27
$26:
  %154 = phi i64 [%144, %$25] ; # X
  %155 = phi i64 [%145, %$25] ; # R
  %156 = phi i64 [%146, %$25] ; # P
  %157 = phi i64 [%147, %$25] ; # Q
  %158 = phi i64 [%148, %$25] ; # V
; # (car V)
  %159 = inttoptr i64 %158 to i64*
  %160 = load i64, i64* %159
  br label %$28
$27:
  %161 = phi i64 [%144, %$25] ; # X
  %162 = phi i64 [%145, %$25] ; # R
  %163 = phi i64 [%146, %$25] ; # P
  %164 = phi i64 [%147, %$25] ; # Q
  %165 = phi i64 [%148, %$25] ; # V
  br label %$28
$28:
  %166 = phi i64 [%154, %$26], [%161, %$27] ; # X
  %167 = phi i64 [%155, %$26], [%162, %$27] ; # R
  %168 = phi i64 [%156, %$26], [%163, %$27] ; # P
  %169 = phi i64 [%157, %$26], [%164, %$27] ; # Q
  %170 = phi i64 [%158, %$26], [%165, %$27] ; # V
  %171 = phi i64 [%160, %$26], [%165, %$27] ; # ->
  %172 = inttoptr i64 %151 to i64*
  %173 = getelementptr i64, i64* %172, i32 3
  store i64 %171, i64* %173
; # (set A V)
  %174 = inttoptr i64 %25 to i64*
  store i64 %170, i64* %174
; # (when (pair (car A)) (loop (setq R (evList E)) (? (atom (set A (c...
; # (car A)
  %175 = inttoptr i64 %25 to i64*
  %176 = load i64, i64* %175
; # (pair (car A))
  %177 = and i64 %176, 15
  %178 = icmp eq i64 %177, 0
  br i1 %178, label %$29, label %$30
$29:
  %179 = phi i64 [%166, %$28] ; # X
  %180 = phi i64 [%167, %$28] ; # R
; # (loop (setq R (evList E)) (? (atom (set A (cdar A)))) (let (P (cd...
  br label %$31
$31:
  %181 = phi i64 [%179, %$29], [%252, %$36] ; # X
  %182 = phi i64 [%180, %$29], [%253, %$36] ; # R
; # (evList E)
  %183 = call i64 @evList(i64 %17)
; # (? (atom (set A (cdar A))))
; # (set A (cdar A))
; # (cdar A)
  %184 = inttoptr i64 %25 to i64*
  %185 = load i64, i64* %184
  %186 = inttoptr i64 %185 to i64*
  %187 = getelementptr i64, i64* %186, i32 1
  %188 = load i64, i64* %187
  %189 = inttoptr i64 %25 to i64*
  store i64 %188, i64* %189
; # (atom (set A (cdar A)))
  %190 = and i64 %188, 15
  %191 = icmp ne i64 %190, 0
  br i1 %191, label %$33, label %$32
$32:
  %192 = phi i64 [%181, %$31] ; # X
  %193 = phi i64 [%183, %$31] ; # R
; # (let (P (cdr E) Q A) (set 4 P (car @)) (while (pair (shift P)) (s...
; # (cdr E)
  %194 = inttoptr i64 %17 to i64*
  %195 = getelementptr i64, i64* %194, i32 1
  %196 = load i64, i64* %195
; # (set 4 P (car @))
; # (car @)
  %197 = inttoptr i64 %188 to i64*
  %198 = load i64, i64* %197
  %199 = inttoptr i64 %196 to i64*
  %200 = getelementptr i64, i64* %199, i32 3
  store i64 %198, i64* %200
; # (while (pair (shift P)) (set 4 P (cond ((atom (car (shift Q))) @)...
  br label %$34
$34:
  %201 = phi i64 [%192, %$32], [%245, %$37] ; # X
  %202 = phi i64 [%193, %$32], [%246, %$37] ; # R
  %203 = phi i64 [%196, %$32], [%247, %$37] ; # P
  %204 = phi i64 [%25, %$32], [%248, %$37] ; # Q
; # (shift P)
  %205 = inttoptr i64 %203 to i64*
  %206 = getelementptr i64, i64* %205, i32 1
  %207 = load i64, i64* %206
; # (pair (shift P))
  %208 = and i64 %207, 15
  %209 = icmp eq i64 %208, 0
  br i1 %209, label %$35, label %$36
$35:
  %210 = phi i64 [%201, %$34] ; # X
  %211 = phi i64 [%202, %$34] ; # R
  %212 = phi i64 [%207, %$34] ; # P
  %213 = phi i64 [%204, %$34] ; # Q
; # (set 4 P (cond ((atom (car (shift Q))) @) ((atom (set Q (cdr @)))...
; # (cond ((atom (car (shift Q))) @) ((atom (set Q (cdr @))) @) (T (c...
; # (shift Q)
  %214 = inttoptr i64 %213 to i64*
  %215 = getelementptr i64, i64* %214, i32 1
  %216 = load i64, i64* %215
; # (car (shift Q))
  %217 = inttoptr i64 %216 to i64*
  %218 = load i64, i64* %217
; # (atom (car (shift Q)))
  %219 = and i64 %218, 15
  %220 = icmp ne i64 %219, 0
  br i1 %220, label %$39, label %$38
$39:
  %221 = phi i64 [%210, %$35] ; # X
  %222 = phi i64 [%211, %$35] ; # R
  %223 = phi i64 [%212, %$35] ; # P
  %224 = phi i64 [%216, %$35] ; # Q
  br label %$37
$38:
  %225 = phi i64 [%210, %$35] ; # X
  %226 = phi i64 [%211, %$35] ; # R
  %227 = phi i64 [%212, %$35] ; # P
  %228 = phi i64 [%216, %$35] ; # Q
; # (set Q (cdr @))
; # (cdr @)
  %229 = inttoptr i64 %218 to i64*
  %230 = getelementptr i64, i64* %229, i32 1
  %231 = load i64, i64* %230
  %232 = inttoptr i64 %228 to i64*
  store i64 %231, i64* %232
; # (atom (set Q (cdr @)))
  %233 = and i64 %231, 15
  %234 = icmp ne i64 %233, 0
  br i1 %234, label %$41, label %$40
$41:
  %235 = phi i64 [%225, %$38] ; # X
  %236 = phi i64 [%226, %$38] ; # R
  %237 = phi i64 [%227, %$38] ; # P
  %238 = phi i64 [%228, %$38] ; # Q
  br label %$37
$40:
  %239 = phi i64 [%225, %$38] ; # X
  %240 = phi i64 [%226, %$38] ; # R
  %241 = phi i64 [%227, %$38] ; # P
  %242 = phi i64 [%228, %$38] ; # Q
; # (car @)
  %243 = inttoptr i64 %231 to i64*
  %244 = load i64, i64* %243
  br label %$37
$37:
  %245 = phi i64 [%221, %$39], [%235, %$41], [%239, %$40] ; # X
  %246 = phi i64 [%222, %$39], [%236, %$41], [%240, %$40] ; # R
  %247 = phi i64 [%223, %$39], [%237, %$41], [%241, %$40] ; # P
  %248 = phi i64 [%224, %$39], [%238, %$41], [%242, %$40] ; # Q
  %249 = phi i64 [%218, %$39], [%231, %$41], [%244, %$40] ; # ->
  %250 = inttoptr i64 %212 to i64*
  %251 = getelementptr i64, i64* %250, i32 3
  store i64 %249, i64* %251
  br label %$34
$36:
  %252 = phi i64 [%201, %$34] ; # X
  %253 = phi i64 [%202, %$34] ; # R
  %254 = phi i64 [%207, %$34] ; # P
  %255 = phi i64 [%204, %$34] ; # Q
  br label %$31
$33:
  %256 = phi i64 [%181, %$31] ; # X
  %257 = phi i64 [%183, %$31] ; # R
  %258 = phi i64 [0, %$31] ; # ->
  br label %$30
$30:
  %259 = phi i64 [%166, %$28], [%256, %$33] ; # X
  %260 = phi i64 [%167, %$28], [%257, %$33] ; # R
; # (drop *Safe)
  %261 = inttoptr i64 %26 to i64*
  %262 = getelementptr i64, i64* %261, i32 1
  %263 = load i64, i64* %262
  %264 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %263, i64* %264
  ret i64 %260
}

define i64 @_Map(i64) align 8 {
$1:
; # (let (X (cdr Exe) R $Nil E (push NIL $Nil ZERO (eval (car X)) NIL...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (car X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (car X))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (push NIL $Nil ZERO (eval (car X)) NIL)
  %14 = alloca i64, i64 5, align 16
  %15 = ptrtoint i64* %14 to i64
  %16 = add i64 %15, 8
  %17 = inttoptr i64 %16 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %17
  %18 = add i64 %15, 16
  %19 = inttoptr i64 %18 to i64*
  store i64 2, i64* %19
  %20 = add i64 %15, 24
  %21 = inttoptr i64 %20 to i64*
  store i64 %13, i64* %21
; # (set E (link (ofs E 3) T))
; # (ofs E 3)
  %22 = add i64 %15, 24
; # (link (ofs E 3) T)
  %23 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %24 = load i64, i64* %23
  %25 = inttoptr i64 %22 to i64*
  %26 = getelementptr i64, i64* %25, i32 1
  store i64 %24, i64* %26
  %27 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %22, i64* %27
  %28 = inttoptr i64 %15 to i64*
  store i64 %22, i64* %28
; # (let P E (while (pair (shift X)) (setq P (set 2 P (push NIL $Nil ...
; # (while (pair (shift X)) (setq P (set 2 P (push NIL $Nil ZERO (eva...
  br label %$7
$7:
  %29 = phi i64 [%3, %$2], [%37, %$10] ; # X
  %30 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%38, %$10] ; # R
  %31 = phi i64 [%15, %$2], [%51, %$10] ; # P
; # (shift X)
  %32 = inttoptr i64 %29 to i64*
  %33 = getelementptr i64, i64* %32, i32 1
  %34 = load i64, i64* %33
; # (pair (shift X))
  %35 = and i64 %34, 15
  %36 = icmp eq i64 %35, 0
  br i1 %36, label %$8, label %$9
$8:
  %37 = phi i64 [%34, %$7] ; # X
  %38 = phi i64 [%30, %$7] ; # R
  %39 = phi i64 [%31, %$7] ; # P
; # (set 2 P (push NIL $Nil ZERO (eval (car X)) NIL))
; # (car X)
  %40 = inttoptr i64 %37 to i64*
  %41 = load i64, i64* %40
; # (eval (car X))
  %42 = and i64 %41, 6
  %43 = icmp ne i64 %42, 0
  br i1 %43, label %$12, label %$11
$12:
  br label %$10
$11:
  %44 = and i64 %41, 8
  %45 = icmp ne i64 %44, 0
  br i1 %45, label %$14, label %$13
$14:
  %46 = inttoptr i64 %41 to i64*
  %47 = load i64, i64* %46
  br label %$10
$13:
  %48 = call i64 @evList(i64 %41)
  br label %$10
$10:
  %49 = phi i64 [%41, %$12], [%47, %$14], [%48, %$13] ; # ->
; # (push NIL $Nil ZERO (eval (car X)) NIL)
  %50 = alloca i64, i64 5, align 16
  %51 = ptrtoint i64* %50 to i64
  %52 = add i64 %51, 8
  %53 = inttoptr i64 %52 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %53
  %54 = add i64 %51, 16
  %55 = inttoptr i64 %54 to i64*
  store i64 2, i64* %55
  %56 = add i64 %51, 24
  %57 = inttoptr i64 %56 to i64*
  store i64 %49, i64* %57
  %58 = inttoptr i64 %39 to i64*
  %59 = getelementptr i64, i64* %58, i32 1
  store i64 %51, i64* %59
; # (set P (link (ofs P 3)))
; # (ofs P 3)
  %60 = add i64 %51, 24
; # (link (ofs P 3))
  %61 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %62 = load i64, i64* %61
  %63 = inttoptr i64 %60 to i64*
  %64 = getelementptr i64, i64* %63, i32 1
  store i64 %62, i64* %64
  %65 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %60, i64* %65
  %66 = inttoptr i64 %51 to i64*
  store i64 %60, i64* %66
  br label %$7
$9:
  %67 = phi i64 [%34, %$7] ; # X
  %68 = phi i64 [%30, %$7] ; # R
  %69 = phi i64 [%31, %$7] ; # P
; # (loop (let P (cdr E) (? (atom (val 4 P))) (setq R (evList E)) (lo...
  br label %$15
$15:
  %70 = phi i64 [%67, %$9], [%111, %$22] ; # X
  %71 = phi i64 [%68, %$9], [%112, %$22] ; # R
; # (let P (cdr E) (? (atom (val 4 P))) (setq R (evList E)) (loop (wh...
; # (cdr E)
  %72 = inttoptr i64 %15 to i64*
  %73 = getelementptr i64, i64* %72, i32 1
  %74 = load i64, i64* %73
; # (? (atom (val 4 P)))
; # (val 4 P)
  %75 = inttoptr i64 %74 to i64*
  %76 = getelementptr i64, i64* %75, i32 3
  %77 = load i64, i64* %76
; # (atom (val 4 P))
  %78 = and i64 %77, 15
  %79 = icmp ne i64 %78, 0
  br i1 %79, label %$17, label %$16
$16:
  %80 = phi i64 [%70, %$15] ; # X
  %81 = phi i64 [%71, %$15] ; # R
  %82 = phi i64 [%74, %$15] ; # P
; # (evList E)
  %83 = call i64 @evList(i64 %15)
; # (loop (when (pair (val 4 P)) (set 4 P (cdr @))) (? (atom (shift P...
  br label %$18
$18:
  %84 = phi i64 [%80, %$16], [%108, %$21] ; # X
  %85 = phi i64 [%83, %$16], [%109, %$21] ; # R
  %86 = phi i64 [%82, %$16], [%110, %$21] ; # P
; # (when (pair (val 4 P)) (set 4 P (cdr @)))
; # (val 4 P)
  %87 = inttoptr i64 %86 to i64*
  %88 = getelementptr i64, i64* %87, i32 3
  %89 = load i64, i64* %88
; # (pair (val 4 P))
  %90 = and i64 %89, 15
  %91 = icmp eq i64 %90, 0
  br i1 %91, label %$19, label %$20
$19:
  %92 = phi i64 [%84, %$18] ; # X
  %93 = phi i64 [%85, %$18] ; # R
  %94 = phi i64 [%86, %$18] ; # P
; # (set 4 P (cdr @))
; # (cdr @)
  %95 = inttoptr i64 %89 to i64*
  %96 = getelementptr i64, i64* %95, i32 1
  %97 = load i64, i64* %96
  %98 = inttoptr i64 %94 to i64*
  %99 = getelementptr i64, i64* %98, i32 3
  store i64 %97, i64* %99
  br label %$20
$20:
  %100 = phi i64 [%84, %$18], [%92, %$19] ; # X
  %101 = phi i64 [%85, %$18], [%93, %$19] ; # R
  %102 = phi i64 [%86, %$18], [%94, %$19] ; # P
; # (? (atom (shift P)))
; # (shift P)
  %103 = inttoptr i64 %102 to i64*
  %104 = getelementptr i64, i64* %103, i32 1
  %105 = load i64, i64* %104
; # (atom (shift P))
  %106 = and i64 %105, 15
  %107 = icmp ne i64 %106, 0
  br i1 %107, label %$22, label %$21
$21:
  %108 = phi i64 [%100, %$20] ; # X
  %109 = phi i64 [%101, %$20] ; # R
  %110 = phi i64 [%105, %$20] ; # P
  br label %$18
$22:
  %111 = phi i64 [%100, %$20] ; # X
  %112 = phi i64 [%101, %$20] ; # R
  %113 = phi i64 [%105, %$20] ; # P
  %114 = phi i64 [0, %$20] ; # ->
  br label %$15
$17:
  %115 = phi i64 [%70, %$15] ; # X
  %116 = phi i64 [%71, %$15] ; # R
  %117 = phi i64 [0, %$15] ; # ->
; # (drop *Safe)
  %118 = inttoptr i64 %22 to i64*
  %119 = getelementptr i64, i64* %118, i32 1
  %120 = load i64, i64* %119
  %121 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %120, i64* %121
  ret i64 %116
}

define i64 @_Mapc(i64) align 8 {
$1:
; # (let (X (cdr Exe) R $Nil E (push NIL $Nil ZERO (eval (++ X)) NIL)...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (push NIL $Nil ZERO (eval (++ X)) NIL)
  %16 = alloca i64, i64 5, align 16
  %17 = ptrtoint i64* %16 to i64
  %18 = add i64 %17, 8
  %19 = inttoptr i64 %18 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %19
  %20 = add i64 %17, 16
  %21 = inttoptr i64 %20 to i64*
  store i64 2, i64* %21
  %22 = add i64 %17, 24
  %23 = inttoptr i64 %22 to i64*
  store i64 %15, i64* %23
; # (push NIL NIL)
  %24 = alloca i64, i64 2, align 16
  %25 = ptrtoint i64* %24 to i64
; # (set E (link (ofs E 3) T))
; # (ofs E 3)
  %26 = add i64 %17, 24
; # (link (ofs E 3) T)
  %27 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %28 = load i64, i64* %27
  %29 = inttoptr i64 %26 to i64*
  %30 = getelementptr i64, i64* %29, i32 1
  store i64 %28, i64* %30
  %31 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %26, i64* %31
  %32 = inttoptr i64 %17 to i64*
  store i64 %26, i64* %32
; # (let (P E Q A) (loop (let V (set Q (save (eval (car X)))) (when (...
; # (loop (let V (set Q (save (eval (car X)))) (when (pair V) (setq V...
  br label %$7
$7:
  %33 = phi i64 [%7, %$2], [%92, %$15] ; # X
  %34 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%93, %$15] ; # R
  %35 = phi i64 [%17, %$2], [%94, %$15] ; # P
  %36 = phi i64 [%25, %$2], [%97, %$15] ; # Q
; # (let V (set Q (save (eval (car X)))) (when (pair V) (setq V (car ...
; # (set Q (save (eval (car X))))
; # (car X)
  %37 = inttoptr i64 %33 to i64*
  %38 = load i64, i64* %37
; # (eval (car X))
  %39 = and i64 %38, 6
  %40 = icmp ne i64 %39, 0
  br i1 %40, label %$10, label %$9
$10:
  br label %$8
$9:
  %41 = and i64 %38, 8
  %42 = icmp ne i64 %41, 0
  br i1 %42, label %$12, label %$11
$12:
  %43 = inttoptr i64 %38 to i64*
  %44 = load i64, i64* %43
  br label %$8
$11:
  %45 = call i64 @evList(i64 %38)
  br label %$8
$8:
  %46 = phi i64 [%38, %$10], [%44, %$12], [%45, %$11] ; # ->
; # (save (eval (car X)))
  %47 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %48 = load i64, i64* %47
  %49 = alloca i64, i64 2, align 16
  %50 = ptrtoint i64* %49 to i64
  %51 = inttoptr i64 %50 to i64*
  store i64 %46, i64* %51
  %52 = add i64 %50, 8
  %53 = inttoptr i64 %52 to i64*
  store i64 %48, i64* %53
  %54 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %50, i64* %54
  %55 = inttoptr i64 %36 to i64*
  store i64 %46, i64* %55
; # (when (pair V) (setq V (car V)))
; # (pair V)
  %56 = and i64 %46, 15
  %57 = icmp eq i64 %56, 0
  br i1 %57, label %$13, label %$14
$13:
  %58 = phi i64 [%33, %$8] ; # X
  %59 = phi i64 [%34, %$8] ; # R
  %60 = phi i64 [%35, %$8] ; # P
  %61 = phi i64 [%36, %$8] ; # Q
  %62 = phi i64 [%46, %$8] ; # V
; # (car V)
  %63 = inttoptr i64 %62 to i64*
  %64 = load i64, i64* %63
  br label %$14
$14:
  %65 = phi i64 [%33, %$8], [%58, %$13] ; # X
  %66 = phi i64 [%34, %$8], [%59, %$13] ; # R
  %67 = phi i64 [%35, %$8], [%60, %$13] ; # P
  %68 = phi i64 [%36, %$8], [%61, %$13] ; # Q
  %69 = phi i64 [%46, %$8], [%64, %$13] ; # V
; # (set 2 P (push NIL $Nil ZERO V NIL))
; # (push NIL $Nil ZERO V NIL)
  %70 = alloca i64, i64 5, align 16
  %71 = ptrtoint i64* %70 to i64
  %72 = add i64 %71, 8
  %73 = inttoptr i64 %72 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %73
  %74 = add i64 %71, 16
  %75 = inttoptr i64 %74 to i64*
  store i64 2, i64* %75
  %76 = add i64 %71, 24
  %77 = inttoptr i64 %76 to i64*
  store i64 %69, i64* %77
  %78 = inttoptr i64 %67 to i64*
  %79 = getelementptr i64, i64* %78, i32 1
  store i64 %71, i64* %79
; # (set P (link (ofs P 3)))
; # (ofs P 3)
  %80 = add i64 %71, 24
; # (link (ofs P 3))
  %81 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %82 = load i64, i64* %81
  %83 = inttoptr i64 %80 to i64*
  %84 = getelementptr i64, i64* %83, i32 1
  store i64 %82, i64* %84
  %85 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %80, i64* %85
  %86 = inttoptr i64 %71 to i64*
  store i64 %80, i64* %86
; # (? (atom (shift X)))
; # (shift X)
  %87 = inttoptr i64 %65 to i64*
  %88 = getelementptr i64, i64* %87, i32 1
  %89 = load i64, i64* %88
; # (atom (shift X))
  %90 = and i64 %89, 15
  %91 = icmp ne i64 %90, 0
  br i1 %91, label %$16, label %$15
$15:
  %92 = phi i64 [%89, %$14] ; # X
  %93 = phi i64 [%66, %$14] ; # R
  %94 = phi i64 [%71, %$14] ; # P
  %95 = phi i64 [%68, %$14] ; # Q
; # (set 2 Q (push NIL NIL))
; # (push NIL NIL)
  %96 = alloca i64, i64 2, align 16
  %97 = ptrtoint i64* %96 to i64
  %98 = inttoptr i64 %95 to i64*
  %99 = getelementptr i64, i64* %98, i32 1
  store i64 %97, i64* %99
  br label %$7
$16:
  %100 = phi i64 [%89, %$14] ; # X
  %101 = phi i64 [%66, %$14] ; # R
  %102 = phi i64 [%71, %$14] ; # P
  %103 = phi i64 [%68, %$14] ; # Q
  %104 = phi i64 [0, %$14] ; # ->
; # (when (pair (car A)) (loop (setq R (evList E)) (? (atom (set A (c...
; # (car A)
  %105 = inttoptr i64 %25 to i64*
  %106 = load i64, i64* %105
; # (pair (car A))
  %107 = and i64 %106, 15
  %108 = icmp eq i64 %107, 0
  br i1 %108, label %$17, label %$18
$17:
  %109 = phi i64 [%100, %$16] ; # X
  %110 = phi i64 [%101, %$16] ; # R
; # (loop (setq R (evList E)) (? (atom (set A (cdar A)))) (let (P (cd...
  br label %$19
$19:
  %111 = phi i64 [%109, %$17], [%182, %$24] ; # X
  %112 = phi i64 [%110, %$17], [%183, %$24] ; # R
; # (evList E)
  %113 = call i64 @evList(i64 %17)
; # (? (atom (set A (cdar A))))
; # (set A (cdar A))
; # (cdar A)
  %114 = inttoptr i64 %25 to i64*
  %115 = load i64, i64* %114
  %116 = inttoptr i64 %115 to i64*
  %117 = getelementptr i64, i64* %116, i32 1
  %118 = load i64, i64* %117
  %119 = inttoptr i64 %25 to i64*
  store i64 %118, i64* %119
; # (atom (set A (cdar A)))
  %120 = and i64 %118, 15
  %121 = icmp ne i64 %120, 0
  br i1 %121, label %$21, label %$20
$20:
  %122 = phi i64 [%111, %$19] ; # X
  %123 = phi i64 [%113, %$19] ; # R
; # (let (P (cdr E) Q A) (set 4 P (car @)) (while (pair (shift P)) (s...
; # (cdr E)
  %124 = inttoptr i64 %17 to i64*
  %125 = getelementptr i64, i64* %124, i32 1
  %126 = load i64, i64* %125
; # (set 4 P (car @))
; # (car @)
  %127 = inttoptr i64 %118 to i64*
  %128 = load i64, i64* %127
  %129 = inttoptr i64 %126 to i64*
  %130 = getelementptr i64, i64* %129, i32 3
  store i64 %128, i64* %130
; # (while (pair (shift P)) (set 4 P (cond ((atom (car (shift Q))) @)...
  br label %$22
$22:
  %131 = phi i64 [%122, %$20], [%175, %$25] ; # X
  %132 = phi i64 [%123, %$20], [%176, %$25] ; # R
  %133 = phi i64 [%126, %$20], [%177, %$25] ; # P
  %134 = phi i64 [%25, %$20], [%178, %$25] ; # Q
; # (shift P)
  %135 = inttoptr i64 %133 to i64*
  %136 = getelementptr i64, i64* %135, i32 1
  %137 = load i64, i64* %136
; # (pair (shift P))
  %138 = and i64 %137, 15
  %139 = icmp eq i64 %138, 0
  br i1 %139, label %$23, label %$24
$23:
  %140 = phi i64 [%131, %$22] ; # X
  %141 = phi i64 [%132, %$22] ; # R
  %142 = phi i64 [%137, %$22] ; # P
  %143 = phi i64 [%134, %$22] ; # Q
; # (set 4 P (cond ((atom (car (shift Q))) @) ((atom (set Q (cdr @)))...
; # (cond ((atom (car (shift Q))) @) ((atom (set Q (cdr @))) @) (T (c...
; # (shift Q)
  %144 = inttoptr i64 %143 to i64*
  %145 = getelementptr i64, i64* %144, i32 1
  %146 = load i64, i64* %145
; # (car (shift Q))
  %147 = inttoptr i64 %146 to i64*
  %148 = load i64, i64* %147
; # (atom (car (shift Q)))
  %149 = and i64 %148, 15
  %150 = icmp ne i64 %149, 0
  br i1 %150, label %$27, label %$26
$27:
  %151 = phi i64 [%140, %$23] ; # X
  %152 = phi i64 [%141, %$23] ; # R
  %153 = phi i64 [%142, %$23] ; # P
  %154 = phi i64 [%146, %$23] ; # Q
  br label %$25
$26:
  %155 = phi i64 [%140, %$23] ; # X
  %156 = phi i64 [%141, %$23] ; # R
  %157 = phi i64 [%142, %$23] ; # P
  %158 = phi i64 [%146, %$23] ; # Q
; # (set Q (cdr @))
; # (cdr @)
  %159 = inttoptr i64 %148 to i64*
  %160 = getelementptr i64, i64* %159, i32 1
  %161 = load i64, i64* %160
  %162 = inttoptr i64 %158 to i64*
  store i64 %161, i64* %162
; # (atom (set Q (cdr @)))
  %163 = and i64 %161, 15
  %164 = icmp ne i64 %163, 0
  br i1 %164, label %$29, label %$28
$29:
  %165 = phi i64 [%155, %$26] ; # X
  %166 = phi i64 [%156, %$26] ; # R
  %167 = phi i64 [%157, %$26] ; # P
  %168 = phi i64 [%158, %$26] ; # Q
  br label %$25
$28:
  %169 = phi i64 [%155, %$26] ; # X
  %170 = phi i64 [%156, %$26] ; # R
  %171 = phi i64 [%157, %$26] ; # P
  %172 = phi i64 [%158, %$26] ; # Q
; # (car @)
  %173 = inttoptr i64 %161 to i64*
  %174 = load i64, i64* %173
  br label %$25
$25:
  %175 = phi i64 [%151, %$27], [%165, %$29], [%169, %$28] ; # X
  %176 = phi i64 [%152, %$27], [%166, %$29], [%170, %$28] ; # R
  %177 = phi i64 [%153, %$27], [%167, %$29], [%171, %$28] ; # P
  %178 = phi i64 [%154, %$27], [%168, %$29], [%172, %$28] ; # Q
  %179 = phi i64 [%148, %$27], [%161, %$29], [%174, %$28] ; # ->
  %180 = inttoptr i64 %142 to i64*
  %181 = getelementptr i64, i64* %180, i32 3
  store i64 %179, i64* %181
  br label %$22
$24:
  %182 = phi i64 [%131, %$22] ; # X
  %183 = phi i64 [%132, %$22] ; # R
  %184 = phi i64 [%137, %$22] ; # P
  %185 = phi i64 [%134, %$22] ; # Q
  br label %$19
$21:
  %186 = phi i64 [%111, %$19] ; # X
  %187 = phi i64 [%113, %$19] ; # R
  %188 = phi i64 [0, %$19] ; # ->
  br label %$18
$18:
  %189 = phi i64 [%100, %$16], [%186, %$21] ; # X
  %190 = phi i64 [%101, %$16], [%187, %$21] ; # R
; # (drop *Safe)
  %191 = inttoptr i64 %26 to i64*
  %192 = getelementptr i64, i64* %191, i32 1
  %193 = load i64, i64* %192
  %194 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %193, i64* %194
  ret i64 %190
}

define i64 @_Maplist(i64) align 8 {
$1:
; # (let (X (cdr Exe) R (save $Nil) L 0 E (push NIL $Nil ZERO (eval (...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (save $Nil)
  %4 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %5 = load i64, i64* %4
  %6 = alloca i64, i64 2, align 16
  %7 = ptrtoint i64* %6 to i64
  %8 = inttoptr i64 %7 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %8
  %9 = add i64 %7, 8
  %10 = inttoptr i64 %9 to i64*
  store i64 %5, i64* %10
  %11 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %7, i64* %11
; # (car X)
  %12 = inttoptr i64 %3 to i64*
  %13 = load i64, i64* %12
; # (eval (car X))
  %14 = and i64 %13, 6
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$4, label %$3
$4:
  br label %$2
$3:
  %16 = and i64 %13, 8
  %17 = icmp ne i64 %16, 0
  br i1 %17, label %$6, label %$5
$6:
  %18 = inttoptr i64 %13 to i64*
  %19 = load i64, i64* %18
  br label %$2
$5:
  %20 = call i64 @evList(i64 %13)
  br label %$2
$2:
  %21 = phi i64 [%13, %$4], [%19, %$6], [%20, %$5] ; # ->
; # (push NIL $Nil ZERO (eval (car X)) NIL)
  %22 = alloca i64, i64 5, align 16
  %23 = ptrtoint i64* %22 to i64
  %24 = add i64 %23, 8
  %25 = inttoptr i64 %24 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %25
  %26 = add i64 %23, 16
  %27 = inttoptr i64 %26 to i64*
  store i64 2, i64* %27
  %28 = add i64 %23, 24
  %29 = inttoptr i64 %28 to i64*
  store i64 %21, i64* %29
; # (set E (link (ofs E 3)))
; # (ofs E 3)
  %30 = add i64 %23, 24
; # (link (ofs E 3))
  %31 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %32 = load i64, i64* %31
  %33 = inttoptr i64 %30 to i64*
  %34 = getelementptr i64, i64* %33, i32 1
  store i64 %32, i64* %34
  %35 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %30, i64* %35
  %36 = inttoptr i64 %23 to i64*
  store i64 %30, i64* %36
; # (let P E (while (pair (shift X)) (setq P (set 2 P (push NIL $Nil ...
; # (while (pair (shift X)) (setq P (set 2 P (push NIL $Nil ZERO (eva...
  br label %$7
$7:
  %37 = phi i64 [%3, %$2], [%46, %$10] ; # X
  %38 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%47, %$10] ; # R
  %39 = phi i64 [0, %$2], [%48, %$10] ; # L
  %40 = phi i64 [%23, %$2], [%61, %$10] ; # P
; # (shift X)
  %41 = inttoptr i64 %37 to i64*
  %42 = getelementptr i64, i64* %41, i32 1
  %43 = load i64, i64* %42
; # (pair (shift X))
  %44 = and i64 %43, 15
  %45 = icmp eq i64 %44, 0
  br i1 %45, label %$8, label %$9
$8:
  %46 = phi i64 [%43, %$7] ; # X
  %47 = phi i64 [%38, %$7] ; # R
  %48 = phi i64 [%39, %$7] ; # L
  %49 = phi i64 [%40, %$7] ; # P
; # (set 2 P (push NIL $Nil ZERO (eval (car X)) NIL))
; # (car X)
  %50 = inttoptr i64 %46 to i64*
  %51 = load i64, i64* %50
; # (eval (car X))
  %52 = and i64 %51, 6
  %53 = icmp ne i64 %52, 0
  br i1 %53, label %$12, label %$11
$12:
  br label %$10
$11:
  %54 = and i64 %51, 8
  %55 = icmp ne i64 %54, 0
  br i1 %55, label %$14, label %$13
$14:
  %56 = inttoptr i64 %51 to i64*
  %57 = load i64, i64* %56
  br label %$10
$13:
  %58 = call i64 @evList(i64 %51)
  br label %$10
$10:
  %59 = phi i64 [%51, %$12], [%57, %$14], [%58, %$13] ; # ->
; # (push NIL $Nil ZERO (eval (car X)) NIL)
  %60 = alloca i64, i64 5, align 16
  %61 = ptrtoint i64* %60 to i64
  %62 = add i64 %61, 8
  %63 = inttoptr i64 %62 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %63
  %64 = add i64 %61, 16
  %65 = inttoptr i64 %64 to i64*
  store i64 2, i64* %65
  %66 = add i64 %61, 24
  %67 = inttoptr i64 %66 to i64*
  store i64 %59, i64* %67
  %68 = inttoptr i64 %49 to i64*
  %69 = getelementptr i64, i64* %68, i32 1
  store i64 %61, i64* %69
; # (set P (link (ofs P 3)))
; # (ofs P 3)
  %70 = add i64 %61, 24
; # (link (ofs P 3))
  %71 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %72 = load i64, i64* %71
  %73 = inttoptr i64 %70 to i64*
  %74 = getelementptr i64, i64* %73, i32 1
  store i64 %72, i64* %74
  %75 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %70, i64* %75
  %76 = inttoptr i64 %61 to i64*
  store i64 %70, i64* %76
  br label %$7
$9:
  %77 = phi i64 [%43, %$7] ; # X
  %78 = phi i64 [%38, %$7] ; # R
  %79 = phi i64 [%39, %$7] ; # L
  %80 = phi i64 [%40, %$7] ; # P
; # (loop (let P (cdr E) (? (atom (val 4 P))) (let Y (cons (evList E)...
  br label %$15
$15:
  %81 = phi i64 [%77, %$9], [%146, %$25] ; # X
  %82 = phi i64 [%78, %$9], [%147, %$25] ; # R
  %83 = phi i64 [%79, %$9], [%148, %$25] ; # L
; # (let P (cdr E) (? (atom (val 4 P))) (let Y (cons (evList E) $Nil)...
; # (cdr E)
  %84 = inttoptr i64 %23 to i64*
  %85 = getelementptr i64, i64* %84, i32 1
  %86 = load i64, i64* %85
; # (? (atom (val 4 P)))
; # (val 4 P)
  %87 = inttoptr i64 %86 to i64*
  %88 = getelementptr i64, i64* %87, i32 3
  %89 = load i64, i64* %88
; # (atom (val 4 P))
  %90 = and i64 %89, 15
  %91 = icmp ne i64 %90, 0
  br i1 %91, label %$17, label %$16
$16:
  %92 = phi i64 [%81, %$15] ; # X
  %93 = phi i64 [%82, %$15] ; # R
  %94 = phi i64 [%83, %$15] ; # L
  %95 = phi i64 [%86, %$15] ; # P
; # (let Y (cons (evList E) $Nil) (setq L (if L (set 2 L Y) (setq R (...
; # (evList E)
  %96 = call i64 @evList(i64 %23)
; # (cons (evList E) $Nil)
  %97 = call i64 @cons(i64 %96, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (if L (set 2 L Y) (setq R (safe Y)))
  %98 = icmp ne i64 %94, 0
  br i1 %98, label %$18, label %$19
$18:
  %99 = phi i64 [%92, %$16] ; # X
  %100 = phi i64 [%93, %$16] ; # R
  %101 = phi i64 [%94, %$16] ; # L
  %102 = phi i64 [%95, %$16] ; # P
; # (set 2 L Y)
  %103 = inttoptr i64 %101 to i64*
  %104 = getelementptr i64, i64* %103, i32 1
  store i64 %97, i64* %104
  br label %$20
$19:
  %105 = phi i64 [%92, %$16] ; # X
  %106 = phi i64 [%93, %$16] ; # R
  %107 = phi i64 [%94, %$16] ; # L
  %108 = phi i64 [%95, %$16] ; # P
; # (safe Y)
  %109 = inttoptr i64 %7 to i64*
  store i64 %97, i64* %109
  br label %$20
$20:
  %110 = phi i64 [%99, %$18], [%105, %$19] ; # X
  %111 = phi i64 [%100, %$18], [%97, %$19] ; # R
  %112 = phi i64 [%101, %$18], [%107, %$19] ; # L
  %113 = phi i64 [%102, %$18], [%108, %$19] ; # P
  %114 = phi i64 [%97, %$18], [%97, %$19] ; # ->
; # (loop (when (pair (val 4 P)) (set 4 P (cdr @))) (? (atom (shift P...
  br label %$21
$21:
  %115 = phi i64 [%110, %$20], [%142, %$24] ; # X
  %116 = phi i64 [%111, %$20], [%143, %$24] ; # R
  %117 = phi i64 [%114, %$20], [%144, %$24] ; # L
  %118 = phi i64 [%113, %$20], [%145, %$24] ; # P
; # (when (pair (val 4 P)) (set 4 P (cdr @)))
; # (val 4 P)
  %119 = inttoptr i64 %118 to i64*
  %120 = getelementptr i64, i64* %119, i32 3
  %121 = load i64, i64* %120
; # (pair (val 4 P))
  %122 = and i64 %121, 15
  %123 = icmp eq i64 %122, 0
  br i1 %123, label %$22, label %$23
$22:
  %124 = phi i64 [%115, %$21] ; # X
  %125 = phi i64 [%116, %$21] ; # R
  %126 = phi i64 [%117, %$21] ; # L
  %127 = phi i64 [%118, %$21] ; # P
; # (set 4 P (cdr @))
; # (cdr @)
  %128 = inttoptr i64 %121 to i64*
  %129 = getelementptr i64, i64* %128, i32 1
  %130 = load i64, i64* %129
  %131 = inttoptr i64 %127 to i64*
  %132 = getelementptr i64, i64* %131, i32 3
  store i64 %130, i64* %132
  br label %$23
$23:
  %133 = phi i64 [%115, %$21], [%124, %$22] ; # X
  %134 = phi i64 [%116, %$21], [%125, %$22] ; # R
  %135 = phi i64 [%117, %$21], [%126, %$22] ; # L
  %136 = phi i64 [%118, %$21], [%127, %$22] ; # P
; # (? (atom (shift P)))
; # (shift P)
  %137 = inttoptr i64 %136 to i64*
  %138 = getelementptr i64, i64* %137, i32 1
  %139 = load i64, i64* %138
; # (atom (shift P))
  %140 = and i64 %139, 15
  %141 = icmp ne i64 %140, 0
  br i1 %141, label %$25, label %$24
$24:
  %142 = phi i64 [%133, %$23] ; # X
  %143 = phi i64 [%134, %$23] ; # R
  %144 = phi i64 [%135, %$23] ; # L
  %145 = phi i64 [%139, %$23] ; # P
  br label %$21
$25:
  %146 = phi i64 [%133, %$23] ; # X
  %147 = phi i64 [%134, %$23] ; # R
  %148 = phi i64 [%135, %$23] ; # L
  %149 = phi i64 [%139, %$23] ; # P
  %150 = phi i64 [0, %$23] ; # ->
  br label %$15
$17:
  %151 = phi i64 [%81, %$15] ; # X
  %152 = phi i64 [%82, %$15] ; # R
  %153 = phi i64 [%83, %$15] ; # L
  %154 = phi i64 [0, %$15] ; # ->
; # (drop *Safe)
  %155 = inttoptr i64 %7 to i64*
  %156 = getelementptr i64, i64* %155, i32 1
  %157 = load i64, i64* %156
  %158 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %157, i64* %158
  ret i64 %152
}

define i64 @_Mapcar(i64) align 8 {
$1:
; # (let (X (cdr Exe) R (save $Nil) L 0 E (push NIL $Nil ZERO (eval (...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (save $Nil)
  %4 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %5 = load i64, i64* %4
  %6 = alloca i64, i64 2, align 16
  %7 = ptrtoint i64* %6 to i64
  %8 = inttoptr i64 %7 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %8
  %9 = add i64 %7, 8
  %10 = inttoptr i64 %9 to i64*
  store i64 %5, i64* %10
  %11 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %7, i64* %11
; # (++ X)
  %12 = inttoptr i64 %3 to i64*
  %13 = load i64, i64* %12
  %14 = getelementptr i64, i64* %12, i32 1
  %15 = load i64, i64* %14
; # (eval (++ X))
  %16 = and i64 %13, 6
  %17 = icmp ne i64 %16, 0
  br i1 %17, label %$4, label %$3
$4:
  br label %$2
$3:
  %18 = and i64 %13, 8
  %19 = icmp ne i64 %18, 0
  br i1 %19, label %$6, label %$5
$6:
  %20 = inttoptr i64 %13 to i64*
  %21 = load i64, i64* %20
  br label %$2
$5:
  %22 = call i64 @evList(i64 %13)
  br label %$2
$2:
  %23 = phi i64 [%13, %$4], [%21, %$6], [%22, %$5] ; # ->
; # (push NIL $Nil ZERO (eval (++ X)) NIL)
  %24 = alloca i64, i64 5, align 16
  %25 = ptrtoint i64* %24 to i64
  %26 = add i64 %25, 8
  %27 = inttoptr i64 %26 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %27
  %28 = add i64 %25, 16
  %29 = inttoptr i64 %28 to i64*
  store i64 2, i64* %29
  %30 = add i64 %25, 24
  %31 = inttoptr i64 %30 to i64*
  store i64 %23, i64* %31
; # (push NIL NIL)
  %32 = alloca i64, i64 2, align 16
  %33 = ptrtoint i64* %32 to i64
; # (set E (link (ofs E 3)))
; # (ofs E 3)
  %34 = add i64 %25, 24
; # (link (ofs E 3))
  %35 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %36 = load i64, i64* %35
  %37 = inttoptr i64 %34 to i64*
  %38 = getelementptr i64, i64* %37, i32 1
  store i64 %36, i64* %38
  %39 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %34, i64* %39
  %40 = inttoptr i64 %25 to i64*
  store i64 %34, i64* %40
; # (let (P E Q A) (loop (let V (set Q (save (eval (car X)))) (when (...
; # (loop (let V (set Q (save (eval (car X)))) (when (pair V) (setq V...
  br label %$7
$7:
  %41 = phi i64 [%15, %$2], [%103, %$15] ; # X
  %42 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%104, %$15] ; # R
  %43 = phi i64 [0, %$2], [%105, %$15] ; # L
  %44 = phi i64 [%25, %$2], [%106, %$15] ; # P
  %45 = phi i64 [%33, %$2], [%109, %$15] ; # Q
; # (let V (set Q (save (eval (car X)))) (when (pair V) (setq V (car ...
; # (set Q (save (eval (car X))))
; # (car X)
  %46 = inttoptr i64 %41 to i64*
  %47 = load i64, i64* %46
; # (eval (car X))
  %48 = and i64 %47, 6
  %49 = icmp ne i64 %48, 0
  br i1 %49, label %$10, label %$9
$10:
  br label %$8
$9:
  %50 = and i64 %47, 8
  %51 = icmp ne i64 %50, 0
  br i1 %51, label %$12, label %$11
$12:
  %52 = inttoptr i64 %47 to i64*
  %53 = load i64, i64* %52
  br label %$8
$11:
  %54 = call i64 @evList(i64 %47)
  br label %$8
$8:
  %55 = phi i64 [%47, %$10], [%53, %$12], [%54, %$11] ; # ->
; # (save (eval (car X)))
  %56 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %57 = load i64, i64* %56
  %58 = alloca i64, i64 2, align 16
  %59 = ptrtoint i64* %58 to i64
  %60 = inttoptr i64 %59 to i64*
  store i64 %55, i64* %60
  %61 = add i64 %59, 8
  %62 = inttoptr i64 %61 to i64*
  store i64 %57, i64* %62
  %63 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %59, i64* %63
  %64 = inttoptr i64 %45 to i64*
  store i64 %55, i64* %64
; # (when (pair V) (setq V (car V)))
; # (pair V)
  %65 = and i64 %55, 15
  %66 = icmp eq i64 %65, 0
  br i1 %66, label %$13, label %$14
$13:
  %67 = phi i64 [%41, %$8] ; # X
  %68 = phi i64 [%42, %$8] ; # R
  %69 = phi i64 [%43, %$8] ; # L
  %70 = phi i64 [%44, %$8] ; # P
  %71 = phi i64 [%45, %$8] ; # Q
  %72 = phi i64 [%55, %$8] ; # V
; # (car V)
  %73 = inttoptr i64 %72 to i64*
  %74 = load i64, i64* %73
  br label %$14
$14:
  %75 = phi i64 [%41, %$8], [%67, %$13] ; # X
  %76 = phi i64 [%42, %$8], [%68, %$13] ; # R
  %77 = phi i64 [%43, %$8], [%69, %$13] ; # L
  %78 = phi i64 [%44, %$8], [%70, %$13] ; # P
  %79 = phi i64 [%45, %$8], [%71, %$13] ; # Q
  %80 = phi i64 [%55, %$8], [%74, %$13] ; # V
; # (set 2 P (push NIL $Nil ZERO V NIL))
; # (push NIL $Nil ZERO V NIL)
  %81 = alloca i64, i64 5, align 16
  %82 = ptrtoint i64* %81 to i64
  %83 = add i64 %82, 8
  %84 = inttoptr i64 %83 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %84
  %85 = add i64 %82, 16
  %86 = inttoptr i64 %85 to i64*
  store i64 2, i64* %86
  %87 = add i64 %82, 24
  %88 = inttoptr i64 %87 to i64*
  store i64 %80, i64* %88
  %89 = inttoptr i64 %78 to i64*
  %90 = getelementptr i64, i64* %89, i32 1
  store i64 %82, i64* %90
; # (set P (link (ofs P 3)))
; # (ofs P 3)
  %91 = add i64 %82, 24
; # (link (ofs P 3))
  %92 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %93 = load i64, i64* %92
  %94 = inttoptr i64 %91 to i64*
  %95 = getelementptr i64, i64* %94, i32 1
  store i64 %93, i64* %95
  %96 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %91, i64* %96
  %97 = inttoptr i64 %82 to i64*
  store i64 %91, i64* %97
; # (? (atom (shift X)))
; # (shift X)
  %98 = inttoptr i64 %75 to i64*
  %99 = getelementptr i64, i64* %98, i32 1
  %100 = load i64, i64* %99
; # (atom (shift X))
  %101 = and i64 %100, 15
  %102 = icmp ne i64 %101, 0
  br i1 %102, label %$16, label %$15
$15:
  %103 = phi i64 [%100, %$14] ; # X
  %104 = phi i64 [%76, %$14] ; # R
  %105 = phi i64 [%77, %$14] ; # L
  %106 = phi i64 [%82, %$14] ; # P
  %107 = phi i64 [%79, %$14] ; # Q
; # (set 2 Q (push NIL NIL))
; # (push NIL NIL)
  %108 = alloca i64, i64 2, align 16
  %109 = ptrtoint i64* %108 to i64
  %110 = inttoptr i64 %107 to i64*
  %111 = getelementptr i64, i64* %110, i32 1
  store i64 %109, i64* %111
  br label %$7
$16:
  %112 = phi i64 [%100, %$14] ; # X
  %113 = phi i64 [%76, %$14] ; # R
  %114 = phi i64 [%77, %$14] ; # L
  %115 = phi i64 [%82, %$14] ; # P
  %116 = phi i64 [%79, %$14] ; # Q
  %117 = phi i64 [0, %$14] ; # ->
; # (when (pair (car A)) (loop (let Y (cons (evList E) $Nil) (setq L ...
; # (car A)
  %118 = inttoptr i64 %33 to i64*
  %119 = load i64, i64* %118
; # (pair (car A))
  %120 = and i64 %119, 15
  %121 = icmp eq i64 %120, 0
  br i1 %121, label %$17, label %$18
$17:
  %122 = phi i64 [%112, %$16] ; # X
  %123 = phi i64 [%113, %$16] ; # R
  %124 = phi i64 [%114, %$16] ; # L
; # (loop (let Y (cons (evList E) $Nil) (setq L (if L (set 2 L Y) (se...
  br label %$19
$19:
  %125 = phi i64 [%122, %$17], [%220, %$27] ; # X
  %126 = phi i64 [%123, %$17], [%221, %$27] ; # R
  %127 = phi i64 [%124, %$17], [%222, %$27] ; # L
; # (let Y (cons (evList E) $Nil) (setq L (if L (set 2 L Y) (setq R (...
; # (evList E)
  %128 = call i64 @evList(i64 %25)
; # (cons (evList E) $Nil)
  %129 = call i64 @cons(i64 %128, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (if L (set 2 L Y) (setq R (safe Y)))
  %130 = icmp ne i64 %127, 0
  br i1 %130, label %$20, label %$21
$20:
  %131 = phi i64 [%125, %$19] ; # X
  %132 = phi i64 [%126, %$19] ; # R
  %133 = phi i64 [%127, %$19] ; # L
; # (set 2 L Y)
  %134 = inttoptr i64 %133 to i64*
  %135 = getelementptr i64, i64* %134, i32 1
  store i64 %129, i64* %135
  br label %$22
$21:
  %136 = phi i64 [%125, %$19] ; # X
  %137 = phi i64 [%126, %$19] ; # R
  %138 = phi i64 [%127, %$19] ; # L
; # (safe Y)
  %139 = inttoptr i64 %7 to i64*
  store i64 %129, i64* %139
  br label %$22
$22:
  %140 = phi i64 [%131, %$20], [%136, %$21] ; # X
  %141 = phi i64 [%132, %$20], [%129, %$21] ; # R
  %142 = phi i64 [%133, %$20], [%138, %$21] ; # L
  %143 = phi i64 [%129, %$20], [%129, %$21] ; # ->
; # (? (atom (set A (cdar A))))
; # (set A (cdar A))
; # (cdar A)
  %144 = inttoptr i64 %33 to i64*
  %145 = load i64, i64* %144
  %146 = inttoptr i64 %145 to i64*
  %147 = getelementptr i64, i64* %146, i32 1
  %148 = load i64, i64* %147
  %149 = inttoptr i64 %33 to i64*
  store i64 %148, i64* %149
; # (atom (set A (cdar A)))
  %150 = and i64 %148, 15
  %151 = icmp ne i64 %150, 0
  br i1 %151, label %$24, label %$23
$23:
  %152 = phi i64 [%140, %$22] ; # X
  %153 = phi i64 [%141, %$22] ; # R
  %154 = phi i64 [%143, %$22] ; # L
; # (let (P (cdr E) Q A) (set 4 P (car @)) (while (pair (shift P)) (s...
; # (cdr E)
  %155 = inttoptr i64 %25 to i64*
  %156 = getelementptr i64, i64* %155, i32 1
  %157 = load i64, i64* %156
; # (set 4 P (car @))
; # (car @)
  %158 = inttoptr i64 %148 to i64*
  %159 = load i64, i64* %158
  %160 = inttoptr i64 %157 to i64*
  %161 = getelementptr i64, i64* %160, i32 3
  store i64 %159, i64* %161
; # (while (pair (shift P)) (set 4 P (cond ((atom (car (shift Q))) @)...
  br label %$25
$25:
  %162 = phi i64 [%152, %$23], [%212, %$28] ; # X
  %163 = phi i64 [%153, %$23], [%213, %$28] ; # R
  %164 = phi i64 [%154, %$23], [%214, %$28] ; # L
  %165 = phi i64 [%157, %$23], [%215, %$28] ; # P
  %166 = phi i64 [%33, %$23], [%216, %$28] ; # Q
; # (shift P)
  %167 = inttoptr i64 %165 to i64*
  %168 = getelementptr i64, i64* %167, i32 1
  %169 = load i64, i64* %168
; # (pair (shift P))
  %170 = and i64 %169, 15
  %171 = icmp eq i64 %170, 0
  br i1 %171, label %$26, label %$27
$26:
  %172 = phi i64 [%162, %$25] ; # X
  %173 = phi i64 [%163, %$25] ; # R
  %174 = phi i64 [%164, %$25] ; # L
  %175 = phi i64 [%169, %$25] ; # P
  %176 = phi i64 [%166, %$25] ; # Q
; # (set 4 P (cond ((atom (car (shift Q))) @) ((atom (set Q (cdr @)))...
; # (cond ((atom (car (shift Q))) @) ((atom (set Q (cdr @))) @) (T (c...
; # (shift Q)
  %177 = inttoptr i64 %176 to i64*
  %178 = getelementptr i64, i64* %177, i32 1
  %179 = load i64, i64* %178
; # (car (shift Q))
  %180 = inttoptr i64 %179 to i64*
  %181 = load i64, i64* %180
; # (atom (car (shift Q)))
  %182 = and i64 %181, 15
  %183 = icmp ne i64 %182, 0
  br i1 %183, label %$30, label %$29
$30:
  %184 = phi i64 [%172, %$26] ; # X
  %185 = phi i64 [%173, %$26] ; # R
  %186 = phi i64 [%174, %$26] ; # L
  %187 = phi i64 [%175, %$26] ; # P
  %188 = phi i64 [%179, %$26] ; # Q
  br label %$28
$29:
  %189 = phi i64 [%172, %$26] ; # X
  %190 = phi i64 [%173, %$26] ; # R
  %191 = phi i64 [%174, %$26] ; # L
  %192 = phi i64 [%175, %$26] ; # P
  %193 = phi i64 [%179, %$26] ; # Q
; # (set Q (cdr @))
; # (cdr @)
  %194 = inttoptr i64 %181 to i64*
  %195 = getelementptr i64, i64* %194, i32 1
  %196 = load i64, i64* %195
  %197 = inttoptr i64 %193 to i64*
  store i64 %196, i64* %197
; # (atom (set Q (cdr @)))
  %198 = and i64 %196, 15
  %199 = icmp ne i64 %198, 0
  br i1 %199, label %$32, label %$31
$32:
  %200 = phi i64 [%189, %$29] ; # X
  %201 = phi i64 [%190, %$29] ; # R
  %202 = phi i64 [%191, %$29] ; # L
  %203 = phi i64 [%192, %$29] ; # P
  %204 = phi i64 [%193, %$29] ; # Q
  br label %$28
$31:
  %205 = phi i64 [%189, %$29] ; # X
  %206 = phi i64 [%190, %$29] ; # R
  %207 = phi i64 [%191, %$29] ; # L
  %208 = phi i64 [%192, %$29] ; # P
  %209 = phi i64 [%193, %$29] ; # Q
; # (car @)
  %210 = inttoptr i64 %196 to i64*
  %211 = load i64, i64* %210
  br label %$28
$28:
  %212 = phi i64 [%184, %$30], [%200, %$32], [%205, %$31] ; # X
  %213 = phi i64 [%185, %$30], [%201, %$32], [%206, %$31] ; # R
  %214 = phi i64 [%186, %$30], [%202, %$32], [%207, %$31] ; # L
  %215 = phi i64 [%187, %$30], [%203, %$32], [%208, %$31] ; # P
  %216 = phi i64 [%188, %$30], [%204, %$32], [%209, %$31] ; # Q
  %217 = phi i64 [%181, %$30], [%196, %$32], [%211, %$31] ; # ->
  %218 = inttoptr i64 %175 to i64*
  %219 = getelementptr i64, i64* %218, i32 3
  store i64 %217, i64* %219
  br label %$25
$27:
  %220 = phi i64 [%162, %$25] ; # X
  %221 = phi i64 [%163, %$25] ; # R
  %222 = phi i64 [%164, %$25] ; # L
  %223 = phi i64 [%169, %$25] ; # P
  %224 = phi i64 [%166, %$25] ; # Q
  br label %$19
$24:
  %225 = phi i64 [%140, %$22] ; # X
  %226 = phi i64 [%141, %$22] ; # R
  %227 = phi i64 [%143, %$22] ; # L
  %228 = phi i64 [0, %$22] ; # ->
  br label %$18
$18:
  %229 = phi i64 [%112, %$16], [%225, %$24] ; # X
  %230 = phi i64 [%113, %$16], [%226, %$24] ; # R
  %231 = phi i64 [%114, %$16], [%227, %$24] ; # L
; # (drop *Safe)
  %232 = inttoptr i64 %7 to i64*
  %233 = getelementptr i64, i64* %232, i32 1
  %234 = load i64, i64* %233
  %235 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %234, i64* %235
  ret i64 %230
}

define i64 @_Mapcon(i64) align 8 {
$1:
; # (let (X (cdr Exe) R (save $Nil) L 0 E (push NIL $Nil ZERO (eval (...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (save $Nil)
  %4 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %5 = load i64, i64* %4
  %6 = alloca i64, i64 2, align 16
  %7 = ptrtoint i64* %6 to i64
  %8 = inttoptr i64 %7 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %8
  %9 = add i64 %7, 8
  %10 = inttoptr i64 %9 to i64*
  store i64 %5, i64* %10
  %11 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %7, i64* %11
; # (car X)
  %12 = inttoptr i64 %3 to i64*
  %13 = load i64, i64* %12
; # (eval (car X))
  %14 = and i64 %13, 6
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$4, label %$3
$4:
  br label %$2
$3:
  %16 = and i64 %13, 8
  %17 = icmp ne i64 %16, 0
  br i1 %17, label %$6, label %$5
$6:
  %18 = inttoptr i64 %13 to i64*
  %19 = load i64, i64* %18
  br label %$2
$5:
  %20 = call i64 @evList(i64 %13)
  br label %$2
$2:
  %21 = phi i64 [%13, %$4], [%19, %$6], [%20, %$5] ; # ->
; # (push NIL $Nil ZERO (eval (car X)) NIL)
  %22 = alloca i64, i64 5, align 16
  %23 = ptrtoint i64* %22 to i64
  %24 = add i64 %23, 8
  %25 = inttoptr i64 %24 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %25
  %26 = add i64 %23, 16
  %27 = inttoptr i64 %26 to i64*
  store i64 2, i64* %27
  %28 = add i64 %23, 24
  %29 = inttoptr i64 %28 to i64*
  store i64 %21, i64* %29
; # (set E (link (ofs E 3)))
; # (ofs E 3)
  %30 = add i64 %23, 24
; # (link (ofs E 3))
  %31 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %32 = load i64, i64* %31
  %33 = inttoptr i64 %30 to i64*
  %34 = getelementptr i64, i64* %33, i32 1
  store i64 %32, i64* %34
  %35 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %30, i64* %35
  %36 = inttoptr i64 %23 to i64*
  store i64 %30, i64* %36
; # (let P E (while (pair (shift X)) (setq P (set 2 P (push NIL $Nil ...
; # (while (pair (shift X)) (setq P (set 2 P (push NIL $Nil ZERO (eva...
  br label %$7
$7:
  %37 = phi i64 [%3, %$2], [%46, %$10] ; # X
  %38 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%47, %$10] ; # R
  %39 = phi i64 [0, %$2], [%48, %$10] ; # L
  %40 = phi i64 [%23, %$2], [%61, %$10] ; # P
; # (shift X)
  %41 = inttoptr i64 %37 to i64*
  %42 = getelementptr i64, i64* %41, i32 1
  %43 = load i64, i64* %42
; # (pair (shift X))
  %44 = and i64 %43, 15
  %45 = icmp eq i64 %44, 0
  br i1 %45, label %$8, label %$9
$8:
  %46 = phi i64 [%43, %$7] ; # X
  %47 = phi i64 [%38, %$7] ; # R
  %48 = phi i64 [%39, %$7] ; # L
  %49 = phi i64 [%40, %$7] ; # P
; # (set 2 P (push NIL $Nil ZERO (eval (car X)) NIL))
; # (car X)
  %50 = inttoptr i64 %46 to i64*
  %51 = load i64, i64* %50
; # (eval (car X))
  %52 = and i64 %51, 6
  %53 = icmp ne i64 %52, 0
  br i1 %53, label %$12, label %$11
$12:
  br label %$10
$11:
  %54 = and i64 %51, 8
  %55 = icmp ne i64 %54, 0
  br i1 %55, label %$14, label %$13
$14:
  %56 = inttoptr i64 %51 to i64*
  %57 = load i64, i64* %56
  br label %$10
$13:
  %58 = call i64 @evList(i64 %51)
  br label %$10
$10:
  %59 = phi i64 [%51, %$12], [%57, %$14], [%58, %$13] ; # ->
; # (push NIL $Nil ZERO (eval (car X)) NIL)
  %60 = alloca i64, i64 5, align 16
  %61 = ptrtoint i64* %60 to i64
  %62 = add i64 %61, 8
  %63 = inttoptr i64 %62 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %63
  %64 = add i64 %61, 16
  %65 = inttoptr i64 %64 to i64*
  store i64 2, i64* %65
  %66 = add i64 %61, 24
  %67 = inttoptr i64 %66 to i64*
  store i64 %59, i64* %67
  %68 = inttoptr i64 %49 to i64*
  %69 = getelementptr i64, i64* %68, i32 1
  store i64 %61, i64* %69
; # (set P (link (ofs P 3)))
; # (ofs P 3)
  %70 = add i64 %61, 24
; # (link (ofs P 3))
  %71 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %72 = load i64, i64* %71
  %73 = inttoptr i64 %70 to i64*
  %74 = getelementptr i64, i64* %73, i32 1
  store i64 %72, i64* %74
  %75 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %70, i64* %75
  %76 = inttoptr i64 %61 to i64*
  store i64 %70, i64* %76
  br label %$7
$9:
  %77 = phi i64 [%43, %$7] ; # X
  %78 = phi i64 [%38, %$7] ; # R
  %79 = phi i64 [%39, %$7] ; # L
  %80 = phi i64 [%40, %$7] ; # P
; # (loop (let P (cdr E) (? (atom (val 4 P))) (let Y (evList E) (when...
  br label %$15
$15:
  %81 = phi i64 [%77, %$9], [%175, %$30] ; # X
  %82 = phi i64 [%78, %$9], [%176, %$30] ; # R
  %83 = phi i64 [%79, %$9], [%177, %$30] ; # L
; # (let P (cdr E) (? (atom (val 4 P))) (let Y (evList E) (when (pair...
; # (cdr E)
  %84 = inttoptr i64 %23 to i64*
  %85 = getelementptr i64, i64* %84, i32 1
  %86 = load i64, i64* %85
; # (? (atom (val 4 P)))
; # (val 4 P)
  %87 = inttoptr i64 %86 to i64*
  %88 = getelementptr i64, i64* %87, i32 3
  %89 = load i64, i64* %88
; # (atom (val 4 P))
  %90 = and i64 %89, 15
  %91 = icmp ne i64 %90, 0
  br i1 %91, label %$17, label %$16
$16:
  %92 = phi i64 [%81, %$15] ; # X
  %93 = phi i64 [%82, %$15] ; # R
  %94 = phi i64 [%83, %$15] ; # L
  %95 = phi i64 [%86, %$15] ; # P
; # (let Y (evList E) (when (pair Y) (setq L (if L (let Z L (while (p...
; # (evList E)
  %96 = call i64 @evList(i64 %23)
; # (when (pair Y) (setq L (if L (let Z L (while (pair (cdr Z)) (setq...
; # (pair Y)
  %97 = and i64 %96, 15
  %98 = icmp eq i64 %97, 0
  br i1 %98, label %$18, label %$19
$18:
  %99 = phi i64 [%92, %$16] ; # X
  %100 = phi i64 [%93, %$16] ; # R
  %101 = phi i64 [%94, %$16] ; # L
  %102 = phi i64 [%95, %$16] ; # P
; # (if L (let Z L (while (pair (cdr Z)) (setq Z @)) (set 2 Z Y)) (se...
  %103 = icmp ne i64 %101, 0
  br i1 %103, label %$20, label %$21
$20:
  %104 = phi i64 [%99, %$18] ; # X
  %105 = phi i64 [%100, %$18] ; # R
  %106 = phi i64 [%101, %$18] ; # L
  %107 = phi i64 [%102, %$18] ; # P
; # (let Z L (while (pair (cdr Z)) (setq Z @)) (set 2 Z Y))
; # (while (pair (cdr Z)) (setq Z @))
  br label %$23
$23:
  %108 = phi i64 [%104, %$20], [%118, %$24] ; # X
  %109 = phi i64 [%105, %$20], [%119, %$24] ; # R
  %110 = phi i64 [%106, %$20], [%120, %$24] ; # L
  %111 = phi i64 [%107, %$20], [%121, %$24] ; # P
  %112 = phi i64 [%106, %$20], [%115, %$24] ; # Z
; # (cdr Z)
  %113 = inttoptr i64 %112 to i64*
  %114 = getelementptr i64, i64* %113, i32 1
  %115 = load i64, i64* %114
; # (pair (cdr Z))
  %116 = and i64 %115, 15
  %117 = icmp eq i64 %116, 0
  br i1 %117, label %$24, label %$25
$24:
  %118 = phi i64 [%108, %$23] ; # X
  %119 = phi i64 [%109, %$23] ; # R
  %120 = phi i64 [%110, %$23] ; # L
  %121 = phi i64 [%111, %$23] ; # P
  %122 = phi i64 [%112, %$23] ; # Z
  br label %$23
$25:
  %123 = phi i64 [%108, %$23] ; # X
  %124 = phi i64 [%109, %$23] ; # R
  %125 = phi i64 [%110, %$23] ; # L
  %126 = phi i64 [%111, %$23] ; # P
  %127 = phi i64 [%112, %$23] ; # Z
; # (set 2 Z Y)
  %128 = inttoptr i64 %127 to i64*
  %129 = getelementptr i64, i64* %128, i32 1
  store i64 %96, i64* %129
  br label %$22
$21:
  %130 = phi i64 [%99, %$18] ; # X
  %131 = phi i64 [%100, %$18] ; # R
  %132 = phi i64 [%101, %$18] ; # L
  %133 = phi i64 [%102, %$18] ; # P
; # (safe Y)
  %134 = inttoptr i64 %7 to i64*
  store i64 %96, i64* %134
  br label %$22
$22:
  %135 = phi i64 [%123, %$25], [%130, %$21] ; # X
  %136 = phi i64 [%124, %$25], [%96, %$21] ; # R
  %137 = phi i64 [%125, %$25], [%132, %$21] ; # L
  %138 = phi i64 [%126, %$25], [%133, %$21] ; # P
  %139 = phi i64 [%96, %$25], [%96, %$21] ; # ->
  br label %$19
$19:
  %140 = phi i64 [%92, %$16], [%135, %$22] ; # X
  %141 = phi i64 [%93, %$16], [%136, %$22] ; # R
  %142 = phi i64 [%94, %$16], [%139, %$22] ; # L
  %143 = phi i64 [%95, %$16], [%138, %$22] ; # P
; # (loop (when (pair (val 4 P)) (set 4 P (cdr @))) (? (atom (shift P...
  br label %$26
$26:
  %144 = phi i64 [%140, %$19], [%171, %$29] ; # X
  %145 = phi i64 [%141, %$19], [%172, %$29] ; # R
  %146 = phi i64 [%142, %$19], [%173, %$29] ; # L
  %147 = phi i64 [%143, %$19], [%174, %$29] ; # P
; # (when (pair (val 4 P)) (set 4 P (cdr @)))
; # (val 4 P)
  %148 = inttoptr i64 %147 to i64*
  %149 = getelementptr i64, i64* %148, i32 3
  %150 = load i64, i64* %149
; # (pair (val 4 P))
  %151 = and i64 %150, 15
  %152 = icmp eq i64 %151, 0
  br i1 %152, label %$27, label %$28
$27:
  %153 = phi i64 [%144, %$26] ; # X
  %154 = phi i64 [%145, %$26] ; # R
  %155 = phi i64 [%146, %$26] ; # L
  %156 = phi i64 [%147, %$26] ; # P
; # (set 4 P (cdr @))
; # (cdr @)
  %157 = inttoptr i64 %150 to i64*
  %158 = getelementptr i64, i64* %157, i32 1
  %159 = load i64, i64* %158
  %160 = inttoptr i64 %156 to i64*
  %161 = getelementptr i64, i64* %160, i32 3
  store i64 %159, i64* %161
  br label %$28
$28:
  %162 = phi i64 [%144, %$26], [%153, %$27] ; # X
  %163 = phi i64 [%145, %$26], [%154, %$27] ; # R
  %164 = phi i64 [%146, %$26], [%155, %$27] ; # L
  %165 = phi i64 [%147, %$26], [%156, %$27] ; # P
; # (? (atom (shift P)))
; # (shift P)
  %166 = inttoptr i64 %165 to i64*
  %167 = getelementptr i64, i64* %166, i32 1
  %168 = load i64, i64* %167
; # (atom (shift P))
  %169 = and i64 %168, 15
  %170 = icmp ne i64 %169, 0
  br i1 %170, label %$30, label %$29
$29:
  %171 = phi i64 [%162, %$28] ; # X
  %172 = phi i64 [%163, %$28] ; # R
  %173 = phi i64 [%164, %$28] ; # L
  %174 = phi i64 [%168, %$28] ; # P
  br label %$26
$30:
  %175 = phi i64 [%162, %$28] ; # X
  %176 = phi i64 [%163, %$28] ; # R
  %177 = phi i64 [%164, %$28] ; # L
  %178 = phi i64 [%168, %$28] ; # P
  %179 = phi i64 [0, %$28] ; # ->
  br label %$15
$17:
  %180 = phi i64 [%81, %$15] ; # X
  %181 = phi i64 [%82, %$15] ; # R
  %182 = phi i64 [%83, %$15] ; # L
  %183 = phi i64 [0, %$15] ; # ->
; # (drop *Safe)
  %184 = inttoptr i64 %7 to i64*
  %185 = getelementptr i64, i64* %184, i32 1
  %186 = load i64, i64* %185
  %187 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %186, i64* %187
  ret i64 %181
}

define i64 @_Mapcan(i64) align 8 {
$1:
; # (let (X (cdr Exe) R (save $Nil) L 0 E (push NIL $Nil ZERO (eval (...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (save $Nil)
  %4 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %5 = load i64, i64* %4
  %6 = alloca i64, i64 2, align 16
  %7 = ptrtoint i64* %6 to i64
  %8 = inttoptr i64 %7 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %8
  %9 = add i64 %7, 8
  %10 = inttoptr i64 %9 to i64*
  store i64 %5, i64* %10
  %11 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %7, i64* %11
; # (++ X)
  %12 = inttoptr i64 %3 to i64*
  %13 = load i64, i64* %12
  %14 = getelementptr i64, i64* %12, i32 1
  %15 = load i64, i64* %14
; # (eval (++ X))
  %16 = and i64 %13, 6
  %17 = icmp ne i64 %16, 0
  br i1 %17, label %$4, label %$3
$4:
  br label %$2
$3:
  %18 = and i64 %13, 8
  %19 = icmp ne i64 %18, 0
  br i1 %19, label %$6, label %$5
$6:
  %20 = inttoptr i64 %13 to i64*
  %21 = load i64, i64* %20
  br label %$2
$5:
  %22 = call i64 @evList(i64 %13)
  br label %$2
$2:
  %23 = phi i64 [%13, %$4], [%21, %$6], [%22, %$5] ; # ->
; # (push NIL $Nil ZERO (eval (++ X)) NIL)
  %24 = alloca i64, i64 5, align 16
  %25 = ptrtoint i64* %24 to i64
  %26 = add i64 %25, 8
  %27 = inttoptr i64 %26 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %27
  %28 = add i64 %25, 16
  %29 = inttoptr i64 %28 to i64*
  store i64 2, i64* %29
  %30 = add i64 %25, 24
  %31 = inttoptr i64 %30 to i64*
  store i64 %23, i64* %31
; # (push NIL NIL)
  %32 = alloca i64, i64 2, align 16
  %33 = ptrtoint i64* %32 to i64
; # (set E (link (ofs E 3)))
; # (ofs E 3)
  %34 = add i64 %25, 24
; # (link (ofs E 3))
  %35 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %36 = load i64, i64* %35
  %37 = inttoptr i64 %34 to i64*
  %38 = getelementptr i64, i64* %37, i32 1
  store i64 %36, i64* %38
  %39 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %34, i64* %39
  %40 = inttoptr i64 %25 to i64*
  store i64 %34, i64* %40
; # (let (P E Q A) (loop (let V (set Q (save (eval (car X)))) (when (...
; # (loop (let V (set Q (save (eval (car X)))) (when (pair V) (setq V...
  br label %$7
$7:
  %41 = phi i64 [%15, %$2], [%103, %$15] ; # X
  %42 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%104, %$15] ; # R
  %43 = phi i64 [0, %$2], [%105, %$15] ; # L
  %44 = phi i64 [%25, %$2], [%106, %$15] ; # P
  %45 = phi i64 [%33, %$2], [%109, %$15] ; # Q
; # (let V (set Q (save (eval (car X)))) (when (pair V) (setq V (car ...
; # (set Q (save (eval (car X))))
; # (car X)
  %46 = inttoptr i64 %41 to i64*
  %47 = load i64, i64* %46
; # (eval (car X))
  %48 = and i64 %47, 6
  %49 = icmp ne i64 %48, 0
  br i1 %49, label %$10, label %$9
$10:
  br label %$8
$9:
  %50 = and i64 %47, 8
  %51 = icmp ne i64 %50, 0
  br i1 %51, label %$12, label %$11
$12:
  %52 = inttoptr i64 %47 to i64*
  %53 = load i64, i64* %52
  br label %$8
$11:
  %54 = call i64 @evList(i64 %47)
  br label %$8
$8:
  %55 = phi i64 [%47, %$10], [%53, %$12], [%54, %$11] ; # ->
; # (save (eval (car X)))
  %56 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %57 = load i64, i64* %56
  %58 = alloca i64, i64 2, align 16
  %59 = ptrtoint i64* %58 to i64
  %60 = inttoptr i64 %59 to i64*
  store i64 %55, i64* %60
  %61 = add i64 %59, 8
  %62 = inttoptr i64 %61 to i64*
  store i64 %57, i64* %62
  %63 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %59, i64* %63
  %64 = inttoptr i64 %45 to i64*
  store i64 %55, i64* %64
; # (when (pair V) (setq V (car V)))
; # (pair V)
  %65 = and i64 %55, 15
  %66 = icmp eq i64 %65, 0
  br i1 %66, label %$13, label %$14
$13:
  %67 = phi i64 [%41, %$8] ; # X
  %68 = phi i64 [%42, %$8] ; # R
  %69 = phi i64 [%43, %$8] ; # L
  %70 = phi i64 [%44, %$8] ; # P
  %71 = phi i64 [%45, %$8] ; # Q
  %72 = phi i64 [%55, %$8] ; # V
; # (car V)
  %73 = inttoptr i64 %72 to i64*
  %74 = load i64, i64* %73
  br label %$14
$14:
  %75 = phi i64 [%41, %$8], [%67, %$13] ; # X
  %76 = phi i64 [%42, %$8], [%68, %$13] ; # R
  %77 = phi i64 [%43, %$8], [%69, %$13] ; # L
  %78 = phi i64 [%44, %$8], [%70, %$13] ; # P
  %79 = phi i64 [%45, %$8], [%71, %$13] ; # Q
  %80 = phi i64 [%55, %$8], [%74, %$13] ; # V
; # (set 2 P (push NIL $Nil ZERO V NIL))
; # (push NIL $Nil ZERO V NIL)
  %81 = alloca i64, i64 5, align 16
  %82 = ptrtoint i64* %81 to i64
  %83 = add i64 %82, 8
  %84 = inttoptr i64 %83 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %84
  %85 = add i64 %82, 16
  %86 = inttoptr i64 %85 to i64*
  store i64 2, i64* %86
  %87 = add i64 %82, 24
  %88 = inttoptr i64 %87 to i64*
  store i64 %80, i64* %88
  %89 = inttoptr i64 %78 to i64*
  %90 = getelementptr i64, i64* %89, i32 1
  store i64 %82, i64* %90
; # (set P (link (ofs P 3)))
; # (ofs P 3)
  %91 = add i64 %82, 24
; # (link (ofs P 3))
  %92 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %93 = load i64, i64* %92
  %94 = inttoptr i64 %91 to i64*
  %95 = getelementptr i64, i64* %94, i32 1
  store i64 %93, i64* %95
  %96 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %91, i64* %96
  %97 = inttoptr i64 %82 to i64*
  store i64 %91, i64* %97
; # (? (atom (shift X)))
; # (shift X)
  %98 = inttoptr i64 %75 to i64*
  %99 = getelementptr i64, i64* %98, i32 1
  %100 = load i64, i64* %99
; # (atom (shift X))
  %101 = and i64 %100, 15
  %102 = icmp ne i64 %101, 0
  br i1 %102, label %$16, label %$15
$15:
  %103 = phi i64 [%100, %$14] ; # X
  %104 = phi i64 [%76, %$14] ; # R
  %105 = phi i64 [%77, %$14] ; # L
  %106 = phi i64 [%82, %$14] ; # P
  %107 = phi i64 [%79, %$14] ; # Q
; # (set 2 Q (push NIL NIL))
; # (push NIL NIL)
  %108 = alloca i64, i64 2, align 16
  %109 = ptrtoint i64* %108 to i64
  %110 = inttoptr i64 %107 to i64*
  %111 = getelementptr i64, i64* %110, i32 1
  store i64 %109, i64* %111
  br label %$7
$16:
  %112 = phi i64 [%100, %$14] ; # X
  %113 = phi i64 [%76, %$14] ; # R
  %114 = phi i64 [%77, %$14] ; # L
  %115 = phi i64 [%82, %$14] ; # P
  %116 = phi i64 [%79, %$14] ; # Q
  %117 = phi i64 [0, %$14] ; # ->
; # (when (pair (car A)) (loop (let Y (evList E) (when (pair Y) (setq...
; # (car A)
  %118 = inttoptr i64 %33 to i64*
  %119 = load i64, i64* %118
; # (pair (car A))
  %120 = and i64 %119, 15
  %121 = icmp eq i64 %120, 0
  br i1 %121, label %$17, label %$18
$17:
  %122 = phi i64 [%112, %$16] ; # X
  %123 = phi i64 [%113, %$16] ; # R
  %124 = phi i64 [%114, %$16] ; # L
; # (loop (let Y (evList E) (when (pair Y) (setq L (if L (let Z L (wh...
  br label %$19
$19:
  %125 = phi i64 [%122, %$17], [%244, %$32] ; # X
  %126 = phi i64 [%123, %$17], [%245, %$32] ; # R
  %127 = phi i64 [%124, %$17], [%246, %$32] ; # L
; # (let Y (evList E) (when (pair Y) (setq L (if L (let Z L (while (p...
; # (evList E)
  %128 = call i64 @evList(i64 %25)
; # (when (pair Y) (setq L (if L (let Z L (while (pair (cdr Z)) (setq...
; # (pair Y)
  %129 = and i64 %128, 15
  %130 = icmp eq i64 %129, 0
  br i1 %130, label %$20, label %$21
$20:
  %131 = phi i64 [%125, %$19] ; # X
  %132 = phi i64 [%126, %$19] ; # R
  %133 = phi i64 [%127, %$19] ; # L
; # (if L (let Z L (while (pair (cdr Z)) (setq Z @)) (set 2 Z Y)) (se...
  %134 = icmp ne i64 %133, 0
  br i1 %134, label %$22, label %$23
$22:
  %135 = phi i64 [%131, %$20] ; # X
  %136 = phi i64 [%132, %$20] ; # R
  %137 = phi i64 [%133, %$20] ; # L
; # (let Z L (while (pair (cdr Z)) (setq Z @)) (set 2 Z Y))
; # (while (pair (cdr Z)) (setq Z @))
  br label %$25
$25:
  %138 = phi i64 [%135, %$22], [%147, %$26] ; # X
  %139 = phi i64 [%136, %$22], [%148, %$26] ; # R
  %140 = phi i64 [%137, %$22], [%149, %$26] ; # L
  %141 = phi i64 [%137, %$22], [%144, %$26] ; # Z
; # (cdr Z)
  %142 = inttoptr i64 %141 to i64*
  %143 = getelementptr i64, i64* %142, i32 1
  %144 = load i64, i64* %143
; # (pair (cdr Z))
  %145 = and i64 %144, 15
  %146 = icmp eq i64 %145, 0
  br i1 %146, label %$26, label %$27
$26:
  %147 = phi i64 [%138, %$25] ; # X
  %148 = phi i64 [%139, %$25] ; # R
  %149 = phi i64 [%140, %$25] ; # L
  %150 = phi i64 [%141, %$25] ; # Z
  br label %$25
$27:
  %151 = phi i64 [%138, %$25] ; # X
  %152 = phi i64 [%139, %$25] ; # R
  %153 = phi i64 [%140, %$25] ; # L
  %154 = phi i64 [%141, %$25] ; # Z
; # (set 2 Z Y)
  %155 = inttoptr i64 %154 to i64*
  %156 = getelementptr i64, i64* %155, i32 1
  store i64 %128, i64* %156
  br label %$24
$23:
  %157 = phi i64 [%131, %$20] ; # X
  %158 = phi i64 [%132, %$20] ; # R
  %159 = phi i64 [%133, %$20] ; # L
; # (safe Y)
  %160 = inttoptr i64 %7 to i64*
  store i64 %128, i64* %160
  br label %$24
$24:
  %161 = phi i64 [%151, %$27], [%157, %$23] ; # X
  %162 = phi i64 [%152, %$27], [%128, %$23] ; # R
  %163 = phi i64 [%153, %$27], [%159, %$23] ; # L
  %164 = phi i64 [%128, %$27], [%128, %$23] ; # ->
  br label %$21
$21:
  %165 = phi i64 [%125, %$19], [%161, %$24] ; # X
  %166 = phi i64 [%126, %$19], [%162, %$24] ; # R
  %167 = phi i64 [%127, %$19], [%164, %$24] ; # L
; # (? (atom (set A (cdar A))))
; # (set A (cdar A))
; # (cdar A)
  %168 = inttoptr i64 %33 to i64*
  %169 = load i64, i64* %168
  %170 = inttoptr i64 %169 to i64*
  %171 = getelementptr i64, i64* %170, i32 1
  %172 = load i64, i64* %171
  %173 = inttoptr i64 %33 to i64*
  store i64 %172, i64* %173
; # (atom (set A (cdar A)))
  %174 = and i64 %172, 15
  %175 = icmp ne i64 %174, 0
  br i1 %175, label %$29, label %$28
$28:
  %176 = phi i64 [%165, %$21] ; # X
  %177 = phi i64 [%166, %$21] ; # R
  %178 = phi i64 [%167, %$21] ; # L
; # (let (P (cdr E) Q A) (set 4 P (car @)) (while (pair (shift P)) (s...
; # (cdr E)
  %179 = inttoptr i64 %25 to i64*
  %180 = getelementptr i64, i64* %179, i32 1
  %181 = load i64, i64* %180
; # (set 4 P (car @))
; # (car @)
  %182 = inttoptr i64 %172 to i64*
  %183 = load i64, i64* %182
  %184 = inttoptr i64 %181 to i64*
  %185 = getelementptr i64, i64* %184, i32 3
  store i64 %183, i64* %185
; # (while (pair (shift P)) (set 4 P (cond ((atom (car (shift Q))) @)...
  br label %$30
$30:
  %186 = phi i64 [%176, %$28], [%236, %$33] ; # X
  %187 = phi i64 [%177, %$28], [%237, %$33] ; # R
  %188 = phi i64 [%178, %$28], [%238, %$33] ; # L
  %189 = phi i64 [%181, %$28], [%239, %$33] ; # P
  %190 = phi i64 [%33, %$28], [%240, %$33] ; # Q
; # (shift P)
  %191 = inttoptr i64 %189 to i64*
  %192 = getelementptr i64, i64* %191, i32 1
  %193 = load i64, i64* %192
; # (pair (shift P))
  %194 = and i64 %193, 15
  %195 = icmp eq i64 %194, 0
  br i1 %195, label %$31, label %$32
$31:
  %196 = phi i64 [%186, %$30] ; # X
  %197 = phi i64 [%187, %$30] ; # R
  %198 = phi i64 [%188, %$30] ; # L
  %199 = phi i64 [%193, %$30] ; # P
  %200 = phi i64 [%190, %$30] ; # Q
; # (set 4 P (cond ((atom (car (shift Q))) @) ((atom (set Q (cdr @)))...
; # (cond ((atom (car (shift Q))) @) ((atom (set Q (cdr @))) @) (T (c...
; # (shift Q)
  %201 = inttoptr i64 %200 to i64*
  %202 = getelementptr i64, i64* %201, i32 1
  %203 = load i64, i64* %202
; # (car (shift Q))
  %204 = inttoptr i64 %203 to i64*
  %205 = load i64, i64* %204
; # (atom (car (shift Q)))
  %206 = and i64 %205, 15
  %207 = icmp ne i64 %206, 0
  br i1 %207, label %$35, label %$34
$35:
  %208 = phi i64 [%196, %$31] ; # X
  %209 = phi i64 [%197, %$31] ; # R
  %210 = phi i64 [%198, %$31] ; # L
  %211 = phi i64 [%199, %$31] ; # P
  %212 = phi i64 [%203, %$31] ; # Q
  br label %$33
$34:
  %213 = phi i64 [%196, %$31] ; # X
  %214 = phi i64 [%197, %$31] ; # R
  %215 = phi i64 [%198, %$31] ; # L
  %216 = phi i64 [%199, %$31] ; # P
  %217 = phi i64 [%203, %$31] ; # Q
; # (set Q (cdr @))
; # (cdr @)
  %218 = inttoptr i64 %205 to i64*
  %219 = getelementptr i64, i64* %218, i32 1
  %220 = load i64, i64* %219
  %221 = inttoptr i64 %217 to i64*
  store i64 %220, i64* %221
; # (atom (set Q (cdr @)))
  %222 = and i64 %220, 15
  %223 = icmp ne i64 %222, 0
  br i1 %223, label %$37, label %$36
$37:
  %224 = phi i64 [%213, %$34] ; # X
  %225 = phi i64 [%214, %$34] ; # R
  %226 = phi i64 [%215, %$34] ; # L
  %227 = phi i64 [%216, %$34] ; # P
  %228 = phi i64 [%217, %$34] ; # Q
  br label %$33
$36:
  %229 = phi i64 [%213, %$34] ; # X
  %230 = phi i64 [%214, %$34] ; # R
  %231 = phi i64 [%215, %$34] ; # L
  %232 = phi i64 [%216, %$34] ; # P
  %233 = phi i64 [%217, %$34] ; # Q
; # (car @)
  %234 = inttoptr i64 %220 to i64*
  %235 = load i64, i64* %234
  br label %$33
$33:
  %236 = phi i64 [%208, %$35], [%224, %$37], [%229, %$36] ; # X
  %237 = phi i64 [%209, %$35], [%225, %$37], [%230, %$36] ; # R
  %238 = phi i64 [%210, %$35], [%226, %$37], [%231, %$36] ; # L
  %239 = phi i64 [%211, %$35], [%227, %$37], [%232, %$36] ; # P
  %240 = phi i64 [%212, %$35], [%228, %$37], [%233, %$36] ; # Q
  %241 = phi i64 [%205, %$35], [%220, %$37], [%235, %$36] ; # ->
  %242 = inttoptr i64 %199 to i64*
  %243 = getelementptr i64, i64* %242, i32 3
  store i64 %241, i64* %243
  br label %$30
$32:
  %244 = phi i64 [%186, %$30] ; # X
  %245 = phi i64 [%187, %$30] ; # R
  %246 = phi i64 [%188, %$30] ; # L
  %247 = phi i64 [%193, %$30] ; # P
  %248 = phi i64 [%190, %$30] ; # Q
  br label %$19
$29:
  %249 = phi i64 [%165, %$21] ; # X
  %250 = phi i64 [%166, %$21] ; # R
  %251 = phi i64 [%167, %$21] ; # L
  %252 = phi i64 [0, %$21] ; # ->
  br label %$18
$18:
  %253 = phi i64 [%112, %$16], [%249, %$29] ; # X
  %254 = phi i64 [%113, %$16], [%250, %$29] ; # R
  %255 = phi i64 [%114, %$16], [%251, %$29] ; # L
; # (drop *Safe)
  %256 = inttoptr i64 %7 to i64*
  %257 = getelementptr i64, i64* %256, i32 1
  %258 = load i64, i64* %257
  %259 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %258, i64* %259
  ret i64 %254
}

define i64 @_Filter(i64) align 8 {
$1:
; # (let (X (cdr Exe) R (save $Nil) L 0 E (push NIL $Nil ZERO (eval (...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (save $Nil)
  %4 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %5 = load i64, i64* %4
  %6 = alloca i64, i64 2, align 16
  %7 = ptrtoint i64* %6 to i64
  %8 = inttoptr i64 %7 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %8
  %9 = add i64 %7, 8
  %10 = inttoptr i64 %9 to i64*
  store i64 %5, i64* %10
  %11 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %7, i64* %11
; # (++ X)
  %12 = inttoptr i64 %3 to i64*
  %13 = load i64, i64* %12
  %14 = getelementptr i64, i64* %12, i32 1
  %15 = load i64, i64* %14
; # (eval (++ X))
  %16 = and i64 %13, 6
  %17 = icmp ne i64 %16, 0
  br i1 %17, label %$4, label %$3
$4:
  br label %$2
$3:
  %18 = and i64 %13, 8
  %19 = icmp ne i64 %18, 0
  br i1 %19, label %$6, label %$5
$6:
  %20 = inttoptr i64 %13 to i64*
  %21 = load i64, i64* %20
  br label %$2
$5:
  %22 = call i64 @evList(i64 %13)
  br label %$2
$2:
  %23 = phi i64 [%13, %$4], [%21, %$6], [%22, %$5] ; # ->
; # (push NIL $Nil ZERO (eval (++ X)) NIL)
  %24 = alloca i64, i64 5, align 16
  %25 = ptrtoint i64* %24 to i64
  %26 = add i64 %25, 8
  %27 = inttoptr i64 %26 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %27
  %28 = add i64 %25, 16
  %29 = inttoptr i64 %28 to i64*
  store i64 2, i64* %29
  %30 = add i64 %25, 24
  %31 = inttoptr i64 %30 to i64*
  store i64 %23, i64* %31
; # (push NIL NIL)
  %32 = alloca i64, i64 2, align 16
  %33 = ptrtoint i64* %32 to i64
; # (set E (link (ofs E 3)))
; # (ofs E 3)
  %34 = add i64 %25, 24
; # (link (ofs E 3))
  %35 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %36 = load i64, i64* %35
  %37 = inttoptr i64 %34 to i64*
  %38 = getelementptr i64, i64* %37, i32 1
  store i64 %36, i64* %38
  %39 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %34, i64* %39
  %40 = inttoptr i64 %25 to i64*
  store i64 %34, i64* %40
; # (let (P E Q A) (loop (let V (set Q (save (eval (car X)))) (when (...
; # (loop (let V (set Q (save (eval (car X)))) (when (pair V) (setq V...
  br label %$7
$7:
  %41 = phi i64 [%15, %$2], [%103, %$15] ; # X
  %42 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%104, %$15] ; # R
  %43 = phi i64 [0, %$2], [%105, %$15] ; # L
  %44 = phi i64 [%25, %$2], [%106, %$15] ; # P
  %45 = phi i64 [%33, %$2], [%109, %$15] ; # Q
; # (let V (set Q (save (eval (car X)))) (when (pair V) (setq V (car ...
; # (set Q (save (eval (car X))))
; # (car X)
  %46 = inttoptr i64 %41 to i64*
  %47 = load i64, i64* %46
; # (eval (car X))
  %48 = and i64 %47, 6
  %49 = icmp ne i64 %48, 0
  br i1 %49, label %$10, label %$9
$10:
  br label %$8
$9:
  %50 = and i64 %47, 8
  %51 = icmp ne i64 %50, 0
  br i1 %51, label %$12, label %$11
$12:
  %52 = inttoptr i64 %47 to i64*
  %53 = load i64, i64* %52
  br label %$8
$11:
  %54 = call i64 @evList(i64 %47)
  br label %$8
$8:
  %55 = phi i64 [%47, %$10], [%53, %$12], [%54, %$11] ; # ->
; # (save (eval (car X)))
  %56 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %57 = load i64, i64* %56
  %58 = alloca i64, i64 2, align 16
  %59 = ptrtoint i64* %58 to i64
  %60 = inttoptr i64 %59 to i64*
  store i64 %55, i64* %60
  %61 = add i64 %59, 8
  %62 = inttoptr i64 %61 to i64*
  store i64 %57, i64* %62
  %63 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %59, i64* %63
  %64 = inttoptr i64 %45 to i64*
  store i64 %55, i64* %64
; # (when (pair V) (setq V (car V)))
; # (pair V)
  %65 = and i64 %55, 15
  %66 = icmp eq i64 %65, 0
  br i1 %66, label %$13, label %$14
$13:
  %67 = phi i64 [%41, %$8] ; # X
  %68 = phi i64 [%42, %$8] ; # R
  %69 = phi i64 [%43, %$8] ; # L
  %70 = phi i64 [%44, %$8] ; # P
  %71 = phi i64 [%45, %$8] ; # Q
  %72 = phi i64 [%55, %$8] ; # V
; # (car V)
  %73 = inttoptr i64 %72 to i64*
  %74 = load i64, i64* %73
  br label %$14
$14:
  %75 = phi i64 [%41, %$8], [%67, %$13] ; # X
  %76 = phi i64 [%42, %$8], [%68, %$13] ; # R
  %77 = phi i64 [%43, %$8], [%69, %$13] ; # L
  %78 = phi i64 [%44, %$8], [%70, %$13] ; # P
  %79 = phi i64 [%45, %$8], [%71, %$13] ; # Q
  %80 = phi i64 [%55, %$8], [%74, %$13] ; # V
; # (set 2 P (push NIL $Nil ZERO V NIL))
; # (push NIL $Nil ZERO V NIL)
  %81 = alloca i64, i64 5, align 16
  %82 = ptrtoint i64* %81 to i64
  %83 = add i64 %82, 8
  %84 = inttoptr i64 %83 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %84
  %85 = add i64 %82, 16
  %86 = inttoptr i64 %85 to i64*
  store i64 2, i64* %86
  %87 = add i64 %82, 24
  %88 = inttoptr i64 %87 to i64*
  store i64 %80, i64* %88
  %89 = inttoptr i64 %78 to i64*
  %90 = getelementptr i64, i64* %89, i32 1
  store i64 %82, i64* %90
; # (set P (link (ofs P 3)))
; # (ofs P 3)
  %91 = add i64 %82, 24
; # (link (ofs P 3))
  %92 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %93 = load i64, i64* %92
  %94 = inttoptr i64 %91 to i64*
  %95 = getelementptr i64, i64* %94, i32 1
  store i64 %93, i64* %95
  %96 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %91, i64* %96
  %97 = inttoptr i64 %82 to i64*
  store i64 %91, i64* %97
; # (? (atom (shift X)))
; # (shift X)
  %98 = inttoptr i64 %75 to i64*
  %99 = getelementptr i64, i64* %98, i32 1
  %100 = load i64, i64* %99
; # (atom (shift X))
  %101 = and i64 %100, 15
  %102 = icmp ne i64 %101, 0
  br i1 %102, label %$16, label %$15
$15:
  %103 = phi i64 [%100, %$14] ; # X
  %104 = phi i64 [%76, %$14] ; # R
  %105 = phi i64 [%77, %$14] ; # L
  %106 = phi i64 [%82, %$14] ; # P
  %107 = phi i64 [%79, %$14] ; # Q
; # (set 2 Q (push NIL NIL))
; # (push NIL NIL)
  %108 = alloca i64, i64 2, align 16
  %109 = ptrtoint i64* %108 to i64
  %110 = inttoptr i64 %107 to i64*
  %111 = getelementptr i64, i64* %110, i32 1
  store i64 %109, i64* %111
  br label %$7
$16:
  %112 = phi i64 [%100, %$14] ; # X
  %113 = phi i64 [%76, %$14] ; # R
  %114 = phi i64 [%77, %$14] ; # L
  %115 = phi i64 [%82, %$14] ; # P
  %116 = phi i64 [%79, %$14] ; # Q
  %117 = phi i64 [0, %$14] ; # ->
; # (when (pair (car A)) (loop (unless (nil? (evList E)) (let Y (cons...
; # (car A)
  %118 = inttoptr i64 %33 to i64*
  %119 = load i64, i64* %118
; # (pair (car A))
  %120 = and i64 %119, 15
  %121 = icmp eq i64 %120, 0
  br i1 %121, label %$17, label %$18
$17:
  %122 = phi i64 [%112, %$16] ; # X
  %123 = phi i64 [%113, %$16] ; # R
  %124 = phi i64 [%114, %$16] ; # L
; # (loop (unless (nil? (evList E)) (let Y (cons (caar A) $Nil) (setq...
  br label %$19
$19:
  %125 = phi i64 [%122, %$17], [%231, %$29] ; # X
  %126 = phi i64 [%123, %$17], [%232, %$29] ; # R
  %127 = phi i64 [%124, %$17], [%233, %$29] ; # L
; # (unless (nil? (evList E)) (let Y (cons (caar A) $Nil) (setq L (if...
; # (evList E)
  %128 = call i64 @evList(i64 %25)
; # (nil? (evList E))
  %129 = icmp eq i64 %128, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %129, label %$21, label %$20
$20:
  %130 = phi i64 [%125, %$19] ; # X
  %131 = phi i64 [%126, %$19] ; # R
  %132 = phi i64 [%127, %$19] ; # L
; # (let Y (cons (caar A) $Nil) (setq L (if L (set 2 L Y) (setq R (sa...
; # (caar A)
  %133 = inttoptr i64 %33 to i64*
  %134 = load i64, i64* %133
  %135 = inttoptr i64 %134 to i64*
  %136 = load i64, i64* %135
; # (cons (caar A) $Nil)
  %137 = call i64 @cons(i64 %136, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (if L (set 2 L Y) (setq R (safe Y)))
  %138 = icmp ne i64 %132, 0
  br i1 %138, label %$22, label %$23
$22:
  %139 = phi i64 [%130, %$20] ; # X
  %140 = phi i64 [%131, %$20] ; # R
  %141 = phi i64 [%132, %$20] ; # L
; # (set 2 L Y)
  %142 = inttoptr i64 %141 to i64*
  %143 = getelementptr i64, i64* %142, i32 1
  store i64 %137, i64* %143
  br label %$24
$23:
  %144 = phi i64 [%130, %$20] ; # X
  %145 = phi i64 [%131, %$20] ; # R
  %146 = phi i64 [%132, %$20] ; # L
; # (safe Y)
  %147 = inttoptr i64 %7 to i64*
  store i64 %137, i64* %147
  br label %$24
$24:
  %148 = phi i64 [%139, %$22], [%144, %$23] ; # X
  %149 = phi i64 [%140, %$22], [%137, %$23] ; # R
  %150 = phi i64 [%141, %$22], [%146, %$23] ; # L
  %151 = phi i64 [%137, %$22], [%137, %$23] ; # ->
  br label %$21
$21:
  %152 = phi i64 [%125, %$19], [%148, %$24] ; # X
  %153 = phi i64 [%126, %$19], [%149, %$24] ; # R
  %154 = phi i64 [%127, %$19], [%151, %$24] ; # L
; # (? (atom (set A (cdar A))))
; # (set A (cdar A))
; # (cdar A)
  %155 = inttoptr i64 %33 to i64*
  %156 = load i64, i64* %155
  %157 = inttoptr i64 %156 to i64*
  %158 = getelementptr i64, i64* %157, i32 1
  %159 = load i64, i64* %158
  %160 = inttoptr i64 %33 to i64*
  store i64 %159, i64* %160
; # (atom (set A (cdar A)))
  %161 = and i64 %159, 15
  %162 = icmp ne i64 %161, 0
  br i1 %162, label %$26, label %$25
$25:
  %163 = phi i64 [%152, %$21] ; # X
  %164 = phi i64 [%153, %$21] ; # R
  %165 = phi i64 [%154, %$21] ; # L
; # (let (P (cdr E) Q A) (set 4 P (car @)) (while (pair (shift P)) (s...
; # (cdr E)
  %166 = inttoptr i64 %25 to i64*
  %167 = getelementptr i64, i64* %166, i32 1
  %168 = load i64, i64* %167
; # (set 4 P (car @))
; # (car @)
  %169 = inttoptr i64 %159 to i64*
  %170 = load i64, i64* %169
  %171 = inttoptr i64 %168 to i64*
  %172 = getelementptr i64, i64* %171, i32 3
  store i64 %170, i64* %172
; # (while (pair (shift P)) (set 4 P (cond ((atom (car (shift Q))) @)...
  br label %$27
$27:
  %173 = phi i64 [%163, %$25], [%223, %$30] ; # X
  %174 = phi i64 [%164, %$25], [%224, %$30] ; # R
  %175 = phi i64 [%165, %$25], [%225, %$30] ; # L
  %176 = phi i64 [%168, %$25], [%226, %$30] ; # P
  %177 = phi i64 [%33, %$25], [%227, %$30] ; # Q
; # (shift P)
  %178 = inttoptr i64 %176 to i64*
  %179 = getelementptr i64, i64* %178, i32 1
  %180 = load i64, i64* %179
; # (pair (shift P))
  %181 = and i64 %180, 15
  %182 = icmp eq i64 %181, 0
  br i1 %182, label %$28, label %$29
$28:
  %183 = phi i64 [%173, %$27] ; # X
  %184 = phi i64 [%174, %$27] ; # R
  %185 = phi i64 [%175, %$27] ; # L
  %186 = phi i64 [%180, %$27] ; # P
  %187 = phi i64 [%177, %$27] ; # Q
; # (set 4 P (cond ((atom (car (shift Q))) @) ((atom (set Q (cdr @)))...
; # (cond ((atom (car (shift Q))) @) ((atom (set Q (cdr @))) @) (T (c...
; # (shift Q)
  %188 = inttoptr i64 %187 to i64*
  %189 = getelementptr i64, i64* %188, i32 1
  %190 = load i64, i64* %189
; # (car (shift Q))
  %191 = inttoptr i64 %190 to i64*
  %192 = load i64, i64* %191
; # (atom (car (shift Q)))
  %193 = and i64 %192, 15
  %194 = icmp ne i64 %193, 0
  br i1 %194, label %$32, label %$31
$32:
  %195 = phi i64 [%183, %$28] ; # X
  %196 = phi i64 [%184, %$28] ; # R
  %197 = phi i64 [%185, %$28] ; # L
  %198 = phi i64 [%186, %$28] ; # P
  %199 = phi i64 [%190, %$28] ; # Q
  br label %$30
$31:
  %200 = phi i64 [%183, %$28] ; # X
  %201 = phi i64 [%184, %$28] ; # R
  %202 = phi i64 [%185, %$28] ; # L
  %203 = phi i64 [%186, %$28] ; # P
  %204 = phi i64 [%190, %$28] ; # Q
; # (set Q (cdr @))
; # (cdr @)
  %205 = inttoptr i64 %192 to i64*
  %206 = getelementptr i64, i64* %205, i32 1
  %207 = load i64, i64* %206
  %208 = inttoptr i64 %204 to i64*
  store i64 %207, i64* %208
; # (atom (set Q (cdr @)))
  %209 = and i64 %207, 15
  %210 = icmp ne i64 %209, 0
  br i1 %210, label %$34, label %$33
$34:
  %211 = phi i64 [%200, %$31] ; # X
  %212 = phi i64 [%201, %$31] ; # R
  %213 = phi i64 [%202, %$31] ; # L
  %214 = phi i64 [%203, %$31] ; # P
  %215 = phi i64 [%204, %$31] ; # Q
  br label %$30
$33:
  %216 = phi i64 [%200, %$31] ; # X
  %217 = phi i64 [%201, %$31] ; # R
  %218 = phi i64 [%202, %$31] ; # L
  %219 = phi i64 [%203, %$31] ; # P
  %220 = phi i64 [%204, %$31] ; # Q
; # (car @)
  %221 = inttoptr i64 %207 to i64*
  %222 = load i64, i64* %221
  br label %$30
$30:
  %223 = phi i64 [%195, %$32], [%211, %$34], [%216, %$33] ; # X
  %224 = phi i64 [%196, %$32], [%212, %$34], [%217, %$33] ; # R
  %225 = phi i64 [%197, %$32], [%213, %$34], [%218, %$33] ; # L
  %226 = phi i64 [%198, %$32], [%214, %$34], [%219, %$33] ; # P
  %227 = phi i64 [%199, %$32], [%215, %$34], [%220, %$33] ; # Q
  %228 = phi i64 [%192, %$32], [%207, %$34], [%222, %$33] ; # ->
  %229 = inttoptr i64 %186 to i64*
  %230 = getelementptr i64, i64* %229, i32 3
  store i64 %228, i64* %230
  br label %$27
$29:
  %231 = phi i64 [%173, %$27] ; # X
  %232 = phi i64 [%174, %$27] ; # R
  %233 = phi i64 [%175, %$27] ; # L
  %234 = phi i64 [%180, %$27] ; # P
  %235 = phi i64 [%177, %$27] ; # Q
  br label %$19
$26:
  %236 = phi i64 [%152, %$21] ; # X
  %237 = phi i64 [%153, %$21] ; # R
  %238 = phi i64 [%154, %$21] ; # L
  %239 = phi i64 [0, %$21] ; # ->
  br label %$18
$18:
  %240 = phi i64 [%112, %$16], [%236, %$26] ; # X
  %241 = phi i64 [%113, %$16], [%237, %$26] ; # R
  %242 = phi i64 [%114, %$16], [%238, %$26] ; # L
; # (drop *Safe)
  %243 = inttoptr i64 %7 to i64*
  %244 = getelementptr i64, i64* %243, i32 1
  %245 = load i64, i64* %244
  %246 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %245, i64* %246
  ret i64 %241
}

define i64 @_Extract(i64) align 8 {
$1:
; # (let (X (cdr Exe) R (save $Nil) L 0 E (push NIL $Nil ZERO (eval (...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (save $Nil)
  %4 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %5 = load i64, i64* %4
  %6 = alloca i64, i64 2, align 16
  %7 = ptrtoint i64* %6 to i64
  %8 = inttoptr i64 %7 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %8
  %9 = add i64 %7, 8
  %10 = inttoptr i64 %9 to i64*
  store i64 %5, i64* %10
  %11 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %7, i64* %11
; # (++ X)
  %12 = inttoptr i64 %3 to i64*
  %13 = load i64, i64* %12
  %14 = getelementptr i64, i64* %12, i32 1
  %15 = load i64, i64* %14
; # (eval (++ X))
  %16 = and i64 %13, 6
  %17 = icmp ne i64 %16, 0
  br i1 %17, label %$4, label %$3
$4:
  br label %$2
$3:
  %18 = and i64 %13, 8
  %19 = icmp ne i64 %18, 0
  br i1 %19, label %$6, label %$5
$6:
  %20 = inttoptr i64 %13 to i64*
  %21 = load i64, i64* %20
  br label %$2
$5:
  %22 = call i64 @evList(i64 %13)
  br label %$2
$2:
  %23 = phi i64 [%13, %$4], [%21, %$6], [%22, %$5] ; # ->
; # (push NIL $Nil ZERO (eval (++ X)) NIL)
  %24 = alloca i64, i64 5, align 16
  %25 = ptrtoint i64* %24 to i64
  %26 = add i64 %25, 8
  %27 = inttoptr i64 %26 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %27
  %28 = add i64 %25, 16
  %29 = inttoptr i64 %28 to i64*
  store i64 2, i64* %29
  %30 = add i64 %25, 24
  %31 = inttoptr i64 %30 to i64*
  store i64 %23, i64* %31
; # (push NIL NIL)
  %32 = alloca i64, i64 2, align 16
  %33 = ptrtoint i64* %32 to i64
; # (set E (link (ofs E 3)))
; # (ofs E 3)
  %34 = add i64 %25, 24
; # (link (ofs E 3))
  %35 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %36 = load i64, i64* %35
  %37 = inttoptr i64 %34 to i64*
  %38 = getelementptr i64, i64* %37, i32 1
  store i64 %36, i64* %38
  %39 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %34, i64* %39
  %40 = inttoptr i64 %25 to i64*
  store i64 %34, i64* %40
; # (let (P E Q A) (loop (let V (set Q (save (eval (car X)))) (when (...
; # (loop (let V (set Q (save (eval (car X)))) (when (pair V) (setq V...
  br label %$7
$7:
  %41 = phi i64 [%15, %$2], [%103, %$15] ; # X
  %42 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%104, %$15] ; # R
  %43 = phi i64 [0, %$2], [%105, %$15] ; # L
  %44 = phi i64 [%25, %$2], [%106, %$15] ; # P
  %45 = phi i64 [%33, %$2], [%109, %$15] ; # Q
; # (let V (set Q (save (eval (car X)))) (when (pair V) (setq V (car ...
; # (set Q (save (eval (car X))))
; # (car X)
  %46 = inttoptr i64 %41 to i64*
  %47 = load i64, i64* %46
; # (eval (car X))
  %48 = and i64 %47, 6
  %49 = icmp ne i64 %48, 0
  br i1 %49, label %$10, label %$9
$10:
  br label %$8
$9:
  %50 = and i64 %47, 8
  %51 = icmp ne i64 %50, 0
  br i1 %51, label %$12, label %$11
$12:
  %52 = inttoptr i64 %47 to i64*
  %53 = load i64, i64* %52
  br label %$8
$11:
  %54 = call i64 @evList(i64 %47)
  br label %$8
$8:
  %55 = phi i64 [%47, %$10], [%53, %$12], [%54, %$11] ; # ->
; # (save (eval (car X)))
  %56 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %57 = load i64, i64* %56
  %58 = alloca i64, i64 2, align 16
  %59 = ptrtoint i64* %58 to i64
  %60 = inttoptr i64 %59 to i64*
  store i64 %55, i64* %60
  %61 = add i64 %59, 8
  %62 = inttoptr i64 %61 to i64*
  store i64 %57, i64* %62
  %63 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %59, i64* %63
  %64 = inttoptr i64 %45 to i64*
  store i64 %55, i64* %64
; # (when (pair V) (setq V (car V)))
; # (pair V)
  %65 = and i64 %55, 15
  %66 = icmp eq i64 %65, 0
  br i1 %66, label %$13, label %$14
$13:
  %67 = phi i64 [%41, %$8] ; # X
  %68 = phi i64 [%42, %$8] ; # R
  %69 = phi i64 [%43, %$8] ; # L
  %70 = phi i64 [%44, %$8] ; # P
  %71 = phi i64 [%45, %$8] ; # Q
  %72 = phi i64 [%55, %$8] ; # V
; # (car V)
  %73 = inttoptr i64 %72 to i64*
  %74 = load i64, i64* %73
  br label %$14
$14:
  %75 = phi i64 [%41, %$8], [%67, %$13] ; # X
  %76 = phi i64 [%42, %$8], [%68, %$13] ; # R
  %77 = phi i64 [%43, %$8], [%69, %$13] ; # L
  %78 = phi i64 [%44, %$8], [%70, %$13] ; # P
  %79 = phi i64 [%45, %$8], [%71, %$13] ; # Q
  %80 = phi i64 [%55, %$8], [%74, %$13] ; # V
; # (set 2 P (push NIL $Nil ZERO V NIL))
; # (push NIL $Nil ZERO V NIL)
  %81 = alloca i64, i64 5, align 16
  %82 = ptrtoint i64* %81 to i64
  %83 = add i64 %82, 8
  %84 = inttoptr i64 %83 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %84
  %85 = add i64 %82, 16
  %86 = inttoptr i64 %85 to i64*
  store i64 2, i64* %86
  %87 = add i64 %82, 24
  %88 = inttoptr i64 %87 to i64*
  store i64 %80, i64* %88
  %89 = inttoptr i64 %78 to i64*
  %90 = getelementptr i64, i64* %89, i32 1
  store i64 %82, i64* %90
; # (set P (link (ofs P 3)))
; # (ofs P 3)
  %91 = add i64 %82, 24
; # (link (ofs P 3))
  %92 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %93 = load i64, i64* %92
  %94 = inttoptr i64 %91 to i64*
  %95 = getelementptr i64, i64* %94, i32 1
  store i64 %93, i64* %95
  %96 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %91, i64* %96
  %97 = inttoptr i64 %82 to i64*
  store i64 %91, i64* %97
; # (? (atom (shift X)))
; # (shift X)
  %98 = inttoptr i64 %75 to i64*
  %99 = getelementptr i64, i64* %98, i32 1
  %100 = load i64, i64* %99
; # (atom (shift X))
  %101 = and i64 %100, 15
  %102 = icmp ne i64 %101, 0
  br i1 %102, label %$16, label %$15
$15:
  %103 = phi i64 [%100, %$14] ; # X
  %104 = phi i64 [%76, %$14] ; # R
  %105 = phi i64 [%77, %$14] ; # L
  %106 = phi i64 [%82, %$14] ; # P
  %107 = phi i64 [%79, %$14] ; # Q
; # (set 2 Q (push NIL NIL))
; # (push NIL NIL)
  %108 = alloca i64, i64 2, align 16
  %109 = ptrtoint i64* %108 to i64
  %110 = inttoptr i64 %107 to i64*
  %111 = getelementptr i64, i64* %110, i32 1
  store i64 %109, i64* %111
  br label %$7
$16:
  %112 = phi i64 [%100, %$14] ; # X
  %113 = phi i64 [%76, %$14] ; # R
  %114 = phi i64 [%77, %$14] ; # L
  %115 = phi i64 [%82, %$14] ; # P
  %116 = phi i64 [%79, %$14] ; # Q
  %117 = phi i64 [0, %$14] ; # ->
; # (when (pair (car A)) (loop (unless (nil? (evList E)) (let Y (cons...
; # (car A)
  %118 = inttoptr i64 %33 to i64*
  %119 = load i64, i64* %118
; # (pair (car A))
  %120 = and i64 %119, 15
  %121 = icmp eq i64 %120, 0
  br i1 %121, label %$17, label %$18
$17:
  %122 = phi i64 [%112, %$16] ; # X
  %123 = phi i64 [%113, %$16] ; # R
  %124 = phi i64 [%114, %$16] ; # L
; # (loop (unless (nil? (evList E)) (let Y (cons @ $Nil) (setq L (if ...
  br label %$19
$19:
  %125 = phi i64 [%122, %$17], [%227, %$29] ; # X
  %126 = phi i64 [%123, %$17], [%228, %$29] ; # R
  %127 = phi i64 [%124, %$17], [%229, %$29] ; # L
; # (unless (nil? (evList E)) (let Y (cons @ $Nil) (setq L (if L (set...
; # (evList E)
  %128 = call i64 @evList(i64 %25)
; # (nil? (evList E))
  %129 = icmp eq i64 %128, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %129, label %$21, label %$20
$20:
  %130 = phi i64 [%125, %$19] ; # X
  %131 = phi i64 [%126, %$19] ; # R
  %132 = phi i64 [%127, %$19] ; # L
; # (let Y (cons @ $Nil) (setq L (if L (set 2 L Y) (setq R (safe Y)))...
; # (cons @ $Nil)
  %133 = call i64 @cons(i64 %128, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (if L (set 2 L Y) (setq R (safe Y)))
  %134 = icmp ne i64 %132, 0
  br i1 %134, label %$22, label %$23
$22:
  %135 = phi i64 [%130, %$20] ; # X
  %136 = phi i64 [%131, %$20] ; # R
  %137 = phi i64 [%132, %$20] ; # L
; # (set 2 L Y)
  %138 = inttoptr i64 %137 to i64*
  %139 = getelementptr i64, i64* %138, i32 1
  store i64 %133, i64* %139
  br label %$24
$23:
  %140 = phi i64 [%130, %$20] ; # X
  %141 = phi i64 [%131, %$20] ; # R
  %142 = phi i64 [%132, %$20] ; # L
; # (safe Y)
  %143 = inttoptr i64 %7 to i64*
  store i64 %133, i64* %143
  br label %$24
$24:
  %144 = phi i64 [%135, %$22], [%140, %$23] ; # X
  %145 = phi i64 [%136, %$22], [%133, %$23] ; # R
  %146 = phi i64 [%137, %$22], [%142, %$23] ; # L
  %147 = phi i64 [%133, %$22], [%133, %$23] ; # ->
  br label %$21
$21:
  %148 = phi i64 [%125, %$19], [%144, %$24] ; # X
  %149 = phi i64 [%126, %$19], [%145, %$24] ; # R
  %150 = phi i64 [%127, %$19], [%147, %$24] ; # L
; # (? (atom (set A (cdar A))))
; # (set A (cdar A))
; # (cdar A)
  %151 = inttoptr i64 %33 to i64*
  %152 = load i64, i64* %151
  %153 = inttoptr i64 %152 to i64*
  %154 = getelementptr i64, i64* %153, i32 1
  %155 = load i64, i64* %154
  %156 = inttoptr i64 %33 to i64*
  store i64 %155, i64* %156
; # (atom (set A (cdar A)))
  %157 = and i64 %155, 15
  %158 = icmp ne i64 %157, 0
  br i1 %158, label %$26, label %$25
$25:
  %159 = phi i64 [%148, %$21] ; # X
  %160 = phi i64 [%149, %$21] ; # R
  %161 = phi i64 [%150, %$21] ; # L
; # (let (P (cdr E) Q A) (set 4 P (car @)) (while (pair (shift P)) (s...
; # (cdr E)
  %162 = inttoptr i64 %25 to i64*
  %163 = getelementptr i64, i64* %162, i32 1
  %164 = load i64, i64* %163
; # (set 4 P (car @))
; # (car @)
  %165 = inttoptr i64 %155 to i64*
  %166 = load i64, i64* %165
  %167 = inttoptr i64 %164 to i64*
  %168 = getelementptr i64, i64* %167, i32 3
  store i64 %166, i64* %168
; # (while (pair (shift P)) (set 4 P (cond ((atom (car (shift Q))) @)...
  br label %$27
$27:
  %169 = phi i64 [%159, %$25], [%219, %$30] ; # X
  %170 = phi i64 [%160, %$25], [%220, %$30] ; # R
  %171 = phi i64 [%161, %$25], [%221, %$30] ; # L
  %172 = phi i64 [%164, %$25], [%222, %$30] ; # P
  %173 = phi i64 [%33, %$25], [%223, %$30] ; # Q
; # (shift P)
  %174 = inttoptr i64 %172 to i64*
  %175 = getelementptr i64, i64* %174, i32 1
  %176 = load i64, i64* %175
; # (pair (shift P))
  %177 = and i64 %176, 15
  %178 = icmp eq i64 %177, 0
  br i1 %178, label %$28, label %$29
$28:
  %179 = phi i64 [%169, %$27] ; # X
  %180 = phi i64 [%170, %$27] ; # R
  %181 = phi i64 [%171, %$27] ; # L
  %182 = phi i64 [%176, %$27] ; # P
  %183 = phi i64 [%173, %$27] ; # Q
; # (set 4 P (cond ((atom (car (shift Q))) @) ((atom (set Q (cdr @)))...
; # (cond ((atom (car (shift Q))) @) ((atom (set Q (cdr @))) @) (T (c...
; # (shift Q)
  %184 = inttoptr i64 %183 to i64*
  %185 = getelementptr i64, i64* %184, i32 1
  %186 = load i64, i64* %185
; # (car (shift Q))
  %187 = inttoptr i64 %186 to i64*
  %188 = load i64, i64* %187
; # (atom (car (shift Q)))
  %189 = and i64 %188, 15
  %190 = icmp ne i64 %189, 0
  br i1 %190, label %$32, label %$31
$32:
  %191 = phi i64 [%179, %$28] ; # X
  %192 = phi i64 [%180, %$28] ; # R
  %193 = phi i64 [%181, %$28] ; # L
  %194 = phi i64 [%182, %$28] ; # P
  %195 = phi i64 [%186, %$28] ; # Q
  br label %$30
$31:
  %196 = phi i64 [%179, %$28] ; # X
  %197 = phi i64 [%180, %$28] ; # R
  %198 = phi i64 [%181, %$28] ; # L
  %199 = phi i64 [%182, %$28] ; # P
  %200 = phi i64 [%186, %$28] ; # Q
; # (set Q (cdr @))
; # (cdr @)
  %201 = inttoptr i64 %188 to i64*
  %202 = getelementptr i64, i64* %201, i32 1
  %203 = load i64, i64* %202
  %204 = inttoptr i64 %200 to i64*
  store i64 %203, i64* %204
; # (atom (set Q (cdr @)))
  %205 = and i64 %203, 15
  %206 = icmp ne i64 %205, 0
  br i1 %206, label %$34, label %$33
$34:
  %207 = phi i64 [%196, %$31] ; # X
  %208 = phi i64 [%197, %$31] ; # R
  %209 = phi i64 [%198, %$31] ; # L
  %210 = phi i64 [%199, %$31] ; # P
  %211 = phi i64 [%200, %$31] ; # Q
  br label %$30
$33:
  %212 = phi i64 [%196, %$31] ; # X
  %213 = phi i64 [%197, %$31] ; # R
  %214 = phi i64 [%198, %$31] ; # L
  %215 = phi i64 [%199, %$31] ; # P
  %216 = phi i64 [%200, %$31] ; # Q
; # (car @)
  %217 = inttoptr i64 %203 to i64*
  %218 = load i64, i64* %217
  br label %$30
$30:
  %219 = phi i64 [%191, %$32], [%207, %$34], [%212, %$33] ; # X
  %220 = phi i64 [%192, %$32], [%208, %$34], [%213, %$33] ; # R
  %221 = phi i64 [%193, %$32], [%209, %$34], [%214, %$33] ; # L
  %222 = phi i64 [%194, %$32], [%210, %$34], [%215, %$33] ; # P
  %223 = phi i64 [%195, %$32], [%211, %$34], [%216, %$33] ; # Q
  %224 = phi i64 [%188, %$32], [%203, %$34], [%218, %$33] ; # ->
  %225 = inttoptr i64 %182 to i64*
  %226 = getelementptr i64, i64* %225, i32 3
  store i64 %224, i64* %226
  br label %$27
$29:
  %227 = phi i64 [%169, %$27] ; # X
  %228 = phi i64 [%170, %$27] ; # R
  %229 = phi i64 [%171, %$27] ; # L
  %230 = phi i64 [%176, %$27] ; # P
  %231 = phi i64 [%173, %$27] ; # Q
  br label %$19
$26:
  %232 = phi i64 [%148, %$21] ; # X
  %233 = phi i64 [%149, %$21] ; # R
  %234 = phi i64 [%150, %$21] ; # L
  %235 = phi i64 [0, %$21] ; # ->
  br label %$18
$18:
  %236 = phi i64 [%112, %$16], [%232, %$26] ; # X
  %237 = phi i64 [%113, %$16], [%233, %$26] ; # R
  %238 = phi i64 [%114, %$16], [%234, %$26] ; # L
; # (drop *Safe)
  %239 = inttoptr i64 %7 to i64*
  %240 = getelementptr i64, i64* %239, i32 1
  %241 = load i64, i64* %240
  %242 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %241, i64* %242
  ret i64 %237
}

define i64 @_Seek(i64) align 8 {
$1:
; # (let (X (cdr Exe) E (push NIL $Nil ZERO (eval (car X)) NIL)) (set...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (car X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (car X))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (push NIL $Nil ZERO (eval (car X)) NIL)
  %14 = alloca i64, i64 5, align 16
  %15 = ptrtoint i64* %14 to i64
  %16 = add i64 %15, 8
  %17 = inttoptr i64 %16 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %17
  %18 = add i64 %15, 16
  %19 = inttoptr i64 %18 to i64*
  store i64 2, i64* %19
  %20 = add i64 %15, 24
  %21 = inttoptr i64 %20 to i64*
  store i64 %13, i64* %21
; # (set E (link (ofs E 3) T))
; # (ofs E 3)
  %22 = add i64 %15, 24
; # (link (ofs E 3) T)
  %23 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %24 = load i64, i64* %23
  %25 = inttoptr i64 %22 to i64*
  %26 = getelementptr i64, i64* %25, i32 1
  store i64 %24, i64* %26
  %27 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %22, i64* %27
  %28 = inttoptr i64 %15 to i64*
  store i64 %22, i64* %28
; # (let P E (while (pair (shift X)) (setq P (set 2 P (push NIL $Nil ...
; # (while (pair (shift X)) (setq P (set 2 P (push NIL $Nil ZERO (eva...
  br label %$7
$7:
  %29 = phi i64 [%3, %$2], [%36, %$10] ; # X
  %30 = phi i64 [%15, %$2], [%49, %$10] ; # P
; # (shift X)
  %31 = inttoptr i64 %29 to i64*
  %32 = getelementptr i64, i64* %31, i32 1
  %33 = load i64, i64* %32
; # (pair (shift X))
  %34 = and i64 %33, 15
  %35 = icmp eq i64 %34, 0
  br i1 %35, label %$8, label %$9
$8:
  %36 = phi i64 [%33, %$7] ; # X
  %37 = phi i64 [%30, %$7] ; # P
; # (set 2 P (push NIL $Nil ZERO (eval (car X)) NIL))
; # (car X)
  %38 = inttoptr i64 %36 to i64*
  %39 = load i64, i64* %38
; # (eval (car X))
  %40 = and i64 %39, 6
  %41 = icmp ne i64 %40, 0
  br i1 %41, label %$12, label %$11
$12:
  br label %$10
$11:
  %42 = and i64 %39, 8
  %43 = icmp ne i64 %42, 0
  br i1 %43, label %$14, label %$13
$14:
  %44 = inttoptr i64 %39 to i64*
  %45 = load i64, i64* %44
  br label %$10
$13:
  %46 = call i64 @evList(i64 %39)
  br label %$10
$10:
  %47 = phi i64 [%39, %$12], [%45, %$14], [%46, %$13] ; # ->
; # (push NIL $Nil ZERO (eval (car X)) NIL)
  %48 = alloca i64, i64 5, align 16
  %49 = ptrtoint i64* %48 to i64
  %50 = add i64 %49, 8
  %51 = inttoptr i64 %50 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %51
  %52 = add i64 %49, 16
  %53 = inttoptr i64 %52 to i64*
  store i64 2, i64* %53
  %54 = add i64 %49, 24
  %55 = inttoptr i64 %54 to i64*
  store i64 %47, i64* %55
  %56 = inttoptr i64 %37 to i64*
  %57 = getelementptr i64, i64* %56, i32 1
  store i64 %49, i64* %57
; # (set P (link (ofs P 3)))
; # (ofs P 3)
  %58 = add i64 %49, 24
; # (link (ofs P 3))
  %59 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %60 = load i64, i64* %59
  %61 = inttoptr i64 %58 to i64*
  %62 = getelementptr i64, i64* %61, i32 1
  store i64 %60, i64* %62
  %63 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %58, i64* %63
  %64 = inttoptr i64 %49 to i64*
  store i64 %58, i64* %64
  br label %$7
$9:
  %65 = phi i64 [%33, %$7] ; # X
  %66 = phi i64 [%30, %$7] ; # P
; # (loop (let P (cdr E) (? (atom (val 4 P)) $Nil) (? (not (nil? (evL...
  br label %$15
$15:
  %67 = phi i64 [%65, %$9], [%114, %$25] ; # X
; # (let P (cdr E) (? (atom (val 4 P)) $Nil) (? (not (nil? (evList E)...
; # (cdr E)
  %68 = inttoptr i64 %15 to i64*
  %69 = getelementptr i64, i64* %68, i32 1
  %70 = load i64, i64* %69
; # (? (atom (val 4 P)) $Nil)
; # (val 4 P)
  %71 = inttoptr i64 %70 to i64*
  %72 = getelementptr i64, i64* %71, i32 3
  %73 = load i64, i64* %72
; # (atom (val 4 P))
  %74 = and i64 %73, 15
  %75 = icmp ne i64 %74, 0
  br i1 %75, label %$18, label %$16
$18:
  %76 = phi i64 [%67, %$15] ; # X
  %77 = phi i64 [%70, %$15] ; # P
  br label %$17
$16:
  %78 = phi i64 [%67, %$15] ; # X
  %79 = phi i64 [%70, %$15] ; # P
; # (? (not (nil? (evList E))) (set $At2 @) (val 4 P))
; # (evList E)
  %80 = call i64 @evList(i64 %15)
; # (nil? (evList E))
  %81 = icmp eq i64 %80, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
; # (not (nil? (evList E)))
  %82 = icmp eq i1 %81, 0
  br i1 %82, label %$20, label %$19
$20:
  %83 = phi i64 [%78, %$16] ; # X
  %84 = phi i64 [%79, %$16] ; # P
; # (set $At2 @)
  %85 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 456) to i64) to i64*
  store i64 %80, i64* %85
; # (val 4 P)
  %86 = inttoptr i64 %84 to i64*
  %87 = getelementptr i64, i64* %86, i32 3
  %88 = load i64, i64* %87
  br label %$17
$19:
  %89 = phi i64 [%78, %$16] ; # X
  %90 = phi i64 [%79, %$16] ; # P
; # (loop (when (pair (val 4 P)) (set 4 P (cdr @))) (? (atom (shift P...
  br label %$21
$21:
  %91 = phi i64 [%89, %$19], [%112, %$24] ; # X
  %92 = phi i64 [%90, %$19], [%113, %$24] ; # P
; # (when (pair (val 4 P)) (set 4 P (cdr @)))
; # (val 4 P)
  %93 = inttoptr i64 %92 to i64*
  %94 = getelementptr i64, i64* %93, i32 3
  %95 = load i64, i64* %94
; # (pair (val 4 P))
  %96 = and i64 %95, 15
  %97 = icmp eq i64 %96, 0
  br i1 %97, label %$22, label %$23
$22:
  %98 = phi i64 [%91, %$21] ; # X
  %99 = phi i64 [%92, %$21] ; # P
; # (set 4 P (cdr @))
; # (cdr @)
  %100 = inttoptr i64 %95 to i64*
  %101 = getelementptr i64, i64* %100, i32 1
  %102 = load i64, i64* %101
  %103 = inttoptr i64 %99 to i64*
  %104 = getelementptr i64, i64* %103, i32 3
  store i64 %102, i64* %104
  br label %$23
$23:
  %105 = phi i64 [%91, %$21], [%98, %$22] ; # X
  %106 = phi i64 [%92, %$21], [%99, %$22] ; # P
; # (? (atom (shift P)))
; # (shift P)
  %107 = inttoptr i64 %106 to i64*
  %108 = getelementptr i64, i64* %107, i32 1
  %109 = load i64, i64* %108
; # (atom (shift P))
  %110 = and i64 %109, 15
  %111 = icmp ne i64 %110, 0
  br i1 %111, label %$25, label %$24
$24:
  %112 = phi i64 [%105, %$23] ; # X
  %113 = phi i64 [%109, %$23] ; # P
  br label %$21
$25:
  %114 = phi i64 [%105, %$23] ; # X
  %115 = phi i64 [%109, %$23] ; # P
  %116 = phi i64 [0, %$23] ; # ->
  br label %$15
$17:
  %117 = phi i64 [%76, %$18], [%83, %$20] ; # X
  %118 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$18], [%88, %$20] ; # ->
; # (drop *Safe)
  %119 = inttoptr i64 %22 to i64*
  %120 = getelementptr i64, i64* %119, i32 1
  %121 = load i64, i64* %120
  %122 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %121, i64* %122
  ret i64 %118
}

define i64 @_Find(i64) align 8 {
$1:
; # (let (X (cdr Exe) E (push NIL $Nil ZERO (eval (++ X)) NIL) A (pus...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (push NIL $Nil ZERO (eval (++ X)) NIL)
  %16 = alloca i64, i64 5, align 16
  %17 = ptrtoint i64* %16 to i64
  %18 = add i64 %17, 8
  %19 = inttoptr i64 %18 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %19
  %20 = add i64 %17, 16
  %21 = inttoptr i64 %20 to i64*
  store i64 2, i64* %21
  %22 = add i64 %17, 24
  %23 = inttoptr i64 %22 to i64*
  store i64 %15, i64* %23
; # (push NIL NIL)
  %24 = alloca i64, i64 2, align 16
  %25 = ptrtoint i64* %24 to i64
; # (set E (link (ofs E 3) T))
; # (ofs E 3)
  %26 = add i64 %17, 24
; # (link (ofs E 3) T)
  %27 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %28 = load i64, i64* %27
  %29 = inttoptr i64 %26 to i64*
  %30 = getelementptr i64, i64* %29, i32 1
  store i64 %28, i64* %30
  %31 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %26, i64* %31
  %32 = inttoptr i64 %17 to i64*
  store i64 %26, i64* %32
; # (let (P E Q A) (loop (let V (set Q (save (eval (car X)))) (when (...
; # (loop (let V (set Q (save (eval (car X)))) (when (pair V) (setq V...
  br label %$7
$7:
  %33 = phi i64 [%7, %$2], [%89, %$15] ; # X
  %34 = phi i64 [%17, %$2], [%90, %$15] ; # P
  %35 = phi i64 [%25, %$2], [%93, %$15] ; # Q
; # (let V (set Q (save (eval (car X)))) (when (pair V) (setq V (car ...
; # (set Q (save (eval (car X))))
; # (car X)
  %36 = inttoptr i64 %33 to i64*
  %37 = load i64, i64* %36
; # (eval (car X))
  %38 = and i64 %37, 6
  %39 = icmp ne i64 %38, 0
  br i1 %39, label %$10, label %$9
$10:
  br label %$8
$9:
  %40 = and i64 %37, 8
  %41 = icmp ne i64 %40, 0
  br i1 %41, label %$12, label %$11
$12:
  %42 = inttoptr i64 %37 to i64*
  %43 = load i64, i64* %42
  br label %$8
$11:
  %44 = call i64 @evList(i64 %37)
  br label %$8
$8:
  %45 = phi i64 [%37, %$10], [%43, %$12], [%44, %$11] ; # ->
; # (save (eval (car X)))
  %46 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %47 = load i64, i64* %46
  %48 = alloca i64, i64 2, align 16
  %49 = ptrtoint i64* %48 to i64
  %50 = inttoptr i64 %49 to i64*
  store i64 %45, i64* %50
  %51 = add i64 %49, 8
  %52 = inttoptr i64 %51 to i64*
  store i64 %47, i64* %52
  %53 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %49, i64* %53
  %54 = inttoptr i64 %35 to i64*
  store i64 %45, i64* %54
; # (when (pair V) (setq V (car V)))
; # (pair V)
  %55 = and i64 %45, 15
  %56 = icmp eq i64 %55, 0
  br i1 %56, label %$13, label %$14
$13:
  %57 = phi i64 [%33, %$8] ; # X
  %58 = phi i64 [%34, %$8] ; # P
  %59 = phi i64 [%35, %$8] ; # Q
  %60 = phi i64 [%45, %$8] ; # V
; # (car V)
  %61 = inttoptr i64 %60 to i64*
  %62 = load i64, i64* %61
  br label %$14
$14:
  %63 = phi i64 [%33, %$8], [%57, %$13] ; # X
  %64 = phi i64 [%34, %$8], [%58, %$13] ; # P
  %65 = phi i64 [%35, %$8], [%59, %$13] ; # Q
  %66 = phi i64 [%45, %$8], [%62, %$13] ; # V
; # (set 2 P (push NIL $Nil ZERO V NIL))
; # (push NIL $Nil ZERO V NIL)
  %67 = alloca i64, i64 5, align 16
  %68 = ptrtoint i64* %67 to i64
  %69 = add i64 %68, 8
  %70 = inttoptr i64 %69 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %70
  %71 = add i64 %68, 16
  %72 = inttoptr i64 %71 to i64*
  store i64 2, i64* %72
  %73 = add i64 %68, 24
  %74 = inttoptr i64 %73 to i64*
  store i64 %66, i64* %74
  %75 = inttoptr i64 %64 to i64*
  %76 = getelementptr i64, i64* %75, i32 1
  store i64 %68, i64* %76
; # (set P (link (ofs P 3)))
; # (ofs P 3)
  %77 = add i64 %68, 24
; # (link (ofs P 3))
  %78 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %79 = load i64, i64* %78
  %80 = inttoptr i64 %77 to i64*
  %81 = getelementptr i64, i64* %80, i32 1
  store i64 %79, i64* %81
  %82 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %77, i64* %82
  %83 = inttoptr i64 %68 to i64*
  store i64 %77, i64* %83
; # (? (atom (shift X)))
; # (shift X)
  %84 = inttoptr i64 %63 to i64*
  %85 = getelementptr i64, i64* %84, i32 1
  %86 = load i64, i64* %85
; # (atom (shift X))
  %87 = and i64 %86, 15
  %88 = icmp ne i64 %87, 0
  br i1 %88, label %$16, label %$15
$15:
  %89 = phi i64 [%86, %$14] ; # X
  %90 = phi i64 [%68, %$14] ; # P
  %91 = phi i64 [%65, %$14] ; # Q
; # (set 2 Q (push NIL NIL))
; # (push NIL NIL)
  %92 = alloca i64, i64 2, align 16
  %93 = ptrtoint i64* %92 to i64
  %94 = inttoptr i64 %91 to i64*
  %95 = getelementptr i64, i64* %94, i32 1
  store i64 %93, i64* %95
  br label %$7
$16:
  %96 = phi i64 [%86, %$14] ; # X
  %97 = phi i64 [%68, %$14] ; # P
  %98 = phi i64 [%65, %$14] ; # Q
  %99 = phi i64 [0, %$14] ; # ->
; # (if (atom (car A)) $Nil (loop (? (not (nil? (evList E))) (set $At...
; # (car A)
  %100 = inttoptr i64 %25 to i64*
  %101 = load i64, i64* %100
; # (atom (car A))
  %102 = and i64 %101, 15
  %103 = icmp ne i64 %102, 0
  br i1 %103, label %$17, label %$18
$17:
  %104 = phi i64 [%96, %$16] ; # X
  br label %$19
$18:
  %105 = phi i64 [%96, %$16] ; # X
; # (loop (? (not (nil? (evList E))) (set $At2 @) (caar A)) (? (atom ...
  br label %$20
$20:
  %106 = phi i64 [%105, %$18], [%178, %$28] ; # X
; # (? (not (nil? (evList E))) (set $At2 @) (caar A))
; # (evList E)
  %107 = call i64 @evList(i64 %17)
; # (nil? (evList E))
  %108 = icmp eq i64 %107, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
; # (not (nil? (evList E)))
  %109 = icmp eq i1 %108, 0
  br i1 %109, label %$23, label %$21
$23:
  %110 = phi i64 [%106, %$20] ; # X
; # (set $At2 @)
  %111 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 456) to i64) to i64*
  store i64 %107, i64* %111
; # (caar A)
  %112 = inttoptr i64 %25 to i64*
  %113 = load i64, i64* %112
  %114 = inttoptr i64 %113 to i64*
  %115 = load i64, i64* %114
  br label %$22
$21:
  %116 = phi i64 [%106, %$20] ; # X
; # (? (atom (set A (cdar A))) $Nil)
; # (set A (cdar A))
; # (cdar A)
  %117 = inttoptr i64 %25 to i64*
  %118 = load i64, i64* %117
  %119 = inttoptr i64 %118 to i64*
  %120 = getelementptr i64, i64* %119, i32 1
  %121 = load i64, i64* %120
  %122 = inttoptr i64 %25 to i64*
  store i64 %121, i64* %122
; # (atom (set A (cdar A)))
  %123 = and i64 %121, 15
  %124 = icmp ne i64 %123, 0
  br i1 %124, label %$25, label %$24
$25:
  %125 = phi i64 [%116, %$21] ; # X
  br label %$22
$24:
  %126 = phi i64 [%116, %$21] ; # X
; # (let (P (cdr E) Q A) (set 4 P (car @)) (while (pair (shift P)) (s...
; # (cdr E)
  %127 = inttoptr i64 %17 to i64*
  %128 = getelementptr i64, i64* %127, i32 1
  %129 = load i64, i64* %128
; # (set 4 P (car @))
; # (car @)
  %130 = inttoptr i64 %121 to i64*
  %131 = load i64, i64* %130
  %132 = inttoptr i64 %129 to i64*
  %133 = getelementptr i64, i64* %132, i32 3
  store i64 %131, i64* %133
; # (while (pair (shift P)) (set 4 P (cond ((atom (car (shift Q))) @)...
  br label %$26
$26:
  %134 = phi i64 [%126, %$24], [%172, %$29] ; # X
  %135 = phi i64 [%129, %$24], [%173, %$29] ; # P
  %136 = phi i64 [%25, %$24], [%174, %$29] ; # Q
; # (shift P)
  %137 = inttoptr i64 %135 to i64*
  %138 = getelementptr i64, i64* %137, i32 1
  %139 = load i64, i64* %138
; # (pair (shift P))
  %140 = and i64 %139, 15
  %141 = icmp eq i64 %140, 0
  br i1 %141, label %$27, label %$28
$27:
  %142 = phi i64 [%134, %$26] ; # X
  %143 = phi i64 [%139, %$26] ; # P
  %144 = phi i64 [%136, %$26] ; # Q
; # (set 4 P (cond ((atom (car (shift Q))) @) ((atom (set Q (cdr @)))...
; # (cond ((atom (car (shift Q))) @) ((atom (set Q (cdr @))) @) (T (c...
; # (shift Q)
  %145 = inttoptr i64 %144 to i64*
  %146 = getelementptr i64, i64* %145, i32 1
  %147 = load i64, i64* %146
; # (car (shift Q))
  %148 = inttoptr i64 %147 to i64*
  %149 = load i64, i64* %148
; # (atom (car (shift Q)))
  %150 = and i64 %149, 15
  %151 = icmp ne i64 %150, 0
  br i1 %151, label %$31, label %$30
$31:
  %152 = phi i64 [%142, %$27] ; # X
  %153 = phi i64 [%143, %$27] ; # P
  %154 = phi i64 [%147, %$27] ; # Q
  br label %$29
$30:
  %155 = phi i64 [%142, %$27] ; # X
  %156 = phi i64 [%143, %$27] ; # P
  %157 = phi i64 [%147, %$27] ; # Q
; # (set Q (cdr @))
; # (cdr @)
  %158 = inttoptr i64 %149 to i64*
  %159 = getelementptr i64, i64* %158, i32 1
  %160 = load i64, i64* %159
  %161 = inttoptr i64 %157 to i64*
  store i64 %160, i64* %161
; # (atom (set Q (cdr @)))
  %162 = and i64 %160, 15
  %163 = icmp ne i64 %162, 0
  br i1 %163, label %$33, label %$32
$33:
  %164 = phi i64 [%155, %$30] ; # X
  %165 = phi i64 [%156, %$30] ; # P
  %166 = phi i64 [%157, %$30] ; # Q
  br label %$29
$32:
  %167 = phi i64 [%155, %$30] ; # X
  %168 = phi i64 [%156, %$30] ; # P
  %169 = phi i64 [%157, %$30] ; # Q
; # (car @)
  %170 = inttoptr i64 %160 to i64*
  %171 = load i64, i64* %170
  br label %$29
$29:
  %172 = phi i64 [%152, %$31], [%164, %$33], [%167, %$32] ; # X
  %173 = phi i64 [%153, %$31], [%165, %$33], [%168, %$32] ; # P
  %174 = phi i64 [%154, %$31], [%166, %$33], [%169, %$32] ; # Q
  %175 = phi i64 [%149, %$31], [%160, %$33], [%171, %$32] ; # ->
  %176 = inttoptr i64 %143 to i64*
  %177 = getelementptr i64, i64* %176, i32 3
  store i64 %175, i64* %177
  br label %$26
$28:
  %178 = phi i64 [%134, %$26] ; # X
  %179 = phi i64 [%139, %$26] ; # P
  %180 = phi i64 [%136, %$26] ; # Q
  br label %$20
$22:
  %181 = phi i64 [%110, %$23], [%125, %$25] ; # X
  %182 = phi i64 [%115, %$23], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$25] ; # ->
  br label %$19
$19:
  %183 = phi i64 [%104, %$17], [%181, %$22] ; # X
  %184 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$17], [%182, %$22] ; # ->
; # (drop *Safe)
  %185 = inttoptr i64 %26 to i64*
  %186 = getelementptr i64, i64* %185, i32 1
  %187 = load i64, i64* %186
  %188 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %187, i64* %188
  ret i64 %184
}

define i64 @_Pick(i64) align 8 {
$1:
; # (let (X (cdr Exe) E (push NIL $Nil ZERO (eval (++ X)) NIL) A (pus...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (push NIL $Nil ZERO (eval (++ X)) NIL)
  %16 = alloca i64, i64 5, align 16
  %17 = ptrtoint i64* %16 to i64
  %18 = add i64 %17, 8
  %19 = inttoptr i64 %18 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %19
  %20 = add i64 %17, 16
  %21 = inttoptr i64 %20 to i64*
  store i64 2, i64* %21
  %22 = add i64 %17, 24
  %23 = inttoptr i64 %22 to i64*
  store i64 %15, i64* %23
; # (push NIL NIL)
  %24 = alloca i64, i64 2, align 16
  %25 = ptrtoint i64* %24 to i64
; # (set E (link (ofs E 3) T))
; # (ofs E 3)
  %26 = add i64 %17, 24
; # (link (ofs E 3) T)
  %27 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %28 = load i64, i64* %27
  %29 = inttoptr i64 %26 to i64*
  %30 = getelementptr i64, i64* %29, i32 1
  store i64 %28, i64* %30
  %31 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %26, i64* %31
  %32 = inttoptr i64 %17 to i64*
  store i64 %26, i64* %32
; # (let (P E Q A) (loop (let V (set Q (save (eval (car X)))) (when (...
; # (loop (let V (set Q (save (eval (car X)))) (when (pair V) (setq V...
  br label %$7
$7:
  %33 = phi i64 [%7, %$2], [%89, %$15] ; # X
  %34 = phi i64 [%17, %$2], [%90, %$15] ; # P
  %35 = phi i64 [%25, %$2], [%93, %$15] ; # Q
; # (let V (set Q (save (eval (car X)))) (when (pair V) (setq V (car ...
; # (set Q (save (eval (car X))))
; # (car X)
  %36 = inttoptr i64 %33 to i64*
  %37 = load i64, i64* %36
; # (eval (car X))
  %38 = and i64 %37, 6
  %39 = icmp ne i64 %38, 0
  br i1 %39, label %$10, label %$9
$10:
  br label %$8
$9:
  %40 = and i64 %37, 8
  %41 = icmp ne i64 %40, 0
  br i1 %41, label %$12, label %$11
$12:
  %42 = inttoptr i64 %37 to i64*
  %43 = load i64, i64* %42
  br label %$8
$11:
  %44 = call i64 @evList(i64 %37)
  br label %$8
$8:
  %45 = phi i64 [%37, %$10], [%43, %$12], [%44, %$11] ; # ->
; # (save (eval (car X)))
  %46 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %47 = load i64, i64* %46
  %48 = alloca i64, i64 2, align 16
  %49 = ptrtoint i64* %48 to i64
  %50 = inttoptr i64 %49 to i64*
  store i64 %45, i64* %50
  %51 = add i64 %49, 8
  %52 = inttoptr i64 %51 to i64*
  store i64 %47, i64* %52
  %53 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %49, i64* %53
  %54 = inttoptr i64 %35 to i64*
  store i64 %45, i64* %54
; # (when (pair V) (setq V (car V)))
; # (pair V)
  %55 = and i64 %45, 15
  %56 = icmp eq i64 %55, 0
  br i1 %56, label %$13, label %$14
$13:
  %57 = phi i64 [%33, %$8] ; # X
  %58 = phi i64 [%34, %$8] ; # P
  %59 = phi i64 [%35, %$8] ; # Q
  %60 = phi i64 [%45, %$8] ; # V
; # (car V)
  %61 = inttoptr i64 %60 to i64*
  %62 = load i64, i64* %61
  br label %$14
$14:
  %63 = phi i64 [%33, %$8], [%57, %$13] ; # X
  %64 = phi i64 [%34, %$8], [%58, %$13] ; # P
  %65 = phi i64 [%35, %$8], [%59, %$13] ; # Q
  %66 = phi i64 [%45, %$8], [%62, %$13] ; # V
; # (set 2 P (push NIL $Nil ZERO V NIL))
; # (push NIL $Nil ZERO V NIL)
  %67 = alloca i64, i64 5, align 16
  %68 = ptrtoint i64* %67 to i64
  %69 = add i64 %68, 8
  %70 = inttoptr i64 %69 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %70
  %71 = add i64 %68, 16
  %72 = inttoptr i64 %71 to i64*
  store i64 2, i64* %72
  %73 = add i64 %68, 24
  %74 = inttoptr i64 %73 to i64*
  store i64 %66, i64* %74
  %75 = inttoptr i64 %64 to i64*
  %76 = getelementptr i64, i64* %75, i32 1
  store i64 %68, i64* %76
; # (set P (link (ofs P 3)))
; # (ofs P 3)
  %77 = add i64 %68, 24
; # (link (ofs P 3))
  %78 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %79 = load i64, i64* %78
  %80 = inttoptr i64 %77 to i64*
  %81 = getelementptr i64, i64* %80, i32 1
  store i64 %79, i64* %81
  %82 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %77, i64* %82
  %83 = inttoptr i64 %68 to i64*
  store i64 %77, i64* %83
; # (? (atom (shift X)))
; # (shift X)
  %84 = inttoptr i64 %63 to i64*
  %85 = getelementptr i64, i64* %84, i32 1
  %86 = load i64, i64* %85
; # (atom (shift X))
  %87 = and i64 %86, 15
  %88 = icmp ne i64 %87, 0
  br i1 %88, label %$16, label %$15
$15:
  %89 = phi i64 [%86, %$14] ; # X
  %90 = phi i64 [%68, %$14] ; # P
  %91 = phi i64 [%65, %$14] ; # Q
; # (set 2 Q (push NIL NIL))
; # (push NIL NIL)
  %92 = alloca i64, i64 2, align 16
  %93 = ptrtoint i64* %92 to i64
  %94 = inttoptr i64 %91 to i64*
  %95 = getelementptr i64, i64* %94, i32 1
  store i64 %93, i64* %95
  br label %$7
$16:
  %96 = phi i64 [%86, %$14] ; # X
  %97 = phi i64 [%68, %$14] ; # P
  %98 = phi i64 [%65, %$14] ; # Q
  %99 = phi i64 [0, %$14] ; # ->
; # (if (atom (car A)) $Nil (loop (? (not (nil? (evList E))) @) (? (a...
; # (car A)
  %100 = inttoptr i64 %25 to i64*
  %101 = load i64, i64* %100
; # (atom (car A))
  %102 = and i64 %101, 15
  %103 = icmp ne i64 %102, 0
  br i1 %103, label %$17, label %$18
$17:
  %104 = phi i64 [%96, %$16] ; # X
  br label %$19
$18:
  %105 = phi i64 [%96, %$16] ; # X
; # (loop (? (not (nil? (evList E))) @) (? (atom (set A (cdar A))) $N...
  br label %$20
$20:
  %106 = phi i64 [%105, %$18], [%173, %$28] ; # X
; # (? (not (nil? (evList E))) @)
; # (evList E)
  %107 = call i64 @evList(i64 %17)
; # (nil? (evList E))
  %108 = icmp eq i64 %107, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
; # (not (nil? (evList E)))
  %109 = icmp eq i1 %108, 0
  br i1 %109, label %$23, label %$21
$23:
  %110 = phi i64 [%106, %$20] ; # X
  br label %$22
$21:
  %111 = phi i64 [%106, %$20] ; # X
; # (? (atom (set A (cdar A))) $Nil)
; # (set A (cdar A))
; # (cdar A)
  %112 = inttoptr i64 %25 to i64*
  %113 = load i64, i64* %112
  %114 = inttoptr i64 %113 to i64*
  %115 = getelementptr i64, i64* %114, i32 1
  %116 = load i64, i64* %115
  %117 = inttoptr i64 %25 to i64*
  store i64 %116, i64* %117
; # (atom (set A (cdar A)))
  %118 = and i64 %116, 15
  %119 = icmp ne i64 %118, 0
  br i1 %119, label %$25, label %$24
$25:
  %120 = phi i64 [%111, %$21] ; # X
  br label %$22
$24:
  %121 = phi i64 [%111, %$21] ; # X
; # (let (P (cdr E) Q A) (set 4 P (car @)) (while (pair (shift P)) (s...
; # (cdr E)
  %122 = inttoptr i64 %17 to i64*
  %123 = getelementptr i64, i64* %122, i32 1
  %124 = load i64, i64* %123
; # (set 4 P (car @))
; # (car @)
  %125 = inttoptr i64 %116 to i64*
  %126 = load i64, i64* %125
  %127 = inttoptr i64 %124 to i64*
  %128 = getelementptr i64, i64* %127, i32 3
  store i64 %126, i64* %128
; # (while (pair (shift P)) (set 4 P (cond ((atom (car (shift Q))) @)...
  br label %$26
$26:
  %129 = phi i64 [%121, %$24], [%167, %$29] ; # X
  %130 = phi i64 [%124, %$24], [%168, %$29] ; # P
  %131 = phi i64 [%25, %$24], [%169, %$29] ; # Q
; # (shift P)
  %132 = inttoptr i64 %130 to i64*
  %133 = getelementptr i64, i64* %132, i32 1
  %134 = load i64, i64* %133
; # (pair (shift P))
  %135 = and i64 %134, 15
  %136 = icmp eq i64 %135, 0
  br i1 %136, label %$27, label %$28
$27:
  %137 = phi i64 [%129, %$26] ; # X
  %138 = phi i64 [%134, %$26] ; # P
  %139 = phi i64 [%131, %$26] ; # Q
; # (set 4 P (cond ((atom (car (shift Q))) @) ((atom (set Q (cdr @)))...
; # (cond ((atom (car (shift Q))) @) ((atom (set Q (cdr @))) @) (T (c...
; # (shift Q)
  %140 = inttoptr i64 %139 to i64*
  %141 = getelementptr i64, i64* %140, i32 1
  %142 = load i64, i64* %141
; # (car (shift Q))
  %143 = inttoptr i64 %142 to i64*
  %144 = load i64, i64* %143
; # (atom (car (shift Q)))
  %145 = and i64 %144, 15
  %146 = icmp ne i64 %145, 0
  br i1 %146, label %$31, label %$30
$31:
  %147 = phi i64 [%137, %$27] ; # X
  %148 = phi i64 [%138, %$27] ; # P
  %149 = phi i64 [%142, %$27] ; # Q
  br label %$29
$30:
  %150 = phi i64 [%137, %$27] ; # X
  %151 = phi i64 [%138, %$27] ; # P
  %152 = phi i64 [%142, %$27] ; # Q
; # (set Q (cdr @))
; # (cdr @)
  %153 = inttoptr i64 %144 to i64*
  %154 = getelementptr i64, i64* %153, i32 1
  %155 = load i64, i64* %154
  %156 = inttoptr i64 %152 to i64*
  store i64 %155, i64* %156
; # (atom (set Q (cdr @)))
  %157 = and i64 %155, 15
  %158 = icmp ne i64 %157, 0
  br i1 %158, label %$33, label %$32
$33:
  %159 = phi i64 [%150, %$30] ; # X
  %160 = phi i64 [%151, %$30] ; # P
  %161 = phi i64 [%152, %$30] ; # Q
  br label %$29
$32:
  %162 = phi i64 [%150, %$30] ; # X
  %163 = phi i64 [%151, %$30] ; # P
  %164 = phi i64 [%152, %$30] ; # Q
; # (car @)
  %165 = inttoptr i64 %155 to i64*
  %166 = load i64, i64* %165
  br label %$29
$29:
  %167 = phi i64 [%147, %$31], [%159, %$33], [%162, %$32] ; # X
  %168 = phi i64 [%148, %$31], [%160, %$33], [%163, %$32] ; # P
  %169 = phi i64 [%149, %$31], [%161, %$33], [%164, %$32] ; # Q
  %170 = phi i64 [%144, %$31], [%155, %$33], [%166, %$32] ; # ->
  %171 = inttoptr i64 %138 to i64*
  %172 = getelementptr i64, i64* %171, i32 3
  store i64 %170, i64* %172
  br label %$26
$28:
  %173 = phi i64 [%129, %$26] ; # X
  %174 = phi i64 [%134, %$26] ; # P
  %175 = phi i64 [%131, %$26] ; # Q
  br label %$20
$22:
  %176 = phi i64 [%110, %$23], [%120, %$25] ; # X
  %177 = phi i64 [%107, %$23], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$25] ; # ->
  br label %$19
$19:
  %178 = phi i64 [%104, %$17], [%176, %$22] ; # X
  %179 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$17], [%177, %$22] ; # ->
; # (drop *Safe)
  %180 = inttoptr i64 %26 to i64*
  %181 = getelementptr i64, i64* %180, i32 1
  %182 = load i64, i64* %181
  %183 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %182, i64* %183
  ret i64 %179
}

define i64 @_Fully(i64) align 8 {
$1:
; # (let (X (cdr Exe) E (push NIL $Nil ZERO (eval (++ X)) NIL) A (pus...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (push NIL $Nil ZERO (eval (++ X)) NIL)
  %16 = alloca i64, i64 5, align 16
  %17 = ptrtoint i64* %16 to i64
  %18 = add i64 %17, 8
  %19 = inttoptr i64 %18 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %19
  %20 = add i64 %17, 16
  %21 = inttoptr i64 %20 to i64*
  store i64 2, i64* %21
  %22 = add i64 %17, 24
  %23 = inttoptr i64 %22 to i64*
  store i64 %15, i64* %23
; # (push NIL NIL)
  %24 = alloca i64, i64 2, align 16
  %25 = ptrtoint i64* %24 to i64
; # (set E (link (ofs E 3) T))
; # (ofs E 3)
  %26 = add i64 %17, 24
; # (link (ofs E 3) T)
  %27 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %28 = load i64, i64* %27
  %29 = inttoptr i64 %26 to i64*
  %30 = getelementptr i64, i64* %29, i32 1
  store i64 %28, i64* %30
  %31 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %26, i64* %31
  %32 = inttoptr i64 %17 to i64*
  store i64 %26, i64* %32
; # (let (P E Q A) (loop (let V (set Q (save (eval (car X)))) (when (...
; # (loop (let V (set Q (save (eval (car X)))) (when (pair V) (setq V...
  br label %$7
$7:
  %33 = phi i64 [%7, %$2], [%89, %$15] ; # X
  %34 = phi i64 [%17, %$2], [%90, %$15] ; # P
  %35 = phi i64 [%25, %$2], [%93, %$15] ; # Q
; # (let V (set Q (save (eval (car X)))) (when (pair V) (setq V (car ...
; # (set Q (save (eval (car X))))
; # (car X)
  %36 = inttoptr i64 %33 to i64*
  %37 = load i64, i64* %36
; # (eval (car X))
  %38 = and i64 %37, 6
  %39 = icmp ne i64 %38, 0
  br i1 %39, label %$10, label %$9
$10:
  br label %$8
$9:
  %40 = and i64 %37, 8
  %41 = icmp ne i64 %40, 0
  br i1 %41, label %$12, label %$11
$12:
  %42 = inttoptr i64 %37 to i64*
  %43 = load i64, i64* %42
  br label %$8
$11:
  %44 = call i64 @evList(i64 %37)
  br label %$8
$8:
  %45 = phi i64 [%37, %$10], [%43, %$12], [%44, %$11] ; # ->
; # (save (eval (car X)))
  %46 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %47 = load i64, i64* %46
  %48 = alloca i64, i64 2, align 16
  %49 = ptrtoint i64* %48 to i64
  %50 = inttoptr i64 %49 to i64*
  store i64 %45, i64* %50
  %51 = add i64 %49, 8
  %52 = inttoptr i64 %51 to i64*
  store i64 %47, i64* %52
  %53 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %49, i64* %53
  %54 = inttoptr i64 %35 to i64*
  store i64 %45, i64* %54
; # (when (pair V) (setq V (car V)))
; # (pair V)
  %55 = and i64 %45, 15
  %56 = icmp eq i64 %55, 0
  br i1 %56, label %$13, label %$14
$13:
  %57 = phi i64 [%33, %$8] ; # X
  %58 = phi i64 [%34, %$8] ; # P
  %59 = phi i64 [%35, %$8] ; # Q
  %60 = phi i64 [%45, %$8] ; # V
; # (car V)
  %61 = inttoptr i64 %60 to i64*
  %62 = load i64, i64* %61
  br label %$14
$14:
  %63 = phi i64 [%33, %$8], [%57, %$13] ; # X
  %64 = phi i64 [%34, %$8], [%58, %$13] ; # P
  %65 = phi i64 [%35, %$8], [%59, %$13] ; # Q
  %66 = phi i64 [%45, %$8], [%62, %$13] ; # V
; # (set 2 P (push NIL $Nil ZERO V NIL))
; # (push NIL $Nil ZERO V NIL)
  %67 = alloca i64, i64 5, align 16
  %68 = ptrtoint i64* %67 to i64
  %69 = add i64 %68, 8
  %70 = inttoptr i64 %69 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %70
  %71 = add i64 %68, 16
  %72 = inttoptr i64 %71 to i64*
  store i64 2, i64* %72
  %73 = add i64 %68, 24
  %74 = inttoptr i64 %73 to i64*
  store i64 %66, i64* %74
  %75 = inttoptr i64 %64 to i64*
  %76 = getelementptr i64, i64* %75, i32 1
  store i64 %68, i64* %76
; # (set P (link (ofs P 3)))
; # (ofs P 3)
  %77 = add i64 %68, 24
; # (link (ofs P 3))
  %78 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %79 = load i64, i64* %78
  %80 = inttoptr i64 %77 to i64*
  %81 = getelementptr i64, i64* %80, i32 1
  store i64 %79, i64* %81
  %82 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %77, i64* %82
  %83 = inttoptr i64 %68 to i64*
  store i64 %77, i64* %83
; # (? (atom (shift X)))
; # (shift X)
  %84 = inttoptr i64 %63 to i64*
  %85 = getelementptr i64, i64* %84, i32 1
  %86 = load i64, i64* %85
; # (atom (shift X))
  %87 = and i64 %86, 15
  %88 = icmp ne i64 %87, 0
  br i1 %88, label %$16, label %$15
$15:
  %89 = phi i64 [%86, %$14] ; # X
  %90 = phi i64 [%68, %$14] ; # P
  %91 = phi i64 [%65, %$14] ; # Q
; # (set 2 Q (push NIL NIL))
; # (push NIL NIL)
  %92 = alloca i64, i64 2, align 16
  %93 = ptrtoint i64* %92 to i64
  %94 = inttoptr i64 %91 to i64*
  %95 = getelementptr i64, i64* %94, i32 1
  store i64 %93, i64* %95
  br label %$7
$16:
  %96 = phi i64 [%86, %$14] ; # X
  %97 = phi i64 [%68, %$14] ; # P
  %98 = phi i64 [%65, %$14] ; # Q
  %99 = phi i64 [0, %$14] ; # ->
; # (if (atom (car A)) $T (loop (? (nil? (evList E)) @) (? (atom (set...
; # (car A)
  %100 = inttoptr i64 %25 to i64*
  %101 = load i64, i64* %100
; # (atom (car A))
  %102 = and i64 %101, 15
  %103 = icmp ne i64 %102, 0
  br i1 %103, label %$17, label %$18
$17:
  %104 = phi i64 [%96, %$16] ; # X
  br label %$19
$18:
  %105 = phi i64 [%96, %$16] ; # X
; # (loop (? (nil? (evList E)) @) (? (atom (set A (cdar A))) $T) (let...
  br label %$20
$20:
  %106 = phi i64 [%105, %$18], [%172, %$28] ; # X
; # (? (nil? (evList E)) @)
; # (evList E)
  %107 = call i64 @evList(i64 %17)
; # (nil? (evList E))
  %108 = icmp eq i64 %107, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %108, label %$23, label %$21
$23:
  %109 = phi i64 [%106, %$20] ; # X
  br label %$22
$21:
  %110 = phi i64 [%106, %$20] ; # X
; # (? (atom (set A (cdar A))) $T)
; # (set A (cdar A))
; # (cdar A)
  %111 = inttoptr i64 %25 to i64*
  %112 = load i64, i64* %111
  %113 = inttoptr i64 %112 to i64*
  %114 = getelementptr i64, i64* %113, i32 1
  %115 = load i64, i64* %114
  %116 = inttoptr i64 %25 to i64*
  store i64 %115, i64* %116
; # (atom (set A (cdar A)))
  %117 = and i64 %115, 15
  %118 = icmp ne i64 %117, 0
  br i1 %118, label %$25, label %$24
$25:
  %119 = phi i64 [%110, %$21] ; # X
  br label %$22
$24:
  %120 = phi i64 [%110, %$21] ; # X
; # (let (P (cdr E) Q A) (set 4 P (car @)) (while (pair (shift P)) (s...
; # (cdr E)
  %121 = inttoptr i64 %17 to i64*
  %122 = getelementptr i64, i64* %121, i32 1
  %123 = load i64, i64* %122
; # (set 4 P (car @))
; # (car @)
  %124 = inttoptr i64 %115 to i64*
  %125 = load i64, i64* %124
  %126 = inttoptr i64 %123 to i64*
  %127 = getelementptr i64, i64* %126, i32 3
  store i64 %125, i64* %127
; # (while (pair (shift P)) (set 4 P (cond ((atom (car (shift Q))) @)...
  br label %$26
$26:
  %128 = phi i64 [%120, %$24], [%166, %$29] ; # X
  %129 = phi i64 [%123, %$24], [%167, %$29] ; # P
  %130 = phi i64 [%25, %$24], [%168, %$29] ; # Q
; # (shift P)
  %131 = inttoptr i64 %129 to i64*
  %132 = getelementptr i64, i64* %131, i32 1
  %133 = load i64, i64* %132
; # (pair (shift P))
  %134 = and i64 %133, 15
  %135 = icmp eq i64 %134, 0
  br i1 %135, label %$27, label %$28
$27:
  %136 = phi i64 [%128, %$26] ; # X
  %137 = phi i64 [%133, %$26] ; # P
  %138 = phi i64 [%130, %$26] ; # Q
; # (set 4 P (cond ((atom (car (shift Q))) @) ((atom (set Q (cdr @)))...
; # (cond ((atom (car (shift Q))) @) ((atom (set Q (cdr @))) @) (T (c...
; # (shift Q)
  %139 = inttoptr i64 %138 to i64*
  %140 = getelementptr i64, i64* %139, i32 1
  %141 = load i64, i64* %140
; # (car (shift Q))
  %142 = inttoptr i64 %141 to i64*
  %143 = load i64, i64* %142
; # (atom (car (shift Q)))
  %144 = and i64 %143, 15
  %145 = icmp ne i64 %144, 0
  br i1 %145, label %$31, label %$30
$31:
  %146 = phi i64 [%136, %$27] ; # X
  %147 = phi i64 [%137, %$27] ; # P
  %148 = phi i64 [%141, %$27] ; # Q
  br label %$29
$30:
  %149 = phi i64 [%136, %$27] ; # X
  %150 = phi i64 [%137, %$27] ; # P
  %151 = phi i64 [%141, %$27] ; # Q
; # (set Q (cdr @))
; # (cdr @)
  %152 = inttoptr i64 %143 to i64*
  %153 = getelementptr i64, i64* %152, i32 1
  %154 = load i64, i64* %153
  %155 = inttoptr i64 %151 to i64*
  store i64 %154, i64* %155
; # (atom (set Q (cdr @)))
  %156 = and i64 %154, 15
  %157 = icmp ne i64 %156, 0
  br i1 %157, label %$33, label %$32
$33:
  %158 = phi i64 [%149, %$30] ; # X
  %159 = phi i64 [%150, %$30] ; # P
  %160 = phi i64 [%151, %$30] ; # Q
  br label %$29
$32:
  %161 = phi i64 [%149, %$30] ; # X
  %162 = phi i64 [%150, %$30] ; # P
  %163 = phi i64 [%151, %$30] ; # Q
; # (car @)
  %164 = inttoptr i64 %154 to i64*
  %165 = load i64, i64* %164
  br label %$29
$29:
  %166 = phi i64 [%146, %$31], [%158, %$33], [%161, %$32] ; # X
  %167 = phi i64 [%147, %$31], [%159, %$33], [%162, %$32] ; # P
  %168 = phi i64 [%148, %$31], [%160, %$33], [%163, %$32] ; # Q
  %169 = phi i64 [%143, %$31], [%154, %$33], [%165, %$32] ; # ->
  %170 = inttoptr i64 %137 to i64*
  %171 = getelementptr i64, i64* %170, i32 3
  store i64 %169, i64* %171
  br label %$26
$28:
  %172 = phi i64 [%128, %$26] ; # X
  %173 = phi i64 [%133, %$26] ; # P
  %174 = phi i64 [%130, %$26] ; # Q
  br label %$20
$22:
  %175 = phi i64 [%109, %$23], [%119, %$25] ; # X
  %176 = phi i64 [%107, %$23], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$25] ; # ->
  br label %$19
$19:
  %177 = phi i64 [%104, %$17], [%175, %$22] ; # X
  %178 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$17], [%176, %$22] ; # ->
; # (drop *Safe)
  %179 = inttoptr i64 %26 to i64*
  %180 = getelementptr i64, i64* %179, i32 1
  %181 = load i64, i64* %180
  %182 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %181, i64* %182
  ret i64 %178
}

define i64 @_Cnt(i64) align 8 {
$1:
; # (let (X (cdr Exe) R ZERO E (push NIL $Nil ZERO (eval (++ X)) NIL)...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (push NIL $Nil ZERO (eval (++ X)) NIL)
  %16 = alloca i64, i64 5, align 16
  %17 = ptrtoint i64* %16 to i64
  %18 = add i64 %17, 8
  %19 = inttoptr i64 %18 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %19
  %20 = add i64 %17, 16
  %21 = inttoptr i64 %20 to i64*
  store i64 2, i64* %21
  %22 = add i64 %17, 24
  %23 = inttoptr i64 %22 to i64*
  store i64 %15, i64* %23
; # (push NIL NIL)
  %24 = alloca i64, i64 2, align 16
  %25 = ptrtoint i64* %24 to i64
; # (set E (link (ofs E 3) T))
; # (ofs E 3)
  %26 = add i64 %17, 24
; # (link (ofs E 3) T)
  %27 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %28 = load i64, i64* %27
  %29 = inttoptr i64 %26 to i64*
  %30 = getelementptr i64, i64* %29, i32 1
  store i64 %28, i64* %30
  %31 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %26, i64* %31
  %32 = inttoptr i64 %17 to i64*
  store i64 %26, i64* %32
; # (let (P E Q A) (loop (let V (set Q (save (eval (car X)))) (when (...
; # (loop (let V (set Q (save (eval (car X)))) (when (pair V) (setq V...
  br label %$7
$7:
  %33 = phi i64 [%7, %$2], [%92, %$15] ; # X
  %34 = phi i64 [2, %$2], [%93, %$15] ; # R
  %35 = phi i64 [%17, %$2], [%94, %$15] ; # P
  %36 = phi i64 [%25, %$2], [%97, %$15] ; # Q
; # (let V (set Q (save (eval (car X)))) (when (pair V) (setq V (car ...
; # (set Q (save (eval (car X))))
; # (car X)
  %37 = inttoptr i64 %33 to i64*
  %38 = load i64, i64* %37
; # (eval (car X))
  %39 = and i64 %38, 6
  %40 = icmp ne i64 %39, 0
  br i1 %40, label %$10, label %$9
$10:
  br label %$8
$9:
  %41 = and i64 %38, 8
  %42 = icmp ne i64 %41, 0
  br i1 %42, label %$12, label %$11
$12:
  %43 = inttoptr i64 %38 to i64*
  %44 = load i64, i64* %43
  br label %$8
$11:
  %45 = call i64 @evList(i64 %38)
  br label %$8
$8:
  %46 = phi i64 [%38, %$10], [%44, %$12], [%45, %$11] ; # ->
; # (save (eval (car X)))
  %47 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %48 = load i64, i64* %47
  %49 = alloca i64, i64 2, align 16
  %50 = ptrtoint i64* %49 to i64
  %51 = inttoptr i64 %50 to i64*
  store i64 %46, i64* %51
  %52 = add i64 %50, 8
  %53 = inttoptr i64 %52 to i64*
  store i64 %48, i64* %53
  %54 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %50, i64* %54
  %55 = inttoptr i64 %36 to i64*
  store i64 %46, i64* %55
; # (when (pair V) (setq V (car V)))
; # (pair V)
  %56 = and i64 %46, 15
  %57 = icmp eq i64 %56, 0
  br i1 %57, label %$13, label %$14
$13:
  %58 = phi i64 [%33, %$8] ; # X
  %59 = phi i64 [%34, %$8] ; # R
  %60 = phi i64 [%35, %$8] ; # P
  %61 = phi i64 [%36, %$8] ; # Q
  %62 = phi i64 [%46, %$8] ; # V
; # (car V)
  %63 = inttoptr i64 %62 to i64*
  %64 = load i64, i64* %63
  br label %$14
$14:
  %65 = phi i64 [%33, %$8], [%58, %$13] ; # X
  %66 = phi i64 [%34, %$8], [%59, %$13] ; # R
  %67 = phi i64 [%35, %$8], [%60, %$13] ; # P
  %68 = phi i64 [%36, %$8], [%61, %$13] ; # Q
  %69 = phi i64 [%46, %$8], [%64, %$13] ; # V
; # (set 2 P (push NIL $Nil ZERO V NIL))
; # (push NIL $Nil ZERO V NIL)
  %70 = alloca i64, i64 5, align 16
  %71 = ptrtoint i64* %70 to i64
  %72 = add i64 %71, 8
  %73 = inttoptr i64 %72 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %73
  %74 = add i64 %71, 16
  %75 = inttoptr i64 %74 to i64*
  store i64 2, i64* %75
  %76 = add i64 %71, 24
  %77 = inttoptr i64 %76 to i64*
  store i64 %69, i64* %77
  %78 = inttoptr i64 %67 to i64*
  %79 = getelementptr i64, i64* %78, i32 1
  store i64 %71, i64* %79
; # (set P (link (ofs P 3)))
; # (ofs P 3)
  %80 = add i64 %71, 24
; # (link (ofs P 3))
  %81 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %82 = load i64, i64* %81
  %83 = inttoptr i64 %80 to i64*
  %84 = getelementptr i64, i64* %83, i32 1
  store i64 %82, i64* %84
  %85 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %80, i64* %85
  %86 = inttoptr i64 %71 to i64*
  store i64 %80, i64* %86
; # (? (atom (shift X)))
; # (shift X)
  %87 = inttoptr i64 %65 to i64*
  %88 = getelementptr i64, i64* %87, i32 1
  %89 = load i64, i64* %88
; # (atom (shift X))
  %90 = and i64 %89, 15
  %91 = icmp ne i64 %90, 0
  br i1 %91, label %$16, label %$15
$15:
  %92 = phi i64 [%89, %$14] ; # X
  %93 = phi i64 [%66, %$14] ; # R
  %94 = phi i64 [%71, %$14] ; # P
  %95 = phi i64 [%68, %$14] ; # Q
; # (set 2 Q (push NIL NIL))
; # (push NIL NIL)
  %96 = alloca i64, i64 2, align 16
  %97 = ptrtoint i64* %96 to i64
  %98 = inttoptr i64 %95 to i64*
  %99 = getelementptr i64, i64* %98, i32 1
  store i64 %97, i64* %99
  br label %$7
$16:
  %100 = phi i64 [%89, %$14] ; # X
  %101 = phi i64 [%66, %$14] ; # R
  %102 = phi i64 [%71, %$14] ; # P
  %103 = phi i64 [%68, %$14] ; # Q
  %104 = phi i64 [0, %$14] ; # ->
; # (when (pair (car A)) (loop (unless (nil? (evList E)) (inc 'R (hex...
; # (car A)
  %105 = inttoptr i64 %25 to i64*
  %106 = load i64, i64* %105
; # (pair (car A))
  %107 = and i64 %106, 15
  %108 = icmp eq i64 %107, 0
  br i1 %108, label %$17, label %$18
$17:
  %109 = phi i64 [%100, %$16] ; # X
  %110 = phi i64 [%101, %$16] ; # R
; # (loop (unless (nil? (evList E)) (inc 'R (hex "10"))) (? (atom (se...
  br label %$19
$19:
  %111 = phi i64 [%109, %$17], [%188, %$26] ; # X
  %112 = phi i64 [%110, %$17], [%189, %$26] ; # R
; # (unless (nil? (evList E)) (inc 'R (hex "10")))
; # (evList E)
  %113 = call i64 @evList(i64 %17)
; # (nil? (evList E))
  %114 = icmp eq i64 %113, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %114, label %$21, label %$20
$20:
  %115 = phi i64 [%111, %$19] ; # X
  %116 = phi i64 [%112, %$19] ; # R
; # (inc 'R (hex "10"))
  %117 = add i64 %116, 16
  br label %$21
$21:
  %118 = phi i64 [%111, %$19], [%115, %$20] ; # X
  %119 = phi i64 [%112, %$19], [%117, %$20] ; # R
; # (? (atom (set A (cdar A))))
; # (set A (cdar A))
; # (cdar A)
  %120 = inttoptr i64 %25 to i64*
  %121 = load i64, i64* %120
  %122 = inttoptr i64 %121 to i64*
  %123 = getelementptr i64, i64* %122, i32 1
  %124 = load i64, i64* %123
  %125 = inttoptr i64 %25 to i64*
  store i64 %124, i64* %125
; # (atom (set A (cdar A)))
  %126 = and i64 %124, 15
  %127 = icmp ne i64 %126, 0
  br i1 %127, label %$23, label %$22
$22:
  %128 = phi i64 [%118, %$21] ; # X
  %129 = phi i64 [%119, %$21] ; # R
; # (let (P (cdr E) Q A) (set 4 P (car @)) (while (pair (shift P)) (s...
; # (cdr E)
  %130 = inttoptr i64 %17 to i64*
  %131 = getelementptr i64, i64* %130, i32 1
  %132 = load i64, i64* %131
; # (set 4 P (car @))
; # (car @)
  %133 = inttoptr i64 %124 to i64*
  %134 = load i64, i64* %133
  %135 = inttoptr i64 %132 to i64*
  %136 = getelementptr i64, i64* %135, i32 3
  store i64 %134, i64* %136
; # (while (pair (shift P)) (set 4 P (cond ((atom (car (shift Q))) @)...
  br label %$24
$24:
  %137 = phi i64 [%128, %$22], [%181, %$27] ; # X
  %138 = phi i64 [%129, %$22], [%182, %$27] ; # R
  %139 = phi i64 [%132, %$22], [%183, %$27] ; # P
  %140 = phi i64 [%25, %$22], [%184, %$27] ; # Q
; # (shift P)
  %141 = inttoptr i64 %139 to i64*
  %142 = getelementptr i64, i64* %141, i32 1
  %143 = load i64, i64* %142
; # (pair (shift P))
  %144 = and i64 %143, 15
  %145 = icmp eq i64 %144, 0
  br i1 %145, label %$25, label %$26
$25:
  %146 = phi i64 [%137, %$24] ; # X
  %147 = phi i64 [%138, %$24] ; # R
  %148 = phi i64 [%143, %$24] ; # P
  %149 = phi i64 [%140, %$24] ; # Q
; # (set 4 P (cond ((atom (car (shift Q))) @) ((atom (set Q (cdr @)))...
; # (cond ((atom (car (shift Q))) @) ((atom (set Q (cdr @))) @) (T (c...
; # (shift Q)
  %150 = inttoptr i64 %149 to i64*
  %151 = getelementptr i64, i64* %150, i32 1
  %152 = load i64, i64* %151
; # (car (shift Q))
  %153 = inttoptr i64 %152 to i64*
  %154 = load i64, i64* %153
; # (atom (car (shift Q)))
  %155 = and i64 %154, 15
  %156 = icmp ne i64 %155, 0
  br i1 %156, label %$29, label %$28
$29:
  %157 = phi i64 [%146, %$25] ; # X
  %158 = phi i64 [%147, %$25] ; # R
  %159 = phi i64 [%148, %$25] ; # P
  %160 = phi i64 [%152, %$25] ; # Q
  br label %$27
$28:
  %161 = phi i64 [%146, %$25] ; # X
  %162 = phi i64 [%147, %$25] ; # R
  %163 = phi i64 [%148, %$25] ; # P
  %164 = phi i64 [%152, %$25] ; # Q
; # (set Q (cdr @))
; # (cdr @)
  %165 = inttoptr i64 %154 to i64*
  %166 = getelementptr i64, i64* %165, i32 1
  %167 = load i64, i64* %166
  %168 = inttoptr i64 %164 to i64*
  store i64 %167, i64* %168
; # (atom (set Q (cdr @)))
  %169 = and i64 %167, 15
  %170 = icmp ne i64 %169, 0
  br i1 %170, label %$31, label %$30
$31:
  %171 = phi i64 [%161, %$28] ; # X
  %172 = phi i64 [%162, %$28] ; # R
  %173 = phi i64 [%163, %$28] ; # P
  %174 = phi i64 [%164, %$28] ; # Q
  br label %$27
$30:
  %175 = phi i64 [%161, %$28] ; # X
  %176 = phi i64 [%162, %$28] ; # R
  %177 = phi i64 [%163, %$28] ; # P
  %178 = phi i64 [%164, %$28] ; # Q
; # (car @)
  %179 = inttoptr i64 %167 to i64*
  %180 = load i64, i64* %179
  br label %$27
$27:
  %181 = phi i64 [%157, %$29], [%171, %$31], [%175, %$30] ; # X
  %182 = phi i64 [%158, %$29], [%172, %$31], [%176, %$30] ; # R
  %183 = phi i64 [%159, %$29], [%173, %$31], [%177, %$30] ; # P
  %184 = phi i64 [%160, %$29], [%174, %$31], [%178, %$30] ; # Q
  %185 = phi i64 [%154, %$29], [%167, %$31], [%180, %$30] ; # ->
  %186 = inttoptr i64 %148 to i64*
  %187 = getelementptr i64, i64* %186, i32 3
  store i64 %185, i64* %187
  br label %$24
$26:
  %188 = phi i64 [%137, %$24] ; # X
  %189 = phi i64 [%138, %$24] ; # R
  %190 = phi i64 [%143, %$24] ; # P
  %191 = phi i64 [%140, %$24] ; # Q
  br label %$19
$23:
  %192 = phi i64 [%118, %$21] ; # X
  %193 = phi i64 [%119, %$21] ; # R
  %194 = phi i64 [0, %$21] ; # ->
  br label %$18
$18:
  %195 = phi i64 [%100, %$16], [%192, %$23] ; # X
  %196 = phi i64 [%101, %$16], [%193, %$23] ; # R
; # (drop *Safe)
  %197 = inttoptr i64 %26 to i64*
  %198 = getelementptr i64, i64* %197, i32 1
  %199 = load i64, i64* %198
  %200 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %199, i64* %200
  ret i64 %196
}

define i64 @_Sum(i64) align 8 {
$1:
; # (let (X (cdr Exe) R (save ZERO) E (push NIL $Nil ZERO (eval (++ X...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (save ZERO)
  %4 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %5 = load i64, i64* %4
  %6 = alloca i64, i64 2, align 16
  %7 = ptrtoint i64* %6 to i64
  %8 = inttoptr i64 %7 to i64*
  store i64 2, i64* %8
  %9 = add i64 %7, 8
  %10 = inttoptr i64 %9 to i64*
  store i64 %5, i64* %10
  %11 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %7, i64* %11
; # (++ X)
  %12 = inttoptr i64 %3 to i64*
  %13 = load i64, i64* %12
  %14 = getelementptr i64, i64* %12, i32 1
  %15 = load i64, i64* %14
; # (eval (++ X))
  %16 = and i64 %13, 6
  %17 = icmp ne i64 %16, 0
  br i1 %17, label %$4, label %$3
$4:
  br label %$2
$3:
  %18 = and i64 %13, 8
  %19 = icmp ne i64 %18, 0
  br i1 %19, label %$6, label %$5
$6:
  %20 = inttoptr i64 %13 to i64*
  %21 = load i64, i64* %20
  br label %$2
$5:
  %22 = call i64 @evList(i64 %13)
  br label %$2
$2:
  %23 = phi i64 [%13, %$4], [%21, %$6], [%22, %$5] ; # ->
; # (push NIL $Nil ZERO (eval (++ X)) NIL)
  %24 = alloca i64, i64 5, align 16
  %25 = ptrtoint i64* %24 to i64
  %26 = add i64 %25, 8
  %27 = inttoptr i64 %26 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %27
  %28 = add i64 %25, 16
  %29 = inttoptr i64 %28 to i64*
  store i64 2, i64* %29
  %30 = add i64 %25, 24
  %31 = inttoptr i64 %30 to i64*
  store i64 %23, i64* %31
; # (push NIL NIL)
  %32 = alloca i64, i64 2, align 16
  %33 = ptrtoint i64* %32 to i64
; # (set E (link (ofs E 3)))
; # (ofs E 3)
  %34 = add i64 %25, 24
; # (link (ofs E 3))
  %35 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %36 = load i64, i64* %35
  %37 = inttoptr i64 %34 to i64*
  %38 = getelementptr i64, i64* %37, i32 1
  store i64 %36, i64* %38
  %39 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %34, i64* %39
  %40 = inttoptr i64 %25 to i64*
  store i64 %34, i64* %40
; # (let (P E Q A) (loop (let V (set Q (save (eval (car X)))) (when (...
; # (loop (let V (set Q (save (eval (car X)))) (when (pair V) (setq V...
  br label %$7
$7:
  %41 = phi i64 [%15, %$2], [%100, %$15] ; # X
  %42 = phi i64 [2, %$2], [%101, %$15] ; # R
  %43 = phi i64 [%25, %$2], [%102, %$15] ; # P
  %44 = phi i64 [%33, %$2], [%105, %$15] ; # Q
; # (let V (set Q (save (eval (car X)))) (when (pair V) (setq V (car ...
; # (set Q (save (eval (car X))))
; # (car X)
  %45 = inttoptr i64 %41 to i64*
  %46 = load i64, i64* %45
; # (eval (car X))
  %47 = and i64 %46, 6
  %48 = icmp ne i64 %47, 0
  br i1 %48, label %$10, label %$9
$10:
  br label %$8
$9:
  %49 = and i64 %46, 8
  %50 = icmp ne i64 %49, 0
  br i1 %50, label %$12, label %$11
$12:
  %51 = inttoptr i64 %46 to i64*
  %52 = load i64, i64* %51
  br label %$8
$11:
  %53 = call i64 @evList(i64 %46)
  br label %$8
$8:
  %54 = phi i64 [%46, %$10], [%52, %$12], [%53, %$11] ; # ->
; # (save (eval (car X)))
  %55 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %56 = load i64, i64* %55
  %57 = alloca i64, i64 2, align 16
  %58 = ptrtoint i64* %57 to i64
  %59 = inttoptr i64 %58 to i64*
  store i64 %54, i64* %59
  %60 = add i64 %58, 8
  %61 = inttoptr i64 %60 to i64*
  store i64 %56, i64* %61
  %62 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %58, i64* %62
  %63 = inttoptr i64 %44 to i64*
  store i64 %54, i64* %63
; # (when (pair V) (setq V (car V)))
; # (pair V)
  %64 = and i64 %54, 15
  %65 = icmp eq i64 %64, 0
  br i1 %65, label %$13, label %$14
$13:
  %66 = phi i64 [%41, %$8] ; # X
  %67 = phi i64 [%42, %$8] ; # R
  %68 = phi i64 [%43, %$8] ; # P
  %69 = phi i64 [%44, %$8] ; # Q
  %70 = phi i64 [%54, %$8] ; # V
; # (car V)
  %71 = inttoptr i64 %70 to i64*
  %72 = load i64, i64* %71
  br label %$14
$14:
  %73 = phi i64 [%41, %$8], [%66, %$13] ; # X
  %74 = phi i64 [%42, %$8], [%67, %$13] ; # R
  %75 = phi i64 [%43, %$8], [%68, %$13] ; # P
  %76 = phi i64 [%44, %$8], [%69, %$13] ; # Q
  %77 = phi i64 [%54, %$8], [%72, %$13] ; # V
; # (set 2 P (push NIL $Nil ZERO V NIL))
; # (push NIL $Nil ZERO V NIL)
  %78 = alloca i64, i64 5, align 16
  %79 = ptrtoint i64* %78 to i64
  %80 = add i64 %79, 8
  %81 = inttoptr i64 %80 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %81
  %82 = add i64 %79, 16
  %83 = inttoptr i64 %82 to i64*
  store i64 2, i64* %83
  %84 = add i64 %79, 24
  %85 = inttoptr i64 %84 to i64*
  store i64 %77, i64* %85
  %86 = inttoptr i64 %75 to i64*
  %87 = getelementptr i64, i64* %86, i32 1
  store i64 %79, i64* %87
; # (set P (link (ofs P 3)))
; # (ofs P 3)
  %88 = add i64 %79, 24
; # (link (ofs P 3))
  %89 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %90 = load i64, i64* %89
  %91 = inttoptr i64 %88 to i64*
  %92 = getelementptr i64, i64* %91, i32 1
  store i64 %90, i64* %92
  %93 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %88, i64* %93
  %94 = inttoptr i64 %79 to i64*
  store i64 %88, i64* %94
; # (? (atom (shift X)))
; # (shift X)
  %95 = inttoptr i64 %73 to i64*
  %96 = getelementptr i64, i64* %95, i32 1
  %97 = load i64, i64* %96
; # (atom (shift X))
  %98 = and i64 %97, 15
  %99 = icmp ne i64 %98, 0
  br i1 %99, label %$16, label %$15
$15:
  %100 = phi i64 [%97, %$14] ; # X
  %101 = phi i64 [%74, %$14] ; # R
  %102 = phi i64 [%79, %$14] ; # P
  %103 = phi i64 [%76, %$14] ; # Q
; # (set 2 Q (push NIL NIL))
; # (push NIL NIL)
  %104 = alloca i64, i64 2, align 16
  %105 = ptrtoint i64* %104 to i64
  %106 = inttoptr i64 %103 to i64*
  %107 = getelementptr i64, i64* %106, i32 1
  store i64 %105, i64* %107
  br label %$7
$16:
  %108 = phi i64 [%97, %$14] ; # X
  %109 = phi i64 [%74, %$14] ; # R
  %110 = phi i64 [%79, %$14] ; # P
  %111 = phi i64 [%76, %$14] ; # Q
  %112 = phi i64 [0, %$14] ; # ->
; # (when (pair (car A)) (loop (when (num? (evList E)) (save @ (setq ...
; # (car A)
  %113 = inttoptr i64 %33 to i64*
  %114 = load i64, i64* %113
; # (pair (car A))
  %115 = and i64 %114, 15
  %116 = icmp eq i64 %115, 0
  br i1 %116, label %$17, label %$18
$17:
  %117 = phi i64 [%108, %$16] ; # X
  %118 = phi i64 [%109, %$16] ; # R
; # (loop (when (num? (evList E)) (save @ (setq R (safe (adds R @))))...
  br label %$19
$19:
  %119 = phi i64 [%117, %$17], [%210, %$26] ; # X
  %120 = phi i64 [%118, %$17], [%211, %$26] ; # R
; # (when (num? (evList E)) (save @ (setq R (safe (adds R @)))))
; # (evList E)
  %121 = call i64 @evList(i64 %25)
; # (num? (evList E))
  %122 = and i64 %121, 6
  %123 = icmp ne i64 %122, 0
  br i1 %123, label %$20, label %$21
$20:
  %124 = phi i64 [%119, %$19] ; # X
  %125 = phi i64 [%120, %$19] ; # R
; # (save @ (setq R (safe (adds R @))))
  %126 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %127 = load i64, i64* %126
  %128 = alloca i64, i64 2, align 16
  %129 = ptrtoint i64* %128 to i64
  %130 = inttoptr i64 %129 to i64*
  store i64 %121, i64* %130
  %131 = add i64 %129, 8
  %132 = inttoptr i64 %131 to i64*
  store i64 %127, i64* %132
  %133 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %129, i64* %133
; # (adds R @)
  %134 = call i64 @adds(i64 %125, i64 %121)
; # (safe (adds R @))
  %135 = inttoptr i64 %7 to i64*
  store i64 %134, i64* %135
; # drop
  %136 = inttoptr i64 %129 to i64*
  %137 = getelementptr i64, i64* %136, i32 1
  %138 = load i64, i64* %137
  %139 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %138, i64* %139
  br label %$21
$21:
  %140 = phi i64 [%119, %$19], [%124, %$20] ; # X
  %141 = phi i64 [%120, %$19], [%134, %$20] ; # R
; # (? (atom (set A (cdar A))))
; # (set A (cdar A))
; # (cdar A)
  %142 = inttoptr i64 %33 to i64*
  %143 = load i64, i64* %142
  %144 = inttoptr i64 %143 to i64*
  %145 = getelementptr i64, i64* %144, i32 1
  %146 = load i64, i64* %145
  %147 = inttoptr i64 %33 to i64*
  store i64 %146, i64* %147
; # (atom (set A (cdar A)))
  %148 = and i64 %146, 15
  %149 = icmp ne i64 %148, 0
  br i1 %149, label %$23, label %$22
$22:
  %150 = phi i64 [%140, %$21] ; # X
  %151 = phi i64 [%141, %$21] ; # R
; # (let (P (cdr E) Q A) (set 4 P (car @)) (while (pair (shift P)) (s...
; # (cdr E)
  %152 = inttoptr i64 %25 to i64*
  %153 = getelementptr i64, i64* %152, i32 1
  %154 = load i64, i64* %153
; # (set 4 P (car @))
; # (car @)
  %155 = inttoptr i64 %146 to i64*
  %156 = load i64, i64* %155
  %157 = inttoptr i64 %154 to i64*
  %158 = getelementptr i64, i64* %157, i32 3
  store i64 %156, i64* %158
; # (while (pair (shift P)) (set 4 P (cond ((atom (car (shift Q))) @)...
  br label %$24
$24:
  %159 = phi i64 [%150, %$22], [%203, %$27] ; # X
  %160 = phi i64 [%151, %$22], [%204, %$27] ; # R
  %161 = phi i64 [%154, %$22], [%205, %$27] ; # P
  %162 = phi i64 [%33, %$22], [%206, %$27] ; # Q
; # (shift P)
  %163 = inttoptr i64 %161 to i64*
  %164 = getelementptr i64, i64* %163, i32 1
  %165 = load i64, i64* %164
; # (pair (shift P))
  %166 = and i64 %165, 15
  %167 = icmp eq i64 %166, 0
  br i1 %167, label %$25, label %$26
$25:
  %168 = phi i64 [%159, %$24] ; # X
  %169 = phi i64 [%160, %$24] ; # R
  %170 = phi i64 [%165, %$24] ; # P
  %171 = phi i64 [%162, %$24] ; # Q
; # (set 4 P (cond ((atom (car (shift Q))) @) ((atom (set Q (cdr @)))...
; # (cond ((atom (car (shift Q))) @) ((atom (set Q (cdr @))) @) (T (c...
; # (shift Q)
  %172 = inttoptr i64 %171 to i64*
  %173 = getelementptr i64, i64* %172, i32 1
  %174 = load i64, i64* %173
; # (car (shift Q))
  %175 = inttoptr i64 %174 to i64*
  %176 = load i64, i64* %175
; # (atom (car (shift Q)))
  %177 = and i64 %176, 15
  %178 = icmp ne i64 %177, 0
  br i1 %178, label %$29, label %$28
$29:
  %179 = phi i64 [%168, %$25] ; # X
  %180 = phi i64 [%169, %$25] ; # R
  %181 = phi i64 [%170, %$25] ; # P
  %182 = phi i64 [%174, %$25] ; # Q
  br label %$27
$28:
  %183 = phi i64 [%168, %$25] ; # X
  %184 = phi i64 [%169, %$25] ; # R
  %185 = phi i64 [%170, %$25] ; # P
  %186 = phi i64 [%174, %$25] ; # Q
; # (set Q (cdr @))
; # (cdr @)
  %187 = inttoptr i64 %176 to i64*
  %188 = getelementptr i64, i64* %187, i32 1
  %189 = load i64, i64* %188
  %190 = inttoptr i64 %186 to i64*
  store i64 %189, i64* %190
; # (atom (set Q (cdr @)))
  %191 = and i64 %189, 15
  %192 = icmp ne i64 %191, 0
  br i1 %192, label %$31, label %$30
$31:
  %193 = phi i64 [%183, %$28] ; # X
  %194 = phi i64 [%184, %$28] ; # R
  %195 = phi i64 [%185, %$28] ; # P
  %196 = phi i64 [%186, %$28] ; # Q
  br label %$27
$30:
  %197 = phi i64 [%183, %$28] ; # X
  %198 = phi i64 [%184, %$28] ; # R
  %199 = phi i64 [%185, %$28] ; # P
  %200 = phi i64 [%186, %$28] ; # Q
; # (car @)
  %201 = inttoptr i64 %189 to i64*
  %202 = load i64, i64* %201
  br label %$27
$27:
  %203 = phi i64 [%179, %$29], [%193, %$31], [%197, %$30] ; # X
  %204 = phi i64 [%180, %$29], [%194, %$31], [%198, %$30] ; # R
  %205 = phi i64 [%181, %$29], [%195, %$31], [%199, %$30] ; # P
  %206 = phi i64 [%182, %$29], [%196, %$31], [%200, %$30] ; # Q
  %207 = phi i64 [%176, %$29], [%189, %$31], [%202, %$30] ; # ->
  %208 = inttoptr i64 %170 to i64*
  %209 = getelementptr i64, i64* %208, i32 3
  store i64 %207, i64* %209
  br label %$24
$26:
  %210 = phi i64 [%159, %$24] ; # X
  %211 = phi i64 [%160, %$24] ; # R
  %212 = phi i64 [%165, %$24] ; # P
  %213 = phi i64 [%162, %$24] ; # Q
  br label %$19
$23:
  %214 = phi i64 [%140, %$21] ; # X
  %215 = phi i64 [%141, %$21] ; # R
  %216 = phi i64 [0, %$21] ; # ->
  br label %$18
$18:
  %217 = phi i64 [%108, %$16], [%214, %$23] ; # X
  %218 = phi i64 [%109, %$16], [%215, %$23] ; # R
; # (drop *Safe)
  %219 = inttoptr i64 %7 to i64*
  %220 = getelementptr i64, i64* %219, i32 1
  %221 = load i64, i64* %220
  %222 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %221, i64* %222
  ret i64 %218
}

define i64 @_Maxi(i64) align 8 {
$1:
; # (let (X (cdr Exe) R $Nil R2 (save $Nil) E (push NIL $Nil ZERO (ev...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (save $Nil)
  %4 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %5 = load i64, i64* %4
  %6 = alloca i64, i64 2, align 16
  %7 = ptrtoint i64* %6 to i64
  %8 = inttoptr i64 %7 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %8
  %9 = add i64 %7, 8
  %10 = inttoptr i64 %9 to i64*
  store i64 %5, i64* %10
  %11 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %7, i64* %11
; # (++ X)
  %12 = inttoptr i64 %3 to i64*
  %13 = load i64, i64* %12
  %14 = getelementptr i64, i64* %12, i32 1
  %15 = load i64, i64* %14
; # (eval (++ X))
  %16 = and i64 %13, 6
  %17 = icmp ne i64 %16, 0
  br i1 %17, label %$4, label %$3
$4:
  br label %$2
$3:
  %18 = and i64 %13, 8
  %19 = icmp ne i64 %18, 0
  br i1 %19, label %$6, label %$5
$6:
  %20 = inttoptr i64 %13 to i64*
  %21 = load i64, i64* %20
  br label %$2
$5:
  %22 = call i64 @evList(i64 %13)
  br label %$2
$2:
  %23 = phi i64 [%13, %$4], [%21, %$6], [%22, %$5] ; # ->
; # (push NIL $Nil ZERO (eval (++ X)) NIL)
  %24 = alloca i64, i64 5, align 16
  %25 = ptrtoint i64* %24 to i64
  %26 = add i64 %25, 8
  %27 = inttoptr i64 %26 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %27
  %28 = add i64 %25, 16
  %29 = inttoptr i64 %28 to i64*
  store i64 2, i64* %29
  %30 = add i64 %25, 24
  %31 = inttoptr i64 %30 to i64*
  store i64 %23, i64* %31
; # (push NIL NIL)
  %32 = alloca i64, i64 2, align 16
  %33 = ptrtoint i64* %32 to i64
; # (set E (link (ofs E 3)))
; # (ofs E 3)
  %34 = add i64 %25, 24
; # (link (ofs E 3))
  %35 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %36 = load i64, i64* %35
  %37 = inttoptr i64 %34 to i64*
  %38 = getelementptr i64, i64* %37, i32 1
  store i64 %36, i64* %38
  %39 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %34, i64* %39
  %40 = inttoptr i64 %25 to i64*
  store i64 %34, i64* %40
; # (let (P E Q A) (loop (let V (set Q (save (eval (car X)))) (when (...
; # (loop (let V (set Q (save (eval (car X)))) (when (pair V) (setq V...
  br label %$7
$7:
  %41 = phi i64 [%15, %$2], [%103, %$15] ; # X
  %42 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%104, %$15] ; # R
  %43 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%105, %$15] ; # R2
  %44 = phi i64 [%25, %$2], [%106, %$15] ; # P
  %45 = phi i64 [%33, %$2], [%109, %$15] ; # Q
; # (let V (set Q (save (eval (car X)))) (when (pair V) (setq V (car ...
; # (set Q (save (eval (car X))))
; # (car X)
  %46 = inttoptr i64 %41 to i64*
  %47 = load i64, i64* %46
; # (eval (car X))
  %48 = and i64 %47, 6
  %49 = icmp ne i64 %48, 0
  br i1 %49, label %$10, label %$9
$10:
  br label %$8
$9:
  %50 = and i64 %47, 8
  %51 = icmp ne i64 %50, 0
  br i1 %51, label %$12, label %$11
$12:
  %52 = inttoptr i64 %47 to i64*
  %53 = load i64, i64* %52
  br label %$8
$11:
  %54 = call i64 @evList(i64 %47)
  br label %$8
$8:
  %55 = phi i64 [%47, %$10], [%53, %$12], [%54, %$11] ; # ->
; # (save (eval (car X)))
  %56 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %57 = load i64, i64* %56
  %58 = alloca i64, i64 2, align 16
  %59 = ptrtoint i64* %58 to i64
  %60 = inttoptr i64 %59 to i64*
  store i64 %55, i64* %60
  %61 = add i64 %59, 8
  %62 = inttoptr i64 %61 to i64*
  store i64 %57, i64* %62
  %63 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %59, i64* %63
  %64 = inttoptr i64 %45 to i64*
  store i64 %55, i64* %64
; # (when (pair V) (setq V (car V)))
; # (pair V)
  %65 = and i64 %55, 15
  %66 = icmp eq i64 %65, 0
  br i1 %66, label %$13, label %$14
$13:
  %67 = phi i64 [%41, %$8] ; # X
  %68 = phi i64 [%42, %$8] ; # R
  %69 = phi i64 [%43, %$8] ; # R2
  %70 = phi i64 [%44, %$8] ; # P
  %71 = phi i64 [%45, %$8] ; # Q
  %72 = phi i64 [%55, %$8] ; # V
; # (car V)
  %73 = inttoptr i64 %72 to i64*
  %74 = load i64, i64* %73
  br label %$14
$14:
  %75 = phi i64 [%41, %$8], [%67, %$13] ; # X
  %76 = phi i64 [%42, %$8], [%68, %$13] ; # R
  %77 = phi i64 [%43, %$8], [%69, %$13] ; # R2
  %78 = phi i64 [%44, %$8], [%70, %$13] ; # P
  %79 = phi i64 [%45, %$8], [%71, %$13] ; # Q
  %80 = phi i64 [%55, %$8], [%74, %$13] ; # V
; # (set 2 P (push NIL $Nil ZERO V NIL))
; # (push NIL $Nil ZERO V NIL)
  %81 = alloca i64, i64 5, align 16
  %82 = ptrtoint i64* %81 to i64
  %83 = add i64 %82, 8
  %84 = inttoptr i64 %83 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %84
  %85 = add i64 %82, 16
  %86 = inttoptr i64 %85 to i64*
  store i64 2, i64* %86
  %87 = add i64 %82, 24
  %88 = inttoptr i64 %87 to i64*
  store i64 %80, i64* %88
  %89 = inttoptr i64 %78 to i64*
  %90 = getelementptr i64, i64* %89, i32 1
  store i64 %82, i64* %90
; # (set P (link (ofs P 3)))
; # (ofs P 3)
  %91 = add i64 %82, 24
; # (link (ofs P 3))
  %92 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %93 = load i64, i64* %92
  %94 = inttoptr i64 %91 to i64*
  %95 = getelementptr i64, i64* %94, i32 1
  store i64 %93, i64* %95
  %96 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %91, i64* %96
  %97 = inttoptr i64 %82 to i64*
  store i64 %91, i64* %97
; # (? (atom (shift X)))
; # (shift X)
  %98 = inttoptr i64 %75 to i64*
  %99 = getelementptr i64, i64* %98, i32 1
  %100 = load i64, i64* %99
; # (atom (shift X))
  %101 = and i64 %100, 15
  %102 = icmp ne i64 %101, 0
  br i1 %102, label %$16, label %$15
$15:
  %103 = phi i64 [%100, %$14] ; # X
  %104 = phi i64 [%76, %$14] ; # R
  %105 = phi i64 [%77, %$14] ; # R2
  %106 = phi i64 [%82, %$14] ; # P
  %107 = phi i64 [%79, %$14] ; # Q
; # (set 2 Q (push NIL NIL))
; # (push NIL NIL)
  %108 = alloca i64, i64 2, align 16
  %109 = ptrtoint i64* %108 to i64
  %110 = inttoptr i64 %107 to i64*
  %111 = getelementptr i64, i64* %110, i32 1
  store i64 %109, i64* %111
  br label %$7
$16:
  %112 = phi i64 [%100, %$14] ; # X
  %113 = phi i64 [%76, %$14] ; # R
  %114 = phi i64 [%77, %$14] ; # R2
  %115 = phi i64 [%82, %$14] ; # P
  %116 = phi i64 [%79, %$14] ; # Q
  %117 = phi i64 [0, %$14] ; # ->
; # (when (pair (car A)) (loop (let Y (evList E) (when (gt0 (compare ...
; # (car A)
  %118 = inttoptr i64 %33 to i64*
  %119 = load i64, i64* %118
; # (pair (car A))
  %120 = and i64 %119, 15
  %121 = icmp eq i64 %120, 0
  br i1 %121, label %$17, label %$18
$17:
  %122 = phi i64 [%112, %$16] ; # X
  %123 = phi i64 [%113, %$16] ; # R
  %124 = phi i64 [%114, %$16] ; # R2
; # (loop (let Y (evList E) (when (gt0 (compare Y R2)) (setq R (caar ...
  br label %$19
$19:
  %125 = phi i64 [%122, %$17], [%218, %$26] ; # X
  %126 = phi i64 [%123, %$17], [%219, %$26] ; # R
  %127 = phi i64 [%124, %$17], [%220, %$26] ; # R2
; # (let Y (evList E) (when (gt0 (compare Y R2)) (setq R (caar A)) (s...
; # (evList E)
  %128 = call i64 @evList(i64 %25)
; # (when (gt0 (compare Y R2)) (setq R (caar A)) (setq R2 (safe Y)))
; # (compare Y R2)
  %129 = call i64 @compare(i64 %128, i64 %127)
; # (gt0 (compare Y R2))
  %130 = icmp sgt i64 %129, 0
  br i1 %130, label %$20, label %$21
$20:
  %131 = phi i64 [%125, %$19] ; # X
  %132 = phi i64 [%126, %$19] ; # R
  %133 = phi i64 [%127, %$19] ; # R2
; # (caar A)
  %134 = inttoptr i64 %33 to i64*
  %135 = load i64, i64* %134
  %136 = inttoptr i64 %135 to i64*
  %137 = load i64, i64* %136
; # (safe Y)
  %138 = inttoptr i64 %7 to i64*
  store i64 %128, i64* %138
  br label %$21
$21:
  %139 = phi i64 [%125, %$19], [%131, %$20] ; # X
  %140 = phi i64 [%126, %$19], [%137, %$20] ; # R
  %141 = phi i64 [%127, %$19], [%128, %$20] ; # R2
; # (? (atom (set A (cdar A))))
; # (set A (cdar A))
; # (cdar A)
  %142 = inttoptr i64 %33 to i64*
  %143 = load i64, i64* %142
  %144 = inttoptr i64 %143 to i64*
  %145 = getelementptr i64, i64* %144, i32 1
  %146 = load i64, i64* %145
  %147 = inttoptr i64 %33 to i64*
  store i64 %146, i64* %147
; # (atom (set A (cdar A)))
  %148 = and i64 %146, 15
  %149 = icmp ne i64 %148, 0
  br i1 %149, label %$23, label %$22
$22:
  %150 = phi i64 [%139, %$21] ; # X
  %151 = phi i64 [%140, %$21] ; # R
  %152 = phi i64 [%141, %$21] ; # R2
; # (let (P (cdr E) Q A) (set 4 P (car @)) (while (pair (shift P)) (s...
; # (cdr E)
  %153 = inttoptr i64 %25 to i64*
  %154 = getelementptr i64, i64* %153, i32 1
  %155 = load i64, i64* %154
; # (set 4 P (car @))
; # (car @)
  %156 = inttoptr i64 %146 to i64*
  %157 = load i64, i64* %156
  %158 = inttoptr i64 %155 to i64*
  %159 = getelementptr i64, i64* %158, i32 3
  store i64 %157, i64* %159
; # (while (pair (shift P)) (set 4 P (cond ((atom (car (shift Q))) @)...
  br label %$24
$24:
  %160 = phi i64 [%150, %$22], [%210, %$27] ; # X
  %161 = phi i64 [%151, %$22], [%211, %$27] ; # R
  %162 = phi i64 [%152, %$22], [%212, %$27] ; # R2
  %163 = phi i64 [%155, %$22], [%213, %$27] ; # P
  %164 = phi i64 [%33, %$22], [%214, %$27] ; # Q
; # (shift P)
  %165 = inttoptr i64 %163 to i64*
  %166 = getelementptr i64, i64* %165, i32 1
  %167 = load i64, i64* %166
; # (pair (shift P))
  %168 = and i64 %167, 15
  %169 = icmp eq i64 %168, 0
  br i1 %169, label %$25, label %$26
$25:
  %170 = phi i64 [%160, %$24] ; # X
  %171 = phi i64 [%161, %$24] ; # R
  %172 = phi i64 [%162, %$24] ; # R2
  %173 = phi i64 [%167, %$24] ; # P
  %174 = phi i64 [%164, %$24] ; # Q
; # (set 4 P (cond ((atom (car (shift Q))) @) ((atom (set Q (cdr @)))...
; # (cond ((atom (car (shift Q))) @) ((atom (set Q (cdr @))) @) (T (c...
; # (shift Q)
  %175 = inttoptr i64 %174 to i64*
  %176 = getelementptr i64, i64* %175, i32 1
  %177 = load i64, i64* %176
; # (car (shift Q))
  %178 = inttoptr i64 %177 to i64*
  %179 = load i64, i64* %178
; # (atom (car (shift Q)))
  %180 = and i64 %179, 15
  %181 = icmp ne i64 %180, 0
  br i1 %181, label %$29, label %$28
$29:
  %182 = phi i64 [%170, %$25] ; # X
  %183 = phi i64 [%171, %$25] ; # R
  %184 = phi i64 [%172, %$25] ; # R2
  %185 = phi i64 [%173, %$25] ; # P
  %186 = phi i64 [%177, %$25] ; # Q
  br label %$27
$28:
  %187 = phi i64 [%170, %$25] ; # X
  %188 = phi i64 [%171, %$25] ; # R
  %189 = phi i64 [%172, %$25] ; # R2
  %190 = phi i64 [%173, %$25] ; # P
  %191 = phi i64 [%177, %$25] ; # Q
; # (set Q (cdr @))
; # (cdr @)
  %192 = inttoptr i64 %179 to i64*
  %193 = getelementptr i64, i64* %192, i32 1
  %194 = load i64, i64* %193
  %195 = inttoptr i64 %191 to i64*
  store i64 %194, i64* %195
; # (atom (set Q (cdr @)))
  %196 = and i64 %194, 15
  %197 = icmp ne i64 %196, 0
  br i1 %197, label %$31, label %$30
$31:
  %198 = phi i64 [%187, %$28] ; # X
  %199 = phi i64 [%188, %$28] ; # R
  %200 = phi i64 [%189, %$28] ; # R2
  %201 = phi i64 [%190, %$28] ; # P
  %202 = phi i64 [%191, %$28] ; # Q
  br label %$27
$30:
  %203 = phi i64 [%187, %$28] ; # X
  %204 = phi i64 [%188, %$28] ; # R
  %205 = phi i64 [%189, %$28] ; # R2
  %206 = phi i64 [%190, %$28] ; # P
  %207 = phi i64 [%191, %$28] ; # Q
; # (car @)
  %208 = inttoptr i64 %194 to i64*
  %209 = load i64, i64* %208
  br label %$27
$27:
  %210 = phi i64 [%182, %$29], [%198, %$31], [%203, %$30] ; # X
  %211 = phi i64 [%183, %$29], [%199, %$31], [%204, %$30] ; # R
  %212 = phi i64 [%184, %$29], [%200, %$31], [%205, %$30] ; # R2
  %213 = phi i64 [%185, %$29], [%201, %$31], [%206, %$30] ; # P
  %214 = phi i64 [%186, %$29], [%202, %$31], [%207, %$30] ; # Q
  %215 = phi i64 [%179, %$29], [%194, %$31], [%209, %$30] ; # ->
  %216 = inttoptr i64 %173 to i64*
  %217 = getelementptr i64, i64* %216, i32 3
  store i64 %215, i64* %217
  br label %$24
$26:
  %218 = phi i64 [%160, %$24] ; # X
  %219 = phi i64 [%161, %$24] ; # R
  %220 = phi i64 [%162, %$24] ; # R2
  %221 = phi i64 [%167, %$24] ; # P
  %222 = phi i64 [%164, %$24] ; # Q
  br label %$19
$23:
  %223 = phi i64 [%139, %$21] ; # X
  %224 = phi i64 [%140, %$21] ; # R
  %225 = phi i64 [%141, %$21] ; # R2
  %226 = phi i64 [0, %$21] ; # ->
  br label %$18
$18:
  %227 = phi i64 [%112, %$16], [%223, %$23] ; # X
  %228 = phi i64 [%113, %$16], [%224, %$23] ; # R
  %229 = phi i64 [%114, %$16], [%225, %$23] ; # R2
; # (set $At2 R2)
  %230 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 456) to i64) to i64*
  store i64 %229, i64* %230
; # (drop *Safe)
  %231 = inttoptr i64 %7 to i64*
  %232 = getelementptr i64, i64* %231, i32 1
  %233 = load i64, i64* %232
  %234 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %233, i64* %234
  ret i64 %228
}

define i64 @_Mini(i64) align 8 {
$1:
; # (let (X (cdr Exe) R $Nil R2 (save $T) E (push NIL $Nil ZERO (eval...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (save $T)
  %4 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %5 = load i64, i64* %4
  %6 = alloca i64, i64 2, align 16
  %7 = ptrtoint i64* %6 to i64
  %8 = inttoptr i64 %7 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), i64* %8
  %9 = add i64 %7, 8
  %10 = inttoptr i64 %9 to i64*
  store i64 %5, i64* %10
  %11 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %7, i64* %11
; # (++ X)
  %12 = inttoptr i64 %3 to i64*
  %13 = load i64, i64* %12
  %14 = getelementptr i64, i64* %12, i32 1
  %15 = load i64, i64* %14
; # (eval (++ X))
  %16 = and i64 %13, 6
  %17 = icmp ne i64 %16, 0
  br i1 %17, label %$4, label %$3
$4:
  br label %$2
$3:
  %18 = and i64 %13, 8
  %19 = icmp ne i64 %18, 0
  br i1 %19, label %$6, label %$5
$6:
  %20 = inttoptr i64 %13 to i64*
  %21 = load i64, i64* %20
  br label %$2
$5:
  %22 = call i64 @evList(i64 %13)
  br label %$2
$2:
  %23 = phi i64 [%13, %$4], [%21, %$6], [%22, %$5] ; # ->
; # (push NIL $Nil ZERO (eval (++ X)) NIL)
  %24 = alloca i64, i64 5, align 16
  %25 = ptrtoint i64* %24 to i64
  %26 = add i64 %25, 8
  %27 = inttoptr i64 %26 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %27
  %28 = add i64 %25, 16
  %29 = inttoptr i64 %28 to i64*
  store i64 2, i64* %29
  %30 = add i64 %25, 24
  %31 = inttoptr i64 %30 to i64*
  store i64 %23, i64* %31
; # (push NIL NIL)
  %32 = alloca i64, i64 2, align 16
  %33 = ptrtoint i64* %32 to i64
; # (set E (link (ofs E 3)))
; # (ofs E 3)
  %34 = add i64 %25, 24
; # (link (ofs E 3))
  %35 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %36 = load i64, i64* %35
  %37 = inttoptr i64 %34 to i64*
  %38 = getelementptr i64, i64* %37, i32 1
  store i64 %36, i64* %38
  %39 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %34, i64* %39
  %40 = inttoptr i64 %25 to i64*
  store i64 %34, i64* %40
; # (let (P E Q A) (loop (let V (set Q (save (eval (car X)))) (when (...
; # (loop (let V (set Q (save (eval (car X)))) (when (pair V) (setq V...
  br label %$7
$7:
  %41 = phi i64 [%15, %$2], [%103, %$15] ; # X
  %42 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%104, %$15] ; # R
  %43 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$2], [%105, %$15] ; # R2
  %44 = phi i64 [%25, %$2], [%106, %$15] ; # P
  %45 = phi i64 [%33, %$2], [%109, %$15] ; # Q
; # (let V (set Q (save (eval (car X)))) (when (pair V) (setq V (car ...
; # (set Q (save (eval (car X))))
; # (car X)
  %46 = inttoptr i64 %41 to i64*
  %47 = load i64, i64* %46
; # (eval (car X))
  %48 = and i64 %47, 6
  %49 = icmp ne i64 %48, 0
  br i1 %49, label %$10, label %$9
$10:
  br label %$8
$9:
  %50 = and i64 %47, 8
  %51 = icmp ne i64 %50, 0
  br i1 %51, label %$12, label %$11
$12:
  %52 = inttoptr i64 %47 to i64*
  %53 = load i64, i64* %52
  br label %$8
$11:
  %54 = call i64 @evList(i64 %47)
  br label %$8
$8:
  %55 = phi i64 [%47, %$10], [%53, %$12], [%54, %$11] ; # ->
; # (save (eval (car X)))
  %56 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %57 = load i64, i64* %56
  %58 = alloca i64, i64 2, align 16
  %59 = ptrtoint i64* %58 to i64
  %60 = inttoptr i64 %59 to i64*
  store i64 %55, i64* %60
  %61 = add i64 %59, 8
  %62 = inttoptr i64 %61 to i64*
  store i64 %57, i64* %62
  %63 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %59, i64* %63
  %64 = inttoptr i64 %45 to i64*
  store i64 %55, i64* %64
; # (when (pair V) (setq V (car V)))
; # (pair V)
  %65 = and i64 %55, 15
  %66 = icmp eq i64 %65, 0
  br i1 %66, label %$13, label %$14
$13:
  %67 = phi i64 [%41, %$8] ; # X
  %68 = phi i64 [%42, %$8] ; # R
  %69 = phi i64 [%43, %$8] ; # R2
  %70 = phi i64 [%44, %$8] ; # P
  %71 = phi i64 [%45, %$8] ; # Q
  %72 = phi i64 [%55, %$8] ; # V
; # (car V)
  %73 = inttoptr i64 %72 to i64*
  %74 = load i64, i64* %73
  br label %$14
$14:
  %75 = phi i64 [%41, %$8], [%67, %$13] ; # X
  %76 = phi i64 [%42, %$8], [%68, %$13] ; # R
  %77 = phi i64 [%43, %$8], [%69, %$13] ; # R2
  %78 = phi i64 [%44, %$8], [%70, %$13] ; # P
  %79 = phi i64 [%45, %$8], [%71, %$13] ; # Q
  %80 = phi i64 [%55, %$8], [%74, %$13] ; # V
; # (set 2 P (push NIL $Nil ZERO V NIL))
; # (push NIL $Nil ZERO V NIL)
  %81 = alloca i64, i64 5, align 16
  %82 = ptrtoint i64* %81 to i64
  %83 = add i64 %82, 8
  %84 = inttoptr i64 %83 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %84
  %85 = add i64 %82, 16
  %86 = inttoptr i64 %85 to i64*
  store i64 2, i64* %86
  %87 = add i64 %82, 24
  %88 = inttoptr i64 %87 to i64*
  store i64 %80, i64* %88
  %89 = inttoptr i64 %78 to i64*
  %90 = getelementptr i64, i64* %89, i32 1
  store i64 %82, i64* %90
; # (set P (link (ofs P 3)))
; # (ofs P 3)
  %91 = add i64 %82, 24
; # (link (ofs P 3))
  %92 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %93 = load i64, i64* %92
  %94 = inttoptr i64 %91 to i64*
  %95 = getelementptr i64, i64* %94, i32 1
  store i64 %93, i64* %95
  %96 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %91, i64* %96
  %97 = inttoptr i64 %82 to i64*
  store i64 %91, i64* %97
; # (? (atom (shift X)))
; # (shift X)
  %98 = inttoptr i64 %75 to i64*
  %99 = getelementptr i64, i64* %98, i32 1
  %100 = load i64, i64* %99
; # (atom (shift X))
  %101 = and i64 %100, 15
  %102 = icmp ne i64 %101, 0
  br i1 %102, label %$16, label %$15
$15:
  %103 = phi i64 [%100, %$14] ; # X
  %104 = phi i64 [%76, %$14] ; # R
  %105 = phi i64 [%77, %$14] ; # R2
  %106 = phi i64 [%82, %$14] ; # P
  %107 = phi i64 [%79, %$14] ; # Q
; # (set 2 Q (push NIL NIL))
; # (push NIL NIL)
  %108 = alloca i64, i64 2, align 16
  %109 = ptrtoint i64* %108 to i64
  %110 = inttoptr i64 %107 to i64*
  %111 = getelementptr i64, i64* %110, i32 1
  store i64 %109, i64* %111
  br label %$7
$16:
  %112 = phi i64 [%100, %$14] ; # X
  %113 = phi i64 [%76, %$14] ; # R
  %114 = phi i64 [%77, %$14] ; # R2
  %115 = phi i64 [%82, %$14] ; # P
  %116 = phi i64 [%79, %$14] ; # Q
  %117 = phi i64 [0, %$14] ; # ->
; # (when (pair (car A)) (loop (let Y (evList E) (when (lt0 (compare ...
; # (car A)
  %118 = inttoptr i64 %33 to i64*
  %119 = load i64, i64* %118
; # (pair (car A))
  %120 = and i64 %119, 15
  %121 = icmp eq i64 %120, 0
  br i1 %121, label %$17, label %$18
$17:
  %122 = phi i64 [%112, %$16] ; # X
  %123 = phi i64 [%113, %$16] ; # R
  %124 = phi i64 [%114, %$16] ; # R2
; # (loop (let Y (evList E) (when (lt0 (compare Y R2)) (setq R (caar ...
  br label %$19
$19:
  %125 = phi i64 [%122, %$17], [%218, %$26] ; # X
  %126 = phi i64 [%123, %$17], [%219, %$26] ; # R
  %127 = phi i64 [%124, %$17], [%220, %$26] ; # R2
; # (let Y (evList E) (when (lt0 (compare Y R2)) (setq R (caar A)) (s...
; # (evList E)
  %128 = call i64 @evList(i64 %25)
; # (when (lt0 (compare Y R2)) (setq R (caar A)) (setq R2 (safe Y)))
; # (compare Y R2)
  %129 = call i64 @compare(i64 %128, i64 %127)
; # (lt0 (compare Y R2))
  %130 = icmp slt i64 %129, 0
  br i1 %130, label %$20, label %$21
$20:
  %131 = phi i64 [%125, %$19] ; # X
  %132 = phi i64 [%126, %$19] ; # R
  %133 = phi i64 [%127, %$19] ; # R2
; # (caar A)
  %134 = inttoptr i64 %33 to i64*
  %135 = load i64, i64* %134
  %136 = inttoptr i64 %135 to i64*
  %137 = load i64, i64* %136
; # (safe Y)
  %138 = inttoptr i64 %7 to i64*
  store i64 %128, i64* %138
  br label %$21
$21:
  %139 = phi i64 [%125, %$19], [%131, %$20] ; # X
  %140 = phi i64 [%126, %$19], [%137, %$20] ; # R
  %141 = phi i64 [%127, %$19], [%128, %$20] ; # R2
; # (? (atom (set A (cdar A))))
; # (set A (cdar A))
; # (cdar A)
  %142 = inttoptr i64 %33 to i64*
  %143 = load i64, i64* %142
  %144 = inttoptr i64 %143 to i64*
  %145 = getelementptr i64, i64* %144, i32 1
  %146 = load i64, i64* %145
  %147 = inttoptr i64 %33 to i64*
  store i64 %146, i64* %147
; # (atom (set A (cdar A)))
  %148 = and i64 %146, 15
  %149 = icmp ne i64 %148, 0
  br i1 %149, label %$23, label %$22
$22:
  %150 = phi i64 [%139, %$21] ; # X
  %151 = phi i64 [%140, %$21] ; # R
  %152 = phi i64 [%141, %$21] ; # R2
; # (let (P (cdr E) Q A) (set 4 P (car @)) (while (pair (shift P)) (s...
; # (cdr E)
  %153 = inttoptr i64 %25 to i64*
  %154 = getelementptr i64, i64* %153, i32 1
  %155 = load i64, i64* %154
; # (set 4 P (car @))
; # (car @)
  %156 = inttoptr i64 %146 to i64*
  %157 = load i64, i64* %156
  %158 = inttoptr i64 %155 to i64*
  %159 = getelementptr i64, i64* %158, i32 3
  store i64 %157, i64* %159
; # (while (pair (shift P)) (set 4 P (cond ((atom (car (shift Q))) @)...
  br label %$24
$24:
  %160 = phi i64 [%150, %$22], [%210, %$27] ; # X
  %161 = phi i64 [%151, %$22], [%211, %$27] ; # R
  %162 = phi i64 [%152, %$22], [%212, %$27] ; # R2
  %163 = phi i64 [%155, %$22], [%213, %$27] ; # P
  %164 = phi i64 [%33, %$22], [%214, %$27] ; # Q
; # (shift P)
  %165 = inttoptr i64 %163 to i64*
  %166 = getelementptr i64, i64* %165, i32 1
  %167 = load i64, i64* %166
; # (pair (shift P))
  %168 = and i64 %167, 15
  %169 = icmp eq i64 %168, 0
  br i1 %169, label %$25, label %$26
$25:
  %170 = phi i64 [%160, %$24] ; # X
  %171 = phi i64 [%161, %$24] ; # R
  %172 = phi i64 [%162, %$24] ; # R2
  %173 = phi i64 [%167, %$24] ; # P
  %174 = phi i64 [%164, %$24] ; # Q
; # (set 4 P (cond ((atom (car (shift Q))) @) ((atom (set Q (cdr @)))...
; # (cond ((atom (car (shift Q))) @) ((atom (set Q (cdr @))) @) (T (c...
; # (shift Q)
  %175 = inttoptr i64 %174 to i64*
  %176 = getelementptr i64, i64* %175, i32 1
  %177 = load i64, i64* %176
; # (car (shift Q))
  %178 = inttoptr i64 %177 to i64*
  %179 = load i64, i64* %178
; # (atom (car (shift Q)))
  %180 = and i64 %179, 15
  %181 = icmp ne i64 %180, 0
  br i1 %181, label %$29, label %$28
$29:
  %182 = phi i64 [%170, %$25] ; # X
  %183 = phi i64 [%171, %$25] ; # R
  %184 = phi i64 [%172, %$25] ; # R2
  %185 = phi i64 [%173, %$25] ; # P
  %186 = phi i64 [%177, %$25] ; # Q
  br label %$27
$28:
  %187 = phi i64 [%170, %$25] ; # X
  %188 = phi i64 [%171, %$25] ; # R
  %189 = phi i64 [%172, %$25] ; # R2
  %190 = phi i64 [%173, %$25] ; # P
  %191 = phi i64 [%177, %$25] ; # Q
; # (set Q (cdr @))
; # (cdr @)
  %192 = inttoptr i64 %179 to i64*
  %193 = getelementptr i64, i64* %192, i32 1
  %194 = load i64, i64* %193
  %195 = inttoptr i64 %191 to i64*
  store i64 %194, i64* %195
; # (atom (set Q (cdr @)))
  %196 = and i64 %194, 15
  %197 = icmp ne i64 %196, 0
  br i1 %197, label %$31, label %$30
$31:
  %198 = phi i64 [%187, %$28] ; # X
  %199 = phi i64 [%188, %$28] ; # R
  %200 = phi i64 [%189, %$28] ; # R2
  %201 = phi i64 [%190, %$28] ; # P
  %202 = phi i64 [%191, %$28] ; # Q
  br label %$27
$30:
  %203 = phi i64 [%187, %$28] ; # X
  %204 = phi i64 [%188, %$28] ; # R
  %205 = phi i64 [%189, %$28] ; # R2
  %206 = phi i64 [%190, %$28] ; # P
  %207 = phi i64 [%191, %$28] ; # Q
; # (car @)
  %208 = inttoptr i64 %194 to i64*
  %209 = load i64, i64* %208
  br label %$27
$27:
  %210 = phi i64 [%182, %$29], [%198, %$31], [%203, %$30] ; # X
  %211 = phi i64 [%183, %$29], [%199, %$31], [%204, %$30] ; # R
  %212 = phi i64 [%184, %$29], [%200, %$31], [%205, %$30] ; # R2
  %213 = phi i64 [%185, %$29], [%201, %$31], [%206, %$30] ; # P
  %214 = phi i64 [%186, %$29], [%202, %$31], [%207, %$30] ; # Q
  %215 = phi i64 [%179, %$29], [%194, %$31], [%209, %$30] ; # ->
  %216 = inttoptr i64 %173 to i64*
  %217 = getelementptr i64, i64* %216, i32 3
  store i64 %215, i64* %217
  br label %$24
$26:
  %218 = phi i64 [%160, %$24] ; # X
  %219 = phi i64 [%161, %$24] ; # R
  %220 = phi i64 [%162, %$24] ; # R2
  %221 = phi i64 [%167, %$24] ; # P
  %222 = phi i64 [%164, %$24] ; # Q
  br label %$19
$23:
  %223 = phi i64 [%139, %$21] ; # X
  %224 = phi i64 [%140, %$21] ; # R
  %225 = phi i64 [%141, %$21] ; # R2
  %226 = phi i64 [0, %$21] ; # ->
  br label %$18
$18:
  %227 = phi i64 [%112, %$16], [%223, %$23] ; # X
  %228 = phi i64 [%113, %$16], [%224, %$23] ; # R
  %229 = phi i64 [%114, %$16], [%225, %$23] ; # R2
; # (set $At2 R2)
  %230 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 456) to i64) to i64*
  store i64 %229, i64* %230
; # (drop *Safe)
  %231 = inttoptr i64 %7 to i64*
  %232 = getelementptr i64, i64* %231, i32 1
  %233 = load i64, i64* %232
  %234 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %233, i64* %234
  ret i64 %228
}

define void @fish(i64, i64, i64, i64, i64) align 8 {
$1:
; # (set P V)
  %5 = inttoptr i64 %2 to i64*
  store i64 %1, i64* %5
; # (cond ((nil? (evList E)) (when (pair V) (stkChk 0) (unless (nil? ...
; # (evList E)
  %6 = call i64 @evList(i64 %0)
; # (nil? (evList E))
  %7 = icmp eq i64 %6, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %7, label %$4, label %$3
$4:
; # (when (pair V) (stkChk 0) (unless (nil? (cdr V)) (fish E @ P R S)...
; # (pair V)
  %8 = and i64 %1, 15
  %9 = icmp eq i64 %8, 0
  br i1 %9, label %$5, label %$6
$5:
; # (stkChk 0)
  %10 = load i8*, i8** @$StkLimit
  %11 = call i8* @llvm.stacksave()
  %12 = icmp ugt i8* %10, %11
  br i1 %12, label %$7, label %$8
$7:
  call void @stkErr(i64 0)
  unreachable
$8:
; # (unless (nil? (cdr V)) (fish E @ P R S))
; # (cdr V)
  %13 = inttoptr i64 %1 to i64*
  %14 = getelementptr i64, i64* %13, i32 1
  %15 = load i64, i64* %14
; # (nil? (cdr V))
  %16 = icmp eq i64 %15, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %16, label %$10, label %$9
$9:
; # (fish E @ P R S)
  call void @fish(i64 %0, i64 %15, i64 %2, i64 %3, i64 %4)
  br label %$10
$10:
; # (car V)
  %17 = inttoptr i64 %1 to i64*
  %18 = load i64, i64* %17
; # (fish E (car V) P R S)
  call void @fish(i64 %0, i64 %18, i64 %2, i64 %3, i64 %4)
  br label %$6
$6:
  br label %$2
$3:
; # (<> @ S)
  %19 = icmp ne i64 %6, %4
  br i1 %19, label %$12, label %$11
$12:
; # (set R (cons V (val R)))
; # (val R)
  %20 = inttoptr i64 %3 to i64*
  %21 = load i64, i64* %20
; # (cons V (val R))
  %22 = call i64 @cons(i64 %1, i64 %21)
  %23 = inttoptr i64 %3 to i64*
  store i64 %22, i64* %23
  br label %$2
$11:
  br label %$2
$2:
  ret void
}

define i64 @_Fish(i64) align 8 {
$1:
; # (let (X (cdr Exe) R (link (push $Nil NIL) T) P (push NIL $Nil ZER...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (push $Nil NIL)
  %4 = alloca i64, i64 2, align 16
  %5 = ptrtoint i64* %4 to i64
  %6 = inttoptr i64 %5 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %6
; # (link (push $Nil NIL) T)
  %7 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %8 = load i64, i64* %7
  %9 = inttoptr i64 %5 to i64*
  %10 = getelementptr i64, i64* %9, i32 1
  store i64 %8, i64* %10
  %11 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %5, i64* %11
; # (push NIL $Nil ZERO NIL)
  %12 = alloca i64, i64 4, align 16
  %13 = ptrtoint i64* %12 to i64
  %14 = add i64 %13, 8
  %15 = inttoptr i64 %14 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %15
  %16 = add i64 %13, 16
  %17 = inttoptr i64 %16 to i64*
  store i64 2, i64* %17
; # (++ X)
  %18 = inttoptr i64 %3 to i64*
  %19 = load i64, i64* %18
  %20 = getelementptr i64, i64* %18, i32 1
  %21 = load i64, i64* %20
; # (eval (++ X))
  %22 = and i64 %19, 6
  %23 = icmp ne i64 %22, 0
  br i1 %23, label %$4, label %$3
$4:
  br label %$2
$3:
  %24 = and i64 %19, 8
  %25 = icmp ne i64 %24, 0
  br i1 %25, label %$6, label %$5
$6:
  %26 = inttoptr i64 %19 to i64*
  %27 = load i64, i64* %26
  br label %$2
$5:
  %28 = call i64 @evList(i64 %19)
  br label %$2
$2:
  %29 = phi i64 [%19, %$4], [%27, %$6], [%28, %$5] ; # ->
; # (push NIL P ZERO (eval (++ X)) NIL)
  %30 = alloca i64, i64 5, align 16
  %31 = ptrtoint i64* %30 to i64
  %32 = add i64 %31, 8
  %33 = inttoptr i64 %32 to i64*
  store i64 %13, i64* %33
  %34 = add i64 %31, 16
  %35 = inttoptr i64 %34 to i64*
  store i64 2, i64* %35
  %36 = add i64 %31, 24
  %37 = inttoptr i64 %36 to i64*
  store i64 %29, i64* %37
; # (set P (ofs P 3) E (link (ofs E 3)))
; # (ofs P 3)
  %38 = add i64 %13, 24
  %39 = inttoptr i64 %13 to i64*
  store i64 %38, i64* %39
; # (ofs E 3)
  %40 = add i64 %31, 24
; # (link (ofs E 3))
  %41 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %42 = load i64, i64* %41
  %43 = inttoptr i64 %40 to i64*
  %44 = getelementptr i64, i64* %43, i32 1
  store i64 %42, i64* %44
  %45 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %40, i64* %45
  %46 = inttoptr i64 %31 to i64*
  store i64 %40, i64* %46
; # (let (V (save (eval (++ X))) S (save (eval (car X))) Q P) (while ...
; # (++ X)
  %47 = inttoptr i64 %21 to i64*
  %48 = load i64, i64* %47
  %49 = getelementptr i64, i64* %47, i32 1
  %50 = load i64, i64* %49
; # (eval (++ X))
  %51 = and i64 %48, 6
  %52 = icmp ne i64 %51, 0
  br i1 %52, label %$9, label %$8
$9:
  br label %$7
$8:
  %53 = and i64 %48, 8
  %54 = icmp ne i64 %53, 0
  br i1 %54, label %$11, label %$10
$11:
  %55 = inttoptr i64 %48 to i64*
  %56 = load i64, i64* %55
  br label %$7
$10:
  %57 = call i64 @evList(i64 %48)
  br label %$7
$7:
  %58 = phi i64 [%48, %$9], [%56, %$11], [%57, %$10] ; # ->
; # (save (eval (++ X)))
  %59 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %60 = load i64, i64* %59
  %61 = alloca i64, i64 2, align 16
  %62 = ptrtoint i64* %61 to i64
  %63 = inttoptr i64 %62 to i64*
  store i64 %58, i64* %63
  %64 = add i64 %62, 8
  %65 = inttoptr i64 %64 to i64*
  store i64 %60, i64* %65
  %66 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %62, i64* %66
; # (car X)
  %67 = inttoptr i64 %50 to i64*
  %68 = load i64, i64* %67
; # (eval (car X))
  %69 = and i64 %68, 6
  %70 = icmp ne i64 %69, 0
  br i1 %70, label %$14, label %$13
$14:
  br label %$12
$13:
  %71 = and i64 %68, 8
  %72 = icmp ne i64 %71, 0
  br i1 %72, label %$16, label %$15
$16:
  %73 = inttoptr i64 %68 to i64*
  %74 = load i64, i64* %73
  br label %$12
$15:
  %75 = call i64 @evList(i64 %68)
  br label %$12
$12:
  %76 = phi i64 [%68, %$14], [%74, %$16], [%75, %$15] ; # ->
; # (save (eval (car X)))
  %77 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %78 = load i64, i64* %77
  %79 = alloca i64, i64 2, align 16
  %80 = ptrtoint i64* %79 to i64
  %81 = inttoptr i64 %80 to i64*
  store i64 %76, i64* %81
  %82 = add i64 %80, 8
  %83 = inttoptr i64 %82 to i64*
  store i64 %78, i64* %83
  %84 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %80, i64* %84
; # (while (pair (shift X)) (setq Q (set 2 Q (push NIL $Nil ZERO (eva...
  br label %$17
$17:
  %85 = phi i64 [%50, %$12], [%92, %$20] ; # X
  %86 = phi i64 [%13, %$12], [%105, %$20] ; # Q
; # (shift X)
  %87 = inttoptr i64 %85 to i64*
  %88 = getelementptr i64, i64* %87, i32 1
  %89 = load i64, i64* %88
; # (pair (shift X))
  %90 = and i64 %89, 15
  %91 = icmp eq i64 %90, 0
  br i1 %91, label %$18, label %$19
$18:
  %92 = phi i64 [%89, %$17] ; # X
  %93 = phi i64 [%86, %$17] ; # Q
; # (set 2 Q (push NIL $Nil ZERO (eval (car X)) NIL))
; # (car X)
  %94 = inttoptr i64 %92 to i64*
  %95 = load i64, i64* %94
; # (eval (car X))
  %96 = and i64 %95, 6
  %97 = icmp ne i64 %96, 0
  br i1 %97, label %$22, label %$21
$22:
  br label %$20
$21:
  %98 = and i64 %95, 8
  %99 = icmp ne i64 %98, 0
  br i1 %99, label %$24, label %$23
$24:
  %100 = inttoptr i64 %95 to i64*
  %101 = load i64, i64* %100
  br label %$20
$23:
  %102 = call i64 @evList(i64 %95)
  br label %$20
$20:
  %103 = phi i64 [%95, %$22], [%101, %$24], [%102, %$23] ; # ->
; # (push NIL $Nil ZERO (eval (car X)) NIL)
  %104 = alloca i64, i64 5, align 16
  %105 = ptrtoint i64* %104 to i64
  %106 = add i64 %105, 8
  %107 = inttoptr i64 %106 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %107
  %108 = add i64 %105, 16
  %109 = inttoptr i64 %108 to i64*
  store i64 2, i64* %109
  %110 = add i64 %105, 24
  %111 = inttoptr i64 %110 to i64*
  store i64 %103, i64* %111
  %112 = inttoptr i64 %93 to i64*
  %113 = getelementptr i64, i64* %112, i32 1
  store i64 %105, i64* %113
; # (set Q (link (ofs Q 3)))
; # (ofs Q 3)
  %114 = add i64 %105, 24
; # (link (ofs Q 3))
  %115 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %116 = load i64, i64* %115
  %117 = inttoptr i64 %114 to i64*
  %118 = getelementptr i64, i64* %117, i32 1
  store i64 %116, i64* %118
  %119 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %114, i64* %119
  %120 = inttoptr i64 %105 to i64*
  store i64 %114, i64* %120
  br label %$17
$19:
  %121 = phi i64 [%89, %$17] ; # X
  %122 = phi i64 [%86, %$17] ; # Q
; # (ofs P 3)
  %123 = add i64 %13, 24
; # (fish E V (ofs P 3) R S)
  call void @fish(i64 %31, i64 %58, i64 %123, i64 %5, i64 %76)
; # (val R)
  %124 = inttoptr i64 %5 to i64*
  %125 = load i64, i64* %124
; # (drop *Safe)
  %126 = inttoptr i64 %5 to i64*
  %127 = getelementptr i64, i64* %126, i32 1
  %128 = load i64, i64* %127
  %129 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %128, i64* %129
  ret i64 %125
}

define i64 @_By(i64) align 8 {
$1:
; # (let (X (cdr Exe) R (save $Nil) L 0 E (push NIL $Nil ZERO (eval (...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (save $Nil)
  %4 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %5 = load i64, i64* %4
  %6 = alloca i64, i64 2, align 16
  %7 = ptrtoint i64* %6 to i64
  %8 = inttoptr i64 %7 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %8
  %9 = add i64 %7, 8
  %10 = inttoptr i64 %9 to i64*
  store i64 %5, i64* %10
  %11 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %7, i64* %11
; # (++ X)
  %12 = inttoptr i64 %3 to i64*
  %13 = load i64, i64* %12
  %14 = getelementptr i64, i64* %12, i32 1
  %15 = load i64, i64* %14
; # (eval (++ X))
  %16 = and i64 %13, 6
  %17 = icmp ne i64 %16, 0
  br i1 %17, label %$4, label %$3
$4:
  br label %$2
$3:
  %18 = and i64 %13, 8
  %19 = icmp ne i64 %18, 0
  br i1 %19, label %$6, label %$5
$6:
  %20 = inttoptr i64 %13 to i64*
  %21 = load i64, i64* %20
  br label %$2
$5:
  %22 = call i64 @evList(i64 %13)
  br label %$2
$2:
  %23 = phi i64 [%13, %$4], [%21, %$6], [%22, %$5] ; # ->
; # (push NIL $Nil ZERO (eval (++ X)) NIL)
  %24 = alloca i64, i64 5, align 16
  %25 = ptrtoint i64* %24 to i64
  %26 = add i64 %25, 8
  %27 = inttoptr i64 %26 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %27
  %28 = add i64 %25, 16
  %29 = inttoptr i64 %28 to i64*
  store i64 2, i64* %29
  %30 = add i64 %25, 24
  %31 = inttoptr i64 %30 to i64*
  store i64 %23, i64* %31
; # (push NIL NIL)
  %32 = alloca i64, i64 2, align 16
  %33 = ptrtoint i64* %32 to i64
; # (++ X)
  %34 = inttoptr i64 %15 to i64*
  %35 = load i64, i64* %34
  %36 = getelementptr i64, i64* %34, i32 1
  %37 = load i64, i64* %36
; # (eval (++ X))
  %38 = and i64 %35, 6
  %39 = icmp ne i64 %38, 0
  br i1 %39, label %$9, label %$8
$9:
  br label %$7
$8:
  %40 = and i64 %35, 8
  %41 = icmp ne i64 %40, 0
  br i1 %41, label %$11, label %$10
$11:
  %42 = inttoptr i64 %35 to i64*
  %43 = load i64, i64* %42
  br label %$7
$10:
  %44 = call i64 @evList(i64 %35)
  br label %$7
$7:
  %45 = phi i64 [%35, %$9], [%43, %$11], [%44, %$10] ; # ->
; # (save (eval (++ X)))
  %46 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %47 = load i64, i64* %46
  %48 = alloca i64, i64 2, align 16
  %49 = ptrtoint i64* %48 to i64
  %50 = inttoptr i64 %49 to i64*
  store i64 %45, i64* %50
  %51 = add i64 %49, 8
  %52 = inttoptr i64 %51 to i64*
  store i64 %47, i64* %52
  %53 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %49, i64* %53
; # (set E (link (ofs E 3)))
; # (ofs E 3)
  %54 = add i64 %25, 24
; # (link (ofs E 3))
  %55 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %56 = load i64, i64* %55
  %57 = inttoptr i64 %54 to i64*
  %58 = getelementptr i64, i64* %57, i32 1
  store i64 %56, i64* %58
  %59 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %54, i64* %59
  %60 = inttoptr i64 %25 to i64*
  store i64 %54, i64* %60
; # (let (P E Q A) (loop (let V (set Q (save (eval (car X)))) (when (...
; # (loop (let V (set Q (save (eval (car X)))) (when (pair V) (setq V...
  br label %$12
$12:
  %61 = phi i64 [%37, %$7], [%123, %$20] ; # X
  %62 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$7], [%124, %$20] ; # R
  %63 = phi i64 [0, %$7], [%125, %$20] ; # L
  %64 = phi i64 [%25, %$7], [%126, %$20] ; # P
  %65 = phi i64 [%33, %$7], [%129, %$20] ; # Q
; # (let V (set Q (save (eval (car X)))) (when (pair V) (setq V (car ...
; # (set Q (save (eval (car X))))
; # (car X)
  %66 = inttoptr i64 %61 to i64*
  %67 = load i64, i64* %66
; # (eval (car X))
  %68 = and i64 %67, 6
  %69 = icmp ne i64 %68, 0
  br i1 %69, label %$15, label %$14
$15:
  br label %$13
$14:
  %70 = and i64 %67, 8
  %71 = icmp ne i64 %70, 0
  br i1 %71, label %$17, label %$16
$17:
  %72 = inttoptr i64 %67 to i64*
  %73 = load i64, i64* %72
  br label %$13
$16:
  %74 = call i64 @evList(i64 %67)
  br label %$13
$13:
  %75 = phi i64 [%67, %$15], [%73, %$17], [%74, %$16] ; # ->
; # (save (eval (car X)))
  %76 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %77 = load i64, i64* %76
  %78 = alloca i64, i64 2, align 16
  %79 = ptrtoint i64* %78 to i64
  %80 = inttoptr i64 %79 to i64*
  store i64 %75, i64* %80
  %81 = add i64 %79, 8
  %82 = inttoptr i64 %81 to i64*
  store i64 %77, i64* %82
  %83 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %79, i64* %83
  %84 = inttoptr i64 %65 to i64*
  store i64 %75, i64* %84
; # (when (pair V) (setq V (car V)))
; # (pair V)
  %85 = and i64 %75, 15
  %86 = icmp eq i64 %85, 0
  br i1 %86, label %$18, label %$19
$18:
  %87 = phi i64 [%61, %$13] ; # X
  %88 = phi i64 [%62, %$13] ; # R
  %89 = phi i64 [%63, %$13] ; # L
  %90 = phi i64 [%64, %$13] ; # P
  %91 = phi i64 [%65, %$13] ; # Q
  %92 = phi i64 [%75, %$13] ; # V
; # (car V)
  %93 = inttoptr i64 %92 to i64*
  %94 = load i64, i64* %93
  br label %$19
$19:
  %95 = phi i64 [%61, %$13], [%87, %$18] ; # X
  %96 = phi i64 [%62, %$13], [%88, %$18] ; # R
  %97 = phi i64 [%63, %$13], [%89, %$18] ; # L
  %98 = phi i64 [%64, %$13], [%90, %$18] ; # P
  %99 = phi i64 [%65, %$13], [%91, %$18] ; # Q
  %100 = phi i64 [%75, %$13], [%94, %$18] ; # V
; # (set 2 P (push NIL $Nil ZERO V NIL))
; # (push NIL $Nil ZERO V NIL)
  %101 = alloca i64, i64 5, align 16
  %102 = ptrtoint i64* %101 to i64
  %103 = add i64 %102, 8
  %104 = inttoptr i64 %103 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %104
  %105 = add i64 %102, 16
  %106 = inttoptr i64 %105 to i64*
  store i64 2, i64* %106
  %107 = add i64 %102, 24
  %108 = inttoptr i64 %107 to i64*
  store i64 %100, i64* %108
  %109 = inttoptr i64 %98 to i64*
  %110 = getelementptr i64, i64* %109, i32 1
  store i64 %102, i64* %110
; # (set P (link (ofs P 3)))
; # (ofs P 3)
  %111 = add i64 %102, 24
; # (link (ofs P 3))
  %112 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %113 = load i64, i64* %112
  %114 = inttoptr i64 %111 to i64*
  %115 = getelementptr i64, i64* %114, i32 1
  store i64 %113, i64* %115
  %116 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %111, i64* %116
  %117 = inttoptr i64 %102 to i64*
  store i64 %111, i64* %117
; # (? (atom (shift X)))
; # (shift X)
  %118 = inttoptr i64 %95 to i64*
  %119 = getelementptr i64, i64* %118, i32 1
  %120 = load i64, i64* %119
; # (atom (shift X))
  %121 = and i64 %120, 15
  %122 = icmp ne i64 %121, 0
  br i1 %122, label %$21, label %$20
$20:
  %123 = phi i64 [%120, %$19] ; # X
  %124 = phi i64 [%96, %$19] ; # R
  %125 = phi i64 [%97, %$19] ; # L
  %126 = phi i64 [%102, %$19] ; # P
  %127 = phi i64 [%99, %$19] ; # Q
; # (set 2 Q (push NIL NIL))
; # (push NIL NIL)
  %128 = alloca i64, i64 2, align 16
  %129 = ptrtoint i64* %128 to i64
  %130 = inttoptr i64 %127 to i64*
  %131 = getelementptr i64, i64* %130, i32 1
  store i64 %129, i64* %131
  br label %$12
$21:
  %132 = phi i64 [%120, %$19] ; # X
  %133 = phi i64 [%96, %$19] ; # R
  %134 = phi i64 [%97, %$19] ; # L
  %135 = phi i64 [%102, %$19] ; # P
  %136 = phi i64 [%99, %$19] ; # Q
  %137 = phi i64 [0, %$19] ; # ->
; # (when (pair (car A)) (loop (let Y (cons (cons (evList E) (caar A)...
; # (car A)
  %138 = inttoptr i64 %33 to i64*
  %139 = load i64, i64* %138
; # (pair (car A))
  %140 = and i64 %139, 15
  %141 = icmp eq i64 %140, 0
  br i1 %141, label %$22, label %$23
$22:
  %142 = phi i64 [%132, %$21] ; # X
  %143 = phi i64 [%133, %$21] ; # R
  %144 = phi i64 [%134, %$21] ; # L
; # (loop (let Y (cons (cons (evList E) (caar A)) $Nil) (setq L (if L...
  br label %$24
$24:
  %145 = phi i64 [%142, %$22], [%245, %$32] ; # X
  %146 = phi i64 [%143, %$22], [%246, %$32] ; # R
  %147 = phi i64 [%144, %$22], [%247, %$32] ; # L
; # (let Y (cons (cons (evList E) (caar A)) $Nil) (setq L (if L (set ...
; # (evList E)
  %148 = call i64 @evList(i64 %25)
; # (caar A)
  %149 = inttoptr i64 %33 to i64*
  %150 = load i64, i64* %149
  %151 = inttoptr i64 %150 to i64*
  %152 = load i64, i64* %151
; # (cons (evList E) (caar A))
  %153 = call i64 @cons(i64 %148, i64 %152)
; # (cons (cons (evList E) (caar A)) $Nil)
  %154 = call i64 @cons(i64 %153, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (if L (set 2 L Y) (setq R (safe Y)))
  %155 = icmp ne i64 %147, 0
  br i1 %155, label %$25, label %$26
$25:
  %156 = phi i64 [%145, %$24] ; # X
  %157 = phi i64 [%146, %$24] ; # R
  %158 = phi i64 [%147, %$24] ; # L
; # (set 2 L Y)
  %159 = inttoptr i64 %158 to i64*
  %160 = getelementptr i64, i64* %159, i32 1
  store i64 %154, i64* %160
  br label %$27
$26:
  %161 = phi i64 [%145, %$24] ; # X
  %162 = phi i64 [%146, %$24] ; # R
  %163 = phi i64 [%147, %$24] ; # L
; # (safe Y)
  %164 = inttoptr i64 %7 to i64*
  store i64 %154, i64* %164
  br label %$27
$27:
  %165 = phi i64 [%156, %$25], [%161, %$26] ; # X
  %166 = phi i64 [%157, %$25], [%154, %$26] ; # R
  %167 = phi i64 [%158, %$25], [%163, %$26] ; # L
  %168 = phi i64 [%154, %$25], [%154, %$26] ; # ->
; # (? (atom (set A (cdar A))))
; # (set A (cdar A))
; # (cdar A)
  %169 = inttoptr i64 %33 to i64*
  %170 = load i64, i64* %169
  %171 = inttoptr i64 %170 to i64*
  %172 = getelementptr i64, i64* %171, i32 1
  %173 = load i64, i64* %172
  %174 = inttoptr i64 %33 to i64*
  store i64 %173, i64* %174
; # (atom (set A (cdar A)))
  %175 = and i64 %173, 15
  %176 = icmp ne i64 %175, 0
  br i1 %176, label %$29, label %$28
$28:
  %177 = phi i64 [%165, %$27] ; # X
  %178 = phi i64 [%166, %$27] ; # R
  %179 = phi i64 [%168, %$27] ; # L
; # (let (P (cdr E) Q A) (set 4 P (car @)) (while (pair (shift P)) (s...
; # (cdr E)
  %180 = inttoptr i64 %25 to i64*
  %181 = getelementptr i64, i64* %180, i32 1
  %182 = load i64, i64* %181
; # (set 4 P (car @))
; # (car @)
  %183 = inttoptr i64 %173 to i64*
  %184 = load i64, i64* %183
  %185 = inttoptr i64 %182 to i64*
  %186 = getelementptr i64, i64* %185, i32 3
  store i64 %184, i64* %186
; # (while (pair (shift P)) (set 4 P (cond ((atom (car (shift Q))) @)...
  br label %$30
$30:
  %187 = phi i64 [%177, %$28], [%237, %$33] ; # X
  %188 = phi i64 [%178, %$28], [%238, %$33] ; # R
  %189 = phi i64 [%179, %$28], [%239, %$33] ; # L
  %190 = phi i64 [%182, %$28], [%240, %$33] ; # P
  %191 = phi i64 [%33, %$28], [%241, %$33] ; # Q
; # (shift P)
  %192 = inttoptr i64 %190 to i64*
  %193 = getelementptr i64, i64* %192, i32 1
  %194 = load i64, i64* %193
; # (pair (shift P))
  %195 = and i64 %194, 15
  %196 = icmp eq i64 %195, 0
  br i1 %196, label %$31, label %$32
$31:
  %197 = phi i64 [%187, %$30] ; # X
  %198 = phi i64 [%188, %$30] ; # R
  %199 = phi i64 [%189, %$30] ; # L
  %200 = phi i64 [%194, %$30] ; # P
  %201 = phi i64 [%191, %$30] ; # Q
; # (set 4 P (cond ((atom (car (shift Q))) @) ((atom (set Q (cdr @)))...
; # (cond ((atom (car (shift Q))) @) ((atom (set Q (cdr @))) @) (T (c...
; # (shift Q)
  %202 = inttoptr i64 %201 to i64*
  %203 = getelementptr i64, i64* %202, i32 1
  %204 = load i64, i64* %203
; # (car (shift Q))
  %205 = inttoptr i64 %204 to i64*
  %206 = load i64, i64* %205
; # (atom (car (shift Q)))
  %207 = and i64 %206, 15
  %208 = icmp ne i64 %207, 0
  br i1 %208, label %$35, label %$34
$35:
  %209 = phi i64 [%197, %$31] ; # X
  %210 = phi i64 [%198, %$31] ; # R
  %211 = phi i64 [%199, %$31] ; # L
  %212 = phi i64 [%200, %$31] ; # P
  %213 = phi i64 [%204, %$31] ; # Q
  br label %$33
$34:
  %214 = phi i64 [%197, %$31] ; # X
  %215 = phi i64 [%198, %$31] ; # R
  %216 = phi i64 [%199, %$31] ; # L
  %217 = phi i64 [%200, %$31] ; # P
  %218 = phi i64 [%204, %$31] ; # Q
; # (set Q (cdr @))
; # (cdr @)
  %219 = inttoptr i64 %206 to i64*
  %220 = getelementptr i64, i64* %219, i32 1
  %221 = load i64, i64* %220
  %222 = inttoptr i64 %218 to i64*
  store i64 %221, i64* %222
; # (atom (set Q (cdr @)))
  %223 = and i64 %221, 15
  %224 = icmp ne i64 %223, 0
  br i1 %224, label %$37, label %$36
$37:
  %225 = phi i64 [%214, %$34] ; # X
  %226 = phi i64 [%215, %$34] ; # R
  %227 = phi i64 [%216, %$34] ; # L
  %228 = phi i64 [%217, %$34] ; # P
  %229 = phi i64 [%218, %$34] ; # Q
  br label %$33
$36:
  %230 = phi i64 [%214, %$34] ; # X
  %231 = phi i64 [%215, %$34] ; # R
  %232 = phi i64 [%216, %$34] ; # L
  %233 = phi i64 [%217, %$34] ; # P
  %234 = phi i64 [%218, %$34] ; # Q
; # (car @)
  %235 = inttoptr i64 %221 to i64*
  %236 = load i64, i64* %235
  br label %$33
$33:
  %237 = phi i64 [%209, %$35], [%225, %$37], [%230, %$36] ; # X
  %238 = phi i64 [%210, %$35], [%226, %$37], [%231, %$36] ; # R
  %239 = phi i64 [%211, %$35], [%227, %$37], [%232, %$36] ; # L
  %240 = phi i64 [%212, %$35], [%228, %$37], [%233, %$36] ; # P
  %241 = phi i64 [%213, %$35], [%229, %$37], [%234, %$36] ; # Q
  %242 = phi i64 [%206, %$35], [%221, %$37], [%236, %$36] ; # ->
  %243 = inttoptr i64 %200 to i64*
  %244 = getelementptr i64, i64* %243, i32 3
  store i64 %242, i64* %244
  br label %$30
$32:
  %245 = phi i64 [%187, %$30] ; # X
  %246 = phi i64 [%188, %$30] ; # R
  %247 = phi i64 [%189, %$30] ; # L
  %248 = phi i64 [%194, %$30] ; # P
  %249 = phi i64 [%191, %$30] ; # Q
  br label %$24
$29:
  %250 = phi i64 [%165, %$27] ; # X
  %251 = phi i64 [%166, %$27] ; # R
  %252 = phi i64 [%168, %$27] ; # L
  %253 = phi i64 [0, %$27] ; # ->
; # (set 4 E Fun2 4 (cdr E) R)
  %254 = inttoptr i64 %25 to i64*
  %255 = getelementptr i64, i64* %254, i32 3
  store i64 %45, i64* %255
; # (cdr E)
  %256 = inttoptr i64 %25 to i64*
  %257 = getelementptr i64, i64* %256, i32 1
  %258 = load i64, i64* %257
  %259 = inttoptr i64 %258 to i64*
  %260 = getelementptr i64, i64* %259, i32 3
  store i64 %251, i64* %260
; # (let Z (setq R (safe (evList E))) (loop (set Z (cdar Z)) (? (atom...
; # (evList E)
  %261 = call i64 @evList(i64 %25)
; # (safe (evList E))
  %262 = inttoptr i64 %7 to i64*
  store i64 %261, i64* %262
; # (loop (set Z (cdar Z)) (? (atom (shift Z))))
  br label %$38
$38:
  %263 = phi i64 [%250, %$29], [%278, %$39] ; # X
  %264 = phi i64 [%261, %$29], [%279, %$39] ; # R
  %265 = phi i64 [%252, %$29], [%280, %$39] ; # L
  %266 = phi i64 [%261, %$29], [%281, %$39] ; # Z
; # (set Z (cdar Z))
; # (cdar Z)
  %267 = inttoptr i64 %266 to i64*
  %268 = load i64, i64* %267
  %269 = inttoptr i64 %268 to i64*
  %270 = getelementptr i64, i64* %269, i32 1
  %271 = load i64, i64* %270
  %272 = inttoptr i64 %266 to i64*
  store i64 %271, i64* %272
; # (? (atom (shift Z)))
; # (shift Z)
  %273 = inttoptr i64 %266 to i64*
  %274 = getelementptr i64, i64* %273, i32 1
  %275 = load i64, i64* %274
; # (atom (shift Z))
  %276 = and i64 %275, 15
  %277 = icmp ne i64 %276, 0
  br i1 %277, label %$40, label %$39
$39:
  %278 = phi i64 [%263, %$38] ; # X
  %279 = phi i64 [%264, %$38] ; # R
  %280 = phi i64 [%265, %$38] ; # L
  %281 = phi i64 [%275, %$38] ; # Z
  br label %$38
$40:
  %282 = phi i64 [%263, %$38] ; # X
  %283 = phi i64 [%264, %$38] ; # R
  %284 = phi i64 [%265, %$38] ; # L
  %285 = phi i64 [%275, %$38] ; # Z
  %286 = phi i64 [0, %$38] ; # ->
  br label %$23
$23:
  %287 = phi i64 [%132, %$21], [%282, %$40] ; # X
  %288 = phi i64 [%133, %$21], [%283, %$40] ; # R
  %289 = phi i64 [%134, %$21], [%284, %$40] ; # L
; # (drop *Safe)
  %290 = inttoptr i64 %7 to i64*
  %291 = getelementptr i64, i64* %290, i32 1
  %292 = load i64, i64* %291
  %293 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %292, i64* %293
  ret i64 %288
}

define i8* @tabComplete(i8*) align 8 {
$1:
; # (if (nil? (val $Complete)) null (let (V (push NIL $Nil ZERO NIL N...
; # (val $Complete)
  %1 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 840) to i64) to i64*
  %2 = load i64, i64* %1
; # (nil? (val $Complete))
  %3 = icmp eq i64 %2, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %3, label %$2, label %$3
$2:
  br label %$4
$3:
; # (let (V (push NIL $Nil ZERO NIL NIL) E (push NIL V ZERO @ NIL)) (...
; # (push NIL $Nil ZERO NIL NIL)
  %4 = alloca i64, i64 5, align 16
  %5 = ptrtoint i64* %4 to i64
  %6 = add i64 %5, 8
  %7 = inttoptr i64 %6 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %7
  %8 = add i64 %5, 16
  %9 = inttoptr i64 %8 to i64*
  store i64 2, i64* %9
; # (push NIL V ZERO @ NIL)
  %10 = alloca i64, i64 5, align 16
  %11 = ptrtoint i64* %10 to i64
  %12 = add i64 %11, 8
  %13 = inttoptr i64 %12 to i64*
  store i64 %5, i64* %13
  %14 = add i64 %11, 16
  %15 = inttoptr i64 %14 to i64*
  store i64 2, i64* %15
  %16 = add i64 %11, 24
  %17 = inttoptr i64 %16 to i64*
  store i64 %2, i64* %17
; # (set 4 V (nond (Text $Nil) ((val Text) $T) (NIL (mkStr Text))))
; # (nond (Text $Nil) ((val Text) $T) (NIL (mkStr Text)))
  %18 = icmp ne i8* %0, null
  br i1 %18, label %$6, label %$7
$7:
  br label %$5
$6:
; # (val Text)
  %19 = load i8, i8* %0
  %20 = icmp ne i8 %19, 0
  br i1 %20, label %$8, label %$9
$9:
  br label %$5
$8:
; # (mkStr Text)
  %21 = call i64 @mkStr(i8* %0)
  br label %$5
$5:
  %22 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$9], [%21, %$8] ; # ->
  %23 = inttoptr i64 %5 to i64*
  %24 = getelementptr i64, i64* %23, i32 3
  store i64 %22, i64* %24
; # (set V (link (ofs V 3) T) E (link (ofs E 3)))
; # (ofs V 3)
  %25 = add i64 %5, 24
; # (link (ofs V 3) T)
  %26 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %27 = load i64, i64* %26
  %28 = inttoptr i64 %25 to i64*
  %29 = getelementptr i64, i64* %28, i32 1
  store i64 %27, i64* %29
  %30 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %25, i64* %30
  %31 = inttoptr i64 %5 to i64*
  store i64 %25, i64* %31
; # (ofs E 3)
  %32 = add i64 %11, 24
; # (link (ofs E 3))
  %33 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %34 = load i64, i64* %33
  %35 = inttoptr i64 %32 to i64*
  %36 = getelementptr i64, i64* %35, i32 1
  store i64 %34, i64* %36
  %37 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %32, i64* %37
  %38 = inttoptr i64 %11 to i64*
  store i64 %32, i64* %38
; # (if (nil? (evList E)) null (let Nm (name (val (tail (xSym @)))) (...
; # (evList E)
  %39 = call i64 @evList(i64 %11)
; # (nil? (evList E))
  %40 = icmp eq i64 %39, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %40, label %$10, label %$11
$10:
  br label %$12
$11:
; # (let Nm (name (val (tail (xSym @)))) (strdup (bufString Nm (b8 (b...
; # (xSym @)
  %41 = call i64 @xSym(i64 %39)
; # (tail (xSym @))
  %42 = add i64 %41, -8
; # (val (tail (xSym @)))
  %43 = inttoptr i64 %42 to i64*
  %44 = load i64, i64* %43
; # (name (val (tail (xSym @))))
  br label %$13
$13:
  %45 = phi i64 [%44, %$11], [%51, %$14] ; # Tail
  %46 = and i64 %45, 6
  %47 = icmp ne i64 %46, 0
  br i1 %47, label %$15, label %$14
$14:
  %48 = phi i64 [%45, %$13] ; # Tail
  %49 = inttoptr i64 %48 to i64*
  %50 = getelementptr i64, i64* %49, i32 1
  %51 = load i64, i64* %50
  br label %$13
$15:
  %52 = phi i64 [%45, %$13] ; # Tail
; # (bufSize Nm)
  %53 = call i64 @bufSize(i64 %52)
; # (b8 (bufSize Nm))
  %54 = alloca i8, i64 %53
; # (bufString Nm (b8 (bufSize Nm)))
  %55 = call i8* @bufString(i64 %52, i8* %54)
; # (strdup (bufString Nm (b8 (bufSize Nm))))
  %56 = call i8* @strdup(i8* %55)
  br label %$12
$12:
  %57 = phi i8* [null, %$10], [%56, %$15] ; # ->
; # (drop *Safe)
  %58 = inttoptr i64 %25 to i64*
  %59 = getelementptr i64, i64* %58, i32 1
  %60 = load i64, i64* %59
  %61 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %60, i64* %61
  br label %$4
$4:
  %62 = phi i8* [null, %$2], [%57, %$12] ; # ->
  ret i8* %62
}

define void @redefMsg(i64, i64) align 8 {
$1:
; # (let (Out (val $OutFile) Put (val (i8** $Put))) (set $OutFile (va...
; # (val $OutFile)
  %2 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 80) to i8**)
; # (i8** $Put)
  %3 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**) to i8**
; # (val (i8** $Put))
  %4 = load i8*, i8** %3
; # (set $OutFile (val 3 (val $OutFiles)) $Put (fun (void i8) _putStd...
; # (val $OutFiles)
  %5 = load i8**, i8*** @$OutFiles
; # (val 3 (val $OutFiles))
  %6 = getelementptr i8*, i8** %5, i32 2
  %7 = load i8*, i8** %6
  store i8* %7, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 80) to i8**)
; # (fun (void i8) _putStdout)
  store void(i8)* @_putStdout, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
; # (outString ($ "# "))
  call void @outString(i8* bitcast ([3 x i8]* @$71 to i8*))
; # (print Sym)
  call void @print(i64 %0)
; # (when Sym2 (space) (print @))
  %8 = icmp ne i64 %1, 0
  br i1 %8, label %$2, label %$3
$2:
; # (space)
  call void @space()
; # (print @)
  call void @print(i64 %1)
  br label %$3
$3:
; # (outString ($ " redefined^J"))
  call void @outString(i8* bitcast ([12 x i8]* @$72 to i8*))
; # (set (i8** $Put) Put $OutFile Out)
; # (i8** $Put)
  %9 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**) to i8**
  store i8* %4, i8** %9
  store i8* %2, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 80) to i8**)
  ret void
}

define void @putSrc(i64, i64) align 8 {
$1:
; # (unless (or (nil? (val $Dbg)) (sym? (val (tail Sym)))) (let In: (...
; # (or (nil? (val $Dbg)) (sym? (val (tail Sym))))
; # (val $Dbg)
  %2 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 824) to i64) to i64*
  %3 = load i64, i64* %2
; # (nil? (val $Dbg))
  %4 = icmp eq i64 %3, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %4, label %$2, label %$3
$3:
; # (tail Sym)
  %5 = add i64 %0, -8
; # (val (tail Sym))
  %6 = inttoptr i64 %5 to i64*
  %7 = load i64, i64* %6
; # (sym? (val (tail Sym)))
  %8 = and i64 %7, 8
  %9 = icmp ne i64 %8, 0
  br label %$2
$2:
  %10 = phi i1 [1, %$1], [%9, %$3] ; # ->
  br i1 %10, label %$5, label %$4
$4:
; # (let In: (inFile (val $InFile)) (when (and (In:) (In: name)) (let...
; # (val $InFile)
  %11 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 72) to i8**)
; # (when (and (In:) (In: name)) (let (Dbg (get Sym $Dbg) Src (cons (...
; # (and (In:) (In: name))
; # (In:)
  %12 = icmp ne i8* %11, null
  br i1 %12, label %$7, label %$6
$7:
; # (In: name)
  %13 = bitcast i8* %11 to i8**
  %14 = load i8*, i8** %13
  %15 = icmp ne i8* %14, null
  br label %$6
$6:
  %16 = phi i1 [0, %$4], [%15, %$7] ; # ->
  br i1 %16, label %$8, label %$9
$8:
; # (let (Dbg (get Sym $Dbg) Src (cons (cnt (i64 (In: src))) (cons (m...
; # (get Sym $Dbg)
  %17 = call i64 @get(i64 %0, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 824) to i64))
; # (In: src)
  %18 = getelementptr i8, i8* %11, i32 20
  %19 = bitcast i8* %18 to i32*
  %20 = load i32, i32* %19
; # (i64 (In: src))
  %21 = sext i32 %20 to i64
; # (cnt (i64 (In: src)))
  %22 = shl i64 %21, 4
  %23 = or i64 %22, 2
; # (In: name)
  %24 = bitcast i8* %11 to i8**
  %25 = load i8*, i8** %24
; # (mkStr (In: name))
  %26 = call i64 @mkStr(i8* %25)
; # (val $Intern)
  %27 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 0) to i64) to i64*
  %28 = load i64, i64* %27
; # (cons (mkStr (In: name)) (val $Intern))
  %29 = call i64 @cons(i64 %26, i64 %28)
; # (cons (cnt (i64 (In: src))) (cons (mkStr (In: name)) (val $Intern...
  %30 = call i64 @cons(i64 %23, i64 %29)
; # (cond ((=0 Key) (if (nil? Dbg) (put Sym $Dbg (cons Src $Nil)) (se...
; # (=0 Key)
  %31 = icmp eq i64 %1, 0
  br i1 %31, label %$12, label %$11
$12:
; # (if (nil? Dbg) (put Sym $Dbg (cons Src $Nil)) (set Dbg Src))
; # (nil? Dbg)
  %32 = icmp eq i64 %17, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %32, label %$13, label %$14
$13:
; # (cons Src $Nil)
  %33 = call i64 @cons(i64 %30, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (put Sym $Dbg (cons Src $Nil))
  call void @put(i64 %0, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 824) to i64), i64 %33)
  br label %$15
$14:
; # (set Dbg Src)
  %34 = inttoptr i64 %17 to i64*
  store i64 %30, i64* %34
  br label %$15
$15:
  br label %$10
$11:
; # (nil? Dbg)
  %35 = icmp eq i64 %17, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %35, label %$17, label %$16
$17:
; # (cons Key Src)
  %36 = call i64 @cons(i64 %1, i64 %30)
; # (cons (cons Key Src) $Nil)
  %37 = call i64 @cons(i64 %36, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (cons $Nil (cons (cons Key Src) $Nil))
  %38 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64 %37)
; # (put Sym $Dbg (cons $Nil (cons (cons Key Src) $Nil)))
  call void @put(i64 %0, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 824) to i64), i64 %38)
  br label %$10
$16:
; # (let X Dbg (loop (? (atom (shift X)) (set 2 Dbg (cons (cons Key S...
; # (loop (? (atom (shift X)) (set 2 Dbg (cons (cons Key Src) (cdr Db...
  br label %$18
$18:
  %39 = phi i64 [%17, %$16], [%64, %$22] ; # X
; # (? (atom (shift X)) (set 2 Dbg (cons (cons Key Src) (cdr Dbg))))
; # (shift X)
  %40 = inttoptr i64 %39 to i64*
  %41 = getelementptr i64, i64* %40, i32 1
  %42 = load i64, i64* %41
; # (atom (shift X))
  %43 = and i64 %42, 15
  %44 = icmp ne i64 %43, 0
  br i1 %44, label %$21, label %$19
$21:
  %45 = phi i64 [%42, %$18] ; # X
; # (set 2 Dbg (cons (cons Key Src) (cdr Dbg)))
; # (cons Key Src)
  %46 = call i64 @cons(i64 %1, i64 %30)
; # (cdr Dbg)
  %47 = inttoptr i64 %17 to i64*
  %48 = getelementptr i64, i64* %47, i32 1
  %49 = load i64, i64* %48
; # (cons (cons Key Src) (cdr Dbg))
  %50 = call i64 @cons(i64 %46, i64 %49)
  %51 = inttoptr i64 %17 to i64*
  %52 = getelementptr i64, i64* %51, i32 1
  store i64 %50, i64* %52
  br label %$20
$19:
  %53 = phi i64 [%42, %$18] ; # X
; # (? (== (caar X) Key) (set 2 (car X) Src))
; # (caar X)
  %54 = inttoptr i64 %53 to i64*
  %55 = load i64, i64* %54
  %56 = inttoptr i64 %55 to i64*
  %57 = load i64, i64* %56
; # (== (caar X) Key)
  %58 = icmp eq i64 %57, %1
  br i1 %58, label %$23, label %$22
$23:
  %59 = phi i64 [%53, %$19] ; # X
; # (set 2 (car X) Src)
; # (car X)
  %60 = inttoptr i64 %59 to i64*
  %61 = load i64, i64* %60
  %62 = inttoptr i64 %61 to i64*
  %63 = getelementptr i64, i64* %62, i32 1
  store i64 %30, i64* %63
  br label %$20
$22:
  %64 = phi i64 [%53, %$19] ; # X
  br label %$18
$20:
  %65 = phi i64 [%45, %$21], [%59, %$23] ; # X
  %66 = phi i64 [%50, %$21], [%30, %$23] ; # ->
  br label %$10
$10:
  br label %$9
$9:
  br label %$5
$5:
  ret void
}

define void @redefine(i64, i64, i64) align 8 {
$1:
; # (needChkVar Exe Sym)
  %3 = and i64 %1, 6
  %4 = icmp ne i64 %3, 0
  br i1 %4, label %$2, label %$3
$2:
  call void @varErr(i64 %0, i64 %1)
  unreachable
$3:
  %5 = icmp uge i64 %1, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %5, label %$5, label %$4
$5:
  %6 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %1
  br label %$4
$4:
  %7 = phi i1 [0, %$3], [%6, %$5] ; # ->
  br i1 %7, label %$6, label %$7
$6:
  call void @protErr(i64 %0, i64 %1)
  unreachable
$7:
; # (let V (val Sym) (unless (or (nil? V) (== V Sym) (equal V Val)) (...
; # (val Sym)
  %8 = inttoptr i64 %1 to i64*
  %9 = load i64, i64* %8
; # (unless (or (nil? V) (== V Sym) (equal V Val)) (redefMsg Sym 0))
; # (or (nil? V) (== V Sym) (equal V Val))
; # (nil? V)
  %10 = icmp eq i64 %9, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %10, label %$8, label %$9
$9:
; # (== V Sym)
  %11 = icmp eq i64 %9, %1
  br i1 %11, label %$8, label %$10
$10:
; # (equal V Val)
  %12 = call i1 @equal(i64 %9, i64 %2)
  br label %$8
$8:
  %13 = phi i1 [1, %$7], [1, %$9], [%12, %$10] ; # ->
  br i1 %13, label %$12, label %$11
$11:
; # (redefMsg Sym 0)
  call void @redefMsg(i64 %1, i64 0)
  br label %$12
$12:
; # (set Sym Val)
  %14 = inttoptr i64 %1 to i64*
  store i64 %2, i64* %14
; # (putSrc Sym 0)
  call void @putSrc(i64 %1, i64 0)
  ret void
}

define i64 @_Quote(i64) align 8 {
$1:
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  ret i64 %3
}

define i64 @_As(i64) align 8 {
$1:
; # (let X (cdr Exe) (if (nil? (eval (car X))) @ (cdr X)))
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (if (nil? (eval (car X))) @ (cdr X))
; # (car X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (car X))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (nil? (eval (car X)))
  %14 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %14, label %$7, label %$8
$7:
  br label %$9
$8:
; # (cdr X)
  %15 = inttoptr i64 %3 to i64*
  %16 = getelementptr i64, i64* %15, i32 1
  %17 = load i64, i64* %16
  br label %$9
$9:
  %18 = phi i64 [%13, %$7], [%17, %$8] ; # ->
  ret i64 %18
}

define i64 @_Lit(i64) align 8 {
$1:
; # (let X (eval (cadr Exe)) (if (or (num? X) (nil? X) (t? X) (and (p...
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (if (or (num? X) (nil? X) (t? X) (and (pair X) (num? (car X)))) X...
; # (or (num? X) (nil? X) (t? X) (and (pair X) (num? (car X))))
; # (num? X)
  %14 = and i64 %13, 6
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$7, label %$8
$8:
; # (nil? X)
  %16 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %16, label %$7, label %$9
$9:
; # (t? X)
  %17 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %17, label %$7, label %$10
$10:
; # (and (pair X) (num? (car X)))
; # (pair X)
  %18 = and i64 %13, 15
  %19 = icmp eq i64 %18, 0
  br i1 %19, label %$12, label %$11
$12:
; # (car X)
  %20 = inttoptr i64 %13 to i64*
  %21 = load i64, i64* %20
; # (num? (car X))
  %22 = and i64 %21, 6
  %23 = icmp ne i64 %22, 0
  br label %$11
$11:
  %24 = phi i1 [0, %$10], [%23, %$12] ; # ->
  br label %$7
$7:
  %25 = phi i1 [1, %$2], [1, %$8], [1, %$9], [%24, %$11] ; # ->
  br i1 %25, label %$13, label %$14
$13:
  br label %$15
$14:
; # (cons $Quote X)
  %26 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 264) to i64), i64 %13)
  br label %$15
$15:
  %27 = phi i64 [%13, %$13], [%26, %$14] ; # ->
  ret i64 %27
}

define i64 @_Eval(i64) align 8 {
$1:
; # (let (X (cdr Exe) E (save (eval (car X)))) (when (pair (cdr X)) (...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (car X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (car X))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (save (eval (car X)))
  %14 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %15 = load i64, i64* %14
  %16 = alloca i64, i64 2, align 16
  %17 = ptrtoint i64* %16 to i64
  %18 = inttoptr i64 %17 to i64*
  store i64 %13, i64* %18
  %19 = add i64 %17, 8
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %17, i64* %21
; # (when (pair (cdr X)) (let N (needCnt Exe (eval (car @))) (when (s...
; # (cdr X)
  %22 = inttoptr i64 %3 to i64*
  %23 = getelementptr i64, i64* %22, i32 1
  %24 = load i64, i64* %23
; # (pair (cdr X))
  %25 = and i64 %24, 15
  %26 = icmp eq i64 %25, 0
  br i1 %26, label %$7, label %$8
$7:
; # (let N (needCnt Exe (eval (car @))) (when (setq N (int N)) (let B...
; # (car @)
  %27 = inttoptr i64 %24 to i64*
  %28 = load i64, i64* %27
; # (eval (car @))
  %29 = and i64 %28, 6
  %30 = icmp ne i64 %29, 0
  br i1 %30, label %$11, label %$10
$11:
  br label %$9
$10:
  %31 = and i64 %28, 8
  %32 = icmp ne i64 %31, 0
  br i1 %32, label %$13, label %$12
$13:
  %33 = inttoptr i64 %28 to i64*
  %34 = load i64, i64* %33
  br label %$9
$12:
  %35 = call i64 @evList(i64 %28)
  br label %$9
$9:
  %36 = phi i64 [%28, %$11], [%34, %$13], [%35, %$12] ; # ->
; # (needCnt Exe (eval (car @)))
  %37 = and i64 %36, 2
  %38 = icmp ne i64 %37, 0
  br i1 %38, label %$15, label %$14
$14:
  call void @cntErr(i64 %0, i64 %36)
  unreachable
$15:
; # (when (setq N (int N)) (let Bnd (val $Bind) (loop (? (=0 Bnd)) (?...
; # (int N)
  %39 = lshr i64 %36, 4
  %40 = icmp ne i64 %39, 0
  br i1 %40, label %$16, label %$17
$16:
  %41 = phi i64 [%39, %$15] ; # N
; # (let Bnd (val $Bind) (loop (? (=0 Bnd)) (? (and (== $At (val 2 Bn...
; # (val $Bind)
  %42 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  %43 = load i64, i64* %42
; # (loop (? (=0 Bnd)) (? (and (== $At (val 2 Bnd)) (prog (set $At (v...
  br label %$18
$18:
  %44 = phi i64 [%41, %$16], [%63, %$23] ; # N
  %45 = phi i64 [%43, %$16], [%67, %$23] ; # Bnd
; # (? (=0 Bnd))
; # (=0 Bnd)
  %46 = icmp eq i64 %45, 0
  br i1 %46, label %$20, label %$19
$19:
  %47 = phi i64 [%44, %$18] ; # N
  %48 = phi i64 [%45, %$18] ; # Bnd
; # (? (and (== $At (val 2 Bnd)) (prog (set $At (val Bnd)) (=0 (dec '...
; # (and (== $At (val 2 Bnd)) (prog (set $At (val Bnd)) (=0 (dec 'N))...
; # (val 2 Bnd)
  %49 = inttoptr i64 %48 to i64*
  %50 = getelementptr i64, i64* %49, i32 1
  %51 = load i64, i64* %50
; # (== $At (val 2 Bnd))
  %52 = icmp eq i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64), %51
  br i1 %52, label %$22, label %$21
$22:
  %53 = phi i64 [%47, %$19] ; # N
  %54 = phi i64 [%48, %$19] ; # Bnd
; # (set $At (val Bnd))
; # (val Bnd)
  %55 = inttoptr i64 %54 to i64*
  %56 = load i64, i64* %55
  %57 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  store i64 %56, i64* %57
; # (dec 'N)
  %58 = sub i64 %53, 1
; # (=0 (dec 'N))
  %59 = icmp eq i64 %58, 0
  br label %$21
$21:
  %60 = phi i64 [%47, %$19], [%58, %$22] ; # N
  %61 = phi i64 [%48, %$19], [%54, %$22] ; # Bnd
  %62 = phi i1 [0, %$19], [%59, %$22] ; # ->
  br i1 %62, label %$20, label %$23
$23:
  %63 = phi i64 [%60, %$21] ; # N
  %64 = phi i64 [%61, %$21] ; # Bnd
; # (val 3 Bnd)
  %65 = inttoptr i64 %64 to i64*
  %66 = getelementptr i64, i64* %65, i32 2
  %67 = load i64, i64* %66
  br label %$18
$20:
  %68 = phi i64 [%44, %$18], [%60, %$21] ; # N
  %69 = phi i64 [%45, %$18], [%61, %$21] ; # Bnd
  %70 = phi i64 [0, %$18], [0, %$21] ; # ->
  br label %$17
$17:
  %71 = phi i64 [%39, %$15], [%68, %$20] ; # N
  br label %$8
$8:
; # (eval E)
  %72 = and i64 %13, 6
  %73 = icmp ne i64 %72, 0
  br i1 %73, label %$26, label %$25
$26:
  br label %$24
$25:
  %74 = and i64 %13, 8
  %75 = icmp ne i64 %74, 0
  br i1 %75, label %$28, label %$27
$28:
  %76 = inttoptr i64 %13 to i64*
  %77 = load i64, i64* %76
  br label %$24
$27:
  %78 = call i64 @evList(i64 %13)
  br label %$24
$24:
  %79 = phi i64 [%13, %$26], [%77, %$28], [%78, %$27] ; # ->
; # (drop *Safe)
  %80 = inttoptr i64 %17 to i64*
  %81 = getelementptr i64, i64* %80, i32 1
  %82 = load i64, i64* %81
  %83 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %82, i64* %83
  ret i64 %79
}

define i64 @_Run(i64) align 8 {
$1:
; # (let (X (cdr Exe) E (eval (car X))) (cond ((num? E) E) ((sym? E) ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (car X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (car X))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (cond ((num? E) E) ((sym? E) (val E)) (T (save E (when (pair (cdr...
; # (num? E)
  %14 = and i64 %13, 6
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$9, label %$8
$9:
  br label %$7
$8:
; # (sym? E)
  %16 = and i64 %13, 8
  %17 = icmp ne i64 %16, 0
  br i1 %17, label %$11, label %$10
$11:
; # (val E)
  %18 = inttoptr i64 %13 to i64*
  %19 = load i64, i64* %18
  br label %$7
$10:
; # (save E (when (pair (cdr X)) (let N (needCnt Exe (eval (car @))) ...
  %20 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %21 = load i64, i64* %20
  %22 = alloca i64, i64 2, align 16
  %23 = ptrtoint i64* %22 to i64
  %24 = inttoptr i64 %23 to i64*
  store i64 %13, i64* %24
  %25 = add i64 %23, 8
  %26 = inttoptr i64 %25 to i64*
  store i64 %21, i64* %26
  %27 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %23, i64* %27
; # (when (pair (cdr X)) (let N (needCnt Exe (eval (car @))) (when (s...
; # (cdr X)
  %28 = inttoptr i64 %3 to i64*
  %29 = getelementptr i64, i64* %28, i32 1
  %30 = load i64, i64* %29
; # (pair (cdr X))
  %31 = and i64 %30, 15
  %32 = icmp eq i64 %31, 0
  br i1 %32, label %$12, label %$13
$12:
; # (let N (needCnt Exe (eval (car @))) (when (setq N (int N)) (let B...
; # (car @)
  %33 = inttoptr i64 %30 to i64*
  %34 = load i64, i64* %33
; # (eval (car @))
  %35 = and i64 %34, 6
  %36 = icmp ne i64 %35, 0
  br i1 %36, label %$16, label %$15
$16:
  br label %$14
$15:
  %37 = and i64 %34, 8
  %38 = icmp ne i64 %37, 0
  br i1 %38, label %$18, label %$17
$18:
  %39 = inttoptr i64 %34 to i64*
  %40 = load i64, i64* %39
  br label %$14
$17:
  %41 = call i64 @evList(i64 %34)
  br label %$14
$14:
  %42 = phi i64 [%34, %$16], [%40, %$18], [%41, %$17] ; # ->
; # (needCnt Exe (eval (car @)))
  %43 = and i64 %42, 2
  %44 = icmp ne i64 %43, 0
  br i1 %44, label %$20, label %$19
$19:
  call void @cntErr(i64 %0, i64 %42)
  unreachable
$20:
; # (when (setq N (int N)) (let Bnd (val $Bind) (loop (? (=0 Bnd)) (?...
; # (int N)
  %45 = lshr i64 %42, 4
  %46 = icmp ne i64 %45, 0
  br i1 %46, label %$21, label %$22
$21:
  %47 = phi i64 [%45, %$20] ; # N
; # (let Bnd (val $Bind) (loop (? (=0 Bnd)) (? (and (== $At (val 2 Bn...
; # (val $Bind)
  %48 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  %49 = load i64, i64* %48
; # (loop (? (=0 Bnd)) (? (and (== $At (val 2 Bnd)) (prog (set $At (v...
  br label %$23
$23:
  %50 = phi i64 [%47, %$21], [%69, %$28] ; # N
  %51 = phi i64 [%49, %$21], [%73, %$28] ; # Bnd
; # (? (=0 Bnd))
; # (=0 Bnd)
  %52 = icmp eq i64 %51, 0
  br i1 %52, label %$25, label %$24
$24:
  %53 = phi i64 [%50, %$23] ; # N
  %54 = phi i64 [%51, %$23] ; # Bnd
; # (? (and (== $At (val 2 Bnd)) (prog (set $At (val Bnd)) (=0 (dec '...
; # (and (== $At (val 2 Bnd)) (prog (set $At (val Bnd)) (=0 (dec 'N))...
; # (val 2 Bnd)
  %55 = inttoptr i64 %54 to i64*
  %56 = getelementptr i64, i64* %55, i32 1
  %57 = load i64, i64* %56
; # (== $At (val 2 Bnd))
  %58 = icmp eq i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64), %57
  br i1 %58, label %$27, label %$26
$27:
  %59 = phi i64 [%53, %$24] ; # N
  %60 = phi i64 [%54, %$24] ; # Bnd
; # (set $At (val Bnd))
; # (val Bnd)
  %61 = inttoptr i64 %60 to i64*
  %62 = load i64, i64* %61
  %63 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  store i64 %62, i64* %63
; # (dec 'N)
  %64 = sub i64 %59, 1
; # (=0 (dec 'N))
  %65 = icmp eq i64 %64, 0
  br label %$26
$26:
  %66 = phi i64 [%53, %$24], [%64, %$27] ; # N
  %67 = phi i64 [%54, %$24], [%60, %$27] ; # Bnd
  %68 = phi i1 [0, %$24], [%65, %$27] ; # ->
  br i1 %68, label %$25, label %$28
$28:
  %69 = phi i64 [%66, %$26] ; # N
  %70 = phi i64 [%67, %$26] ; # Bnd
; # (val 3 Bnd)
  %71 = inttoptr i64 %70 to i64*
  %72 = getelementptr i64, i64* %71, i32 2
  %73 = load i64, i64* %72
  br label %$23
$25:
  %74 = phi i64 [%50, %$23], [%66, %$26] ; # N
  %75 = phi i64 [%51, %$23], [%67, %$26] ; # Bnd
  %76 = phi i64 [0, %$23], [0, %$26] ; # ->
  br label %$22
$22:
  %77 = phi i64 [%45, %$20], [%74, %$25] ; # N
  br label %$13
$13:
; # (runAt E)
  %78 = call i64 @runAt(i64 %13)
; # drop
  %79 = inttoptr i64 %23 to i64*
  %80 = getelementptr i64, i64* %79, i32 1
  %81 = load i64, i64* %80
  %82 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %81, i64* %82
  br label %$7
$7:
  %83 = phi i64 [%13, %$9], [%19, %$11], [%78, %$13] ; # ->
  ret i64 %83
}

define i64 @_Def(i64) align 8 {
$1:
; # (let (X (cdr Exe) Sym (save (needSymb Exe (eval (++ X)))) Y (save...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (needSymb Exe (eval (++ X)))
  %16 = xor i64 %15, 8
  %17 = and i64 %16, 14
  %18 = icmp eq i64 %17, 0
  br i1 %18, label %$8, label %$7
$7:
  call void @symErr(i64 %0, i64 %15)
  unreachable
$8:
; # (save (needSymb Exe (eval (++ X))))
  %19 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %20 = load i64, i64* %19
  %21 = alloca i64, i64 2, align 16
  %22 = ptrtoint i64* %21 to i64
  %23 = inttoptr i64 %22 to i64*
  store i64 %15, i64* %23
  %24 = add i64 %22, 8
  %25 = inttoptr i64 %24 to i64*
  store i64 %20, i64* %25
  %26 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %22, i64* %26
; # (++ X)
  %27 = inttoptr i64 %7 to i64*
  %28 = load i64, i64* %27
  %29 = getelementptr i64, i64* %27, i32 1
  %30 = load i64, i64* %29
; # (eval (++ X))
  %31 = and i64 %28, 6
  %32 = icmp ne i64 %31, 0
  br i1 %32, label %$11, label %$10
$11:
  br label %$9
$10:
  %33 = and i64 %28, 8
  %34 = icmp ne i64 %33, 0
  br i1 %34, label %$13, label %$12
$13:
  %35 = inttoptr i64 %28 to i64*
  %36 = load i64, i64* %35
  br label %$9
$12:
  %37 = call i64 @evList(i64 %28)
  br label %$9
$9:
  %38 = phi i64 [%28, %$11], [%36, %$13], [%37, %$12] ; # ->
; # (save (eval (++ X)))
  %39 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %40 = load i64, i64* %39
  %41 = alloca i64, i64 2, align 16
  %42 = ptrtoint i64* %41 to i64
  %43 = inttoptr i64 %42 to i64*
  store i64 %38, i64* %43
  %44 = add i64 %42, 8
  %45 = inttoptr i64 %44 to i64*
  store i64 %40, i64* %45
  %46 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %42, i64* %46
; # (if (pair X) (let Val (save (eval (car X))) (when (== Y ZERO) (se...
; # (pair X)
  %47 = and i64 %30, 15
  %48 = icmp eq i64 %47, 0
  br i1 %48, label %$14, label %$15
$14:
  %49 = phi i64 [%38, %$9] ; # Y
; # (let Val (save (eval (car X))) (when (== Y ZERO) (setq Y Val) (go...
; # (car X)
  %50 = inttoptr i64 %30 to i64*
  %51 = load i64, i64* %50
; # (eval (car X))
  %52 = and i64 %51, 6
  %53 = icmp ne i64 %52, 0
  br i1 %53, label %$19, label %$18
$19:
  br label %$17
$18:
  %54 = and i64 %51, 8
  %55 = icmp ne i64 %54, 0
  br i1 %55, label %$21, label %$20
$21:
  %56 = inttoptr i64 %51 to i64*
  %57 = load i64, i64* %56
  br label %$17
$20:
  %58 = call i64 @evList(i64 %51)
  br label %$17
$17:
  %59 = phi i64 [%51, %$19], [%57, %$21], [%58, %$20] ; # ->
; # (save (eval (car X)))
  %60 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %61 = load i64, i64* %60
  %62 = alloca i64, i64 2, align 16
  %63 = ptrtoint i64* %62 to i64
  %64 = inttoptr i64 %63 to i64*
  store i64 %59, i64* %64
  %65 = add i64 %63, 8
  %66 = inttoptr i64 %65 to i64*
  store i64 %61, i64* %66
  %67 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %63, i64* %67
; # (when (== Y ZERO) (setq Y Val) (goto 1))
; # (== Y ZERO)
  %68 = icmp eq i64 %49, 2
  br i1 %68, label %$22, label %$23
$22:
  %69 = phi i64 [%49, %$17] ; # Y
; # (goto 1)
  br label %$-1
$23:
  %70 = phi i64 [%49, %$17] ; # Y
; # (when (sym? (val (tail Sym))) (if (nil? Y) (dbFetch Exe Sym) (dbT...
; # (tail Sym)
  %71 = add i64 %15, -8
; # (val (tail Sym))
  %72 = inttoptr i64 %71 to i64*
  %73 = load i64, i64* %72
; # (sym? (val (tail Sym)))
  %74 = and i64 %73, 8
  %75 = icmp ne i64 %74, 0
  br i1 %75, label %$24, label %$25
$24:
  %76 = phi i64 [%70, %$23] ; # Y
; # (if (nil? Y) (dbFetch Exe Sym) (dbTouch Exe Sym))
; # (nil? Y)
  %77 = icmp eq i64 %76, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %77, label %$26, label %$27
$26:
  %78 = phi i64 [%76, %$24] ; # Y
; # (dbFetch Exe Sym)
  call void @dbFetch(i64 %0, i64 %15)
  br label %$28
$27:
  %79 = phi i64 [%76, %$24] ; # Y
; # (dbTouch Exe Sym)
  call void @dbTouch(i64 %0, i64 %15)
  br label %$28
$28:
  %80 = phi i64 [%78, %$26], [%79, %$27] ; # Y
  br label %$25
$25:
  %81 = phi i64 [%70, %$23], [%80, %$28] ; # Y
; # (let V (get Sym Y) (unless (or (nil? V) (equal V Val)) (redefMsg ...
; # (get Sym Y)
  %82 = call i64 @get(i64 %15, i64 %81)
; # (unless (or (nil? V) (equal V Val)) (redefMsg Sym Y))
; # (or (nil? V) (equal V Val))
; # (nil? V)
  %83 = icmp eq i64 %82, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %83, label %$29, label %$30
$30:
  %84 = phi i64 [%81, %$25] ; # Y
; # (equal V Val)
  %85 = call i1 @equal(i64 %82, i64 %59)
  br label %$29
$29:
  %86 = phi i64 [%81, %$25], [%84, %$30] ; # Y
  %87 = phi i1 [1, %$25], [%85, %$30] ; # ->
  br i1 %87, label %$32, label %$31
$31:
  %88 = phi i64 [%86, %$29] ; # Y
; # (redefMsg Sym Y)
  call void @redefMsg(i64 %15, i64 %88)
  br label %$32
$32:
  %89 = phi i64 [%86, %$29], [%88, %$31] ; # Y
; # (put Sym Y Val)
  call void @put(i64 %15, i64 %89, i64 %59)
; # (putSrc Sym Y)
  call void @putSrc(i64 %15, i64 %89)
  br label %$16
$15:
  %90 = phi i64 [%38, %$9] ; # Y
; # (: 1 (chkVar Exe Sym) (when (sym? (val (tail Sym))) (dbTouch Exe ...
  br label %$-1
$-1:
  %91 = phi i64 [%59, %$22], [%90, %$15] ; # Y
; # (chkVar Exe Sym)
  %92 = icmp uge i64 %15, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %92, label %$34, label %$33
$34:
  %93 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %15
  br label %$33
$33:
  %94 = phi i1 [0, %$-1], [%93, %$34] ; # ->
  br i1 %94, label %$35, label %$36
$35:
  call void @protErr(i64 %0, i64 %15)
  unreachable
$36:
; # (when (sym? (val (tail Sym))) (dbTouch Exe Sym))
; # (tail Sym)
  %95 = add i64 %15, -8
; # (val (tail Sym))
  %96 = inttoptr i64 %95 to i64*
  %97 = load i64, i64* %96
; # (sym? (val (tail Sym)))
  %98 = and i64 %97, 8
  %99 = icmp ne i64 %98, 0
  br i1 %99, label %$37, label %$38
$37:
  %100 = phi i64 [%91, %$36] ; # Y
; # (dbTouch Exe Sym)
  call void @dbTouch(i64 %0, i64 %15)
  br label %$38
$38:
  %101 = phi i64 [%91, %$36], [%100, %$37] ; # Y
; # (let V (val Sym) (unless (or (nil? V) (== V Sym) (equal V Y)) (re...
; # (val Sym)
  %102 = inttoptr i64 %15 to i64*
  %103 = load i64, i64* %102
; # (unless (or (nil? V) (== V Sym) (equal V Y)) (redefMsg Sym 0))
; # (or (nil? V) (== V Sym) (equal V Y))
; # (nil? V)
  %104 = icmp eq i64 %103, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %104, label %$39, label %$40
$40:
  %105 = phi i64 [%101, %$38] ; # Y
; # (== V Sym)
  %106 = icmp eq i64 %103, %15
  br i1 %106, label %$39, label %$41
$41:
  %107 = phi i64 [%105, %$40] ; # Y
; # (equal V Y)
  %108 = call i1 @equal(i64 %103, i64 %107)
  br label %$39
$39:
  %109 = phi i64 [%101, %$38], [%105, %$40], [%107, %$41] ; # Y
  %110 = phi i1 [1, %$38], [1, %$40], [%108, %$41] ; # ->
  br i1 %110, label %$43, label %$42
$42:
  %111 = phi i64 [%109, %$39] ; # Y
; # (redefMsg Sym 0)
  call void @redefMsg(i64 %15, i64 0)
  br label %$43
$43:
  %112 = phi i64 [%109, %$39], [%111, %$42] ; # Y
; # (set Sym Y)
  %113 = inttoptr i64 %15 to i64*
  store i64 %112, i64* %113
; # (putSrc Sym 0)
  call void @putSrc(i64 %15, i64 0)
  br label %$16
$16:
  %114 = phi i64 [%89, %$32], [%112, %$43] ; # Y
; # (drop *Safe)
  %115 = inttoptr i64 %22 to i64*
  %116 = getelementptr i64, i64* %115, i32 1
  %117 = load i64, i64* %116
  %118 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %117, i64* %118
  ret i64 %15
}

define i64 @_De(i64) align 8 {
$1:
; # (let S (cadr Exe) (redefine Exe S (cddr Exe)) S)
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (cddr Exe)
  %6 = inttoptr i64 %0 to i64*
  %7 = getelementptr i64, i64* %6, i32 1
  %8 = load i64, i64* %7
  %9 = inttoptr i64 %8 to i64*
  %10 = getelementptr i64, i64* %9, i32 1
  %11 = load i64, i64* %10
; # (redefine Exe S (cddr Exe))
  call void @redefine(i64 %0, i64 %5, i64 %11)
  ret i64 %5
}

define i64 @_Dm(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (car X) Fun (cdr X) Msg (if (atom Y) Y (car Y...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (car X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (cdr X)
  %6 = inttoptr i64 %3 to i64*
  %7 = getelementptr i64, i64* %6, i32 1
  %8 = load i64, i64* %7
; # (if (atom Y) Y (car Y))
; # (atom Y)
  %9 = and i64 %5, 15
  %10 = icmp ne i64 %9, 0
  br i1 %10, label %$2, label %$3
$2:
  %11 = phi i64 [%3, %$1] ; # X
  %12 = phi i64 [%8, %$1] ; # Fun
  br label %$4
$3:
  %13 = phi i64 [%3, %$1] ; # X
  %14 = phi i64 [%8, %$1] ; # Fun
; # (car Y)
  %15 = inttoptr i64 %5 to i64*
  %16 = load i64, i64* %15
  br label %$4
$4:
  %17 = phi i64 [%11, %$2], [%13, %$3] ; # X
  %18 = phi i64 [%12, %$2], [%14, %$3] ; # Fun
  %19 = phi i64 [%5, %$2], [%16, %$3] ; # ->
; # (cond ((atom Y) (val $Class)) ((atom (cdr Y)) @) (T (let Z @ (get...
; # (atom Y)
  %20 = and i64 %5, 15
  %21 = icmp ne i64 %20, 0
  br i1 %21, label %$7, label %$6
$7:
  %22 = phi i64 [%17, %$4] ; # X
  %23 = phi i64 [%18, %$4] ; # Fun
; # (val $Class)
  %24 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 584) to i64) to i64*
  %25 = load i64, i64* %24
  br label %$5
$6:
  %26 = phi i64 [%17, %$4] ; # X
  %27 = phi i64 [%18, %$4] ; # Fun
; # (cdr Y)
  %28 = inttoptr i64 %5 to i64*
  %29 = getelementptr i64, i64* %28, i32 1
  %30 = load i64, i64* %29
; # (atom (cdr Y))
  %31 = and i64 %30, 15
  %32 = icmp ne i64 %31, 0
  br i1 %32, label %$9, label %$8
$9:
  %33 = phi i64 [%26, %$6] ; # X
  %34 = phi i64 [%27, %$6] ; # Fun
  br label %$5
$8:
  %35 = phi i64 [%26, %$6] ; # X
  %36 = phi i64 [%27, %$6] ; # Fun
; # (let Z @ (get (if (nil? (cdr Z)) (val $Class) @) (needSymb Exe (c...
; # (if (nil? (cdr Z)) (val $Class) @)
; # (cdr Z)
  %37 = inttoptr i64 %30 to i64*
  %38 = getelementptr i64, i64* %37, i32 1
  %39 = load i64, i64* %38
; # (nil? (cdr Z))
  %40 = icmp eq i64 %39, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %40, label %$10, label %$11
$10:
  %41 = phi i64 [%35, %$8] ; # X
  %42 = phi i64 [%36, %$8] ; # Fun
; # (val $Class)
  %43 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 584) to i64) to i64*
  %44 = load i64, i64* %43
  br label %$12
$11:
  %45 = phi i64 [%35, %$8] ; # X
  %46 = phi i64 [%36, %$8] ; # Fun
  br label %$12
$12:
  %47 = phi i64 [%41, %$10], [%45, %$11] ; # X
  %48 = phi i64 [%42, %$10], [%46, %$11] ; # Fun
  %49 = phi i64 [%44, %$10], [%39, %$11] ; # ->
; # (car Z)
  %50 = inttoptr i64 %30 to i64*
  %51 = load i64, i64* %50
; # (needSymb Exe (car Z))
  %52 = xor i64 %51, 8
  %53 = and i64 %52, 14
  %54 = icmp eq i64 %53, 0
  br i1 %54, label %$14, label %$13
$13:
  call void @symErr(i64 %0, i64 %51)
  unreachable
$14:
; # (get (if (nil? (cdr Z)) (val $Class) @) (needSymb Exe (car Z)))
  %55 = call i64 @get(i64 %49, i64 %51)
  br label %$5
$5:
  %56 = phi i64 [%22, %$7], [%33, %$9], [%47, %$14] ; # X
  %57 = phi i64 [%23, %$7], [%34, %$9], [%48, %$14] ; # Fun
  %58 = phi i64 [%25, %$7], [%30, %$9], [%55, %$14] ; # ->
; # (chkVar Exe Cls)
  %59 = icmp uge i64 %58, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %59, label %$16, label %$15
$16:
  %60 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %58
  br label %$15
$15:
  %61 = phi i1 [0, %$5], [%60, %$16] ; # ->
  br i1 %61, label %$17, label %$18
$17:
  call void @protErr(i64 %0, i64 %58)
  unreachable
$18:
; # (unless (t? Msg) (redefine Exe Msg (val $Meth)))
; # (t? Msg)
  %62 = icmp eq i64 %19, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %62, label %$20, label %$19
$19:
  %63 = phi i64 [%56, %$18] ; # X
  %64 = phi i64 [%57, %$18] ; # Fun
; # (val $Meth)
  %65 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 248) to i64) to i64*
  %66 = load i64, i64* %65
; # (redefine Exe Msg (val $Meth))
  call void @redefine(i64 %0, i64 %19, i64 %66)
  br label %$20
$20:
  %67 = phi i64 [%56, %$18], [%63, %$19] ; # X
  %68 = phi i64 [%57, %$18], [%64, %$19] ; # Fun
; # (when (symb? Fun) (let L (val Fun) (loop (when (or (atom L) (atom...
; # (symb? Fun)
  %69 = xor i64 %68, 8
  %70 = and i64 %69, 14
  %71 = icmp eq i64 %70, 0
  br i1 %71, label %$21, label %$22
$21:
  %72 = phi i64 [%67, %$20] ; # X
  %73 = phi i64 [%68, %$20] ; # Fun
; # (let L (val Fun) (loop (when (or (atom L) (atom (car L))) (err Ex...
; # (val Fun)
  %74 = inttoptr i64 %73 to i64*
  %75 = load i64, i64* %74
; # (loop (when (or (atom L) (atom (car L))) (err Exe Msg ($ "Bad mes...
  br label %$23
$23:
  %76 = phi i64 [%72, %$21], [%111, %$28] ; # X
  %77 = phi i64 [%73, %$21], [%112, %$28] ; # Fun
  %78 = phi i64 [%75, %$21], [%116, %$28] ; # L
; # (when (or (atom L) (atom (car L))) (err Exe Msg ($ "Bad message")...
; # (or (atom L) (atom (car L)))
; # (atom L)
  %79 = and i64 %78, 15
  %80 = icmp ne i64 %79, 0
  br i1 %80, label %$24, label %$25
$25:
  %81 = phi i64 [%76, %$23] ; # X
  %82 = phi i64 [%77, %$23] ; # Fun
  %83 = phi i64 [%78, %$23] ; # L
; # (car L)
  %84 = inttoptr i64 %83 to i64*
  %85 = load i64, i64* %84
; # (atom (car L))
  %86 = and i64 %85, 15
  %87 = icmp ne i64 %86, 0
  br label %$24
$24:
  %88 = phi i64 [%76, %$23], [%81, %$25] ; # X
  %89 = phi i64 [%77, %$23], [%82, %$25] ; # Fun
  %90 = phi i64 [%78, %$23], [%83, %$25] ; # L
  %91 = phi i1 [1, %$23], [%87, %$25] ; # ->
  br i1 %91, label %$26, label %$27
$26:
  %92 = phi i64 [%88, %$24] ; # X
  %93 = phi i64 [%89, %$24] ; # Fun
  %94 = phi i64 [%90, %$24] ; # L
; # (err Exe Msg ($ "Bad message") null)
  call void @err(i64 %0, i64 %19, i8* bitcast ([12 x i8]* @$73 to i8*), i8* null)
  unreachable
$27:
  %95 = phi i64 [%88, %$24] ; # X
  %96 = phi i64 [%89, %$24] ; # Fun
  %97 = phi i64 [%90, %$24] ; # L
; # (? (== Msg (caar L)) (setq X (car L) Fun (cdr X)))
; # (caar L)
  %98 = inttoptr i64 %97 to i64*
  %99 = load i64, i64* %98
  %100 = inttoptr i64 %99 to i64*
  %101 = load i64, i64* %100
; # (== Msg (caar L))
  %102 = icmp eq i64 %19, %101
  br i1 %102, label %$30, label %$28
$30:
  %103 = phi i64 [%95, %$27] ; # X
  %104 = phi i64 [%96, %$27] ; # Fun
  %105 = phi i64 [%97, %$27] ; # L
; # (car L)
  %106 = inttoptr i64 %105 to i64*
  %107 = load i64, i64* %106
; # (cdr X)
  %108 = inttoptr i64 %107 to i64*
  %109 = getelementptr i64, i64* %108, i32 1
  %110 = load i64, i64* %109
  br label %$29
$28:
  %111 = phi i64 [%95, %$27] ; # X
  %112 = phi i64 [%96, %$27] ; # Fun
  %113 = phi i64 [%97, %$27] ; # L
; # (shift L)
  %114 = inttoptr i64 %113 to i64*
  %115 = getelementptr i64, i64* %114, i32 1
  %116 = load i64, i64* %115
  br label %$23
$29:
  %117 = phi i64 [%107, %$30] ; # X
  %118 = phi i64 [%110, %$30] ; # Fun
  %119 = phi i64 [%105, %$30] ; # L
  %120 = phi i64 [%110, %$30] ; # ->
  br label %$22
$22:
  %121 = phi i64 [%67, %$20], [%117, %$29] ; # X
  %122 = phi i64 [%68, %$20], [%118, %$29] ; # Fun
; # (let (V (val Cls) L V) (loop (? (or (atom L) (atom (car L))) (set...
; # (val Cls)
  %123 = inttoptr i64 %58 to i64*
  %124 = load i64, i64* %123
; # (loop (? (or (atom L) (atom (car L))) (set Cls (cons (if (atom (c...
  br label %$31
$31:
  %125 = phi i64 [%121, %$22], [%186, %$40] ; # X
  %126 = phi i64 [%122, %$22], [%187, %$40] ; # Fun
  %127 = phi i64 [%124, %$22], [%191, %$40] ; # L
; # (? (or (atom L) (atom (car L))) (set Cls (cons (if (atom (car X))...
; # (or (atom L) (atom (car L)))
; # (atom L)
  %128 = and i64 %127, 15
  %129 = icmp ne i64 %128, 0
  br i1 %129, label %$32, label %$33
$33:
  %130 = phi i64 [%125, %$31] ; # X
  %131 = phi i64 [%126, %$31] ; # Fun
  %132 = phi i64 [%127, %$31] ; # L
; # (car L)
  %133 = inttoptr i64 %132 to i64*
  %134 = load i64, i64* %133
; # (atom (car L))
  %135 = and i64 %134, 15
  %136 = icmp ne i64 %135, 0
  br label %$32
$32:
  %137 = phi i64 [%125, %$31], [%130, %$33] ; # X
  %138 = phi i64 [%126, %$31], [%131, %$33] ; # Fun
  %139 = phi i64 [%127, %$31], [%132, %$33] ; # L
  %140 = phi i1 [1, %$31], [%136, %$33] ; # ->
  br i1 %140, label %$36, label %$34
$36:
  %141 = phi i64 [%137, %$32] ; # X
  %142 = phi i64 [%138, %$32] ; # Fun
  %143 = phi i64 [%139, %$32] ; # L
; # (set Cls (cons (if (atom (car X)) X (cons Msg Fun)) V))
; # (if (atom (car X)) X (cons Msg Fun))
; # (car X)
  %144 = inttoptr i64 %141 to i64*
  %145 = load i64, i64* %144
; # (atom (car X))
  %146 = and i64 %145, 15
  %147 = icmp ne i64 %146, 0
  br i1 %147, label %$37, label %$38
$37:
  %148 = phi i64 [%141, %$36] ; # X
  %149 = phi i64 [%142, %$36] ; # Fun
  %150 = phi i64 [%143, %$36] ; # L
  br label %$39
$38:
  %151 = phi i64 [%141, %$36] ; # X
  %152 = phi i64 [%142, %$36] ; # Fun
  %153 = phi i64 [%143, %$36] ; # L
; # (cons Msg Fun)
  %154 = call i64 @cons(i64 %19, i64 %152)
  br label %$39
$39:
  %155 = phi i64 [%148, %$37], [%151, %$38] ; # X
  %156 = phi i64 [%149, %$37], [%152, %$38] ; # Fun
  %157 = phi i64 [%150, %$37], [%153, %$38] ; # L
  %158 = phi i64 [%148, %$37], [%154, %$38] ; # ->
; # (cons (if (atom (car X)) X (cons Msg Fun)) V)
  %159 = call i64 @cons(i64 %158, i64 %124)
  %160 = inttoptr i64 %58 to i64*
  store i64 %159, i64* %160
  br label %$35
$34:
  %161 = phi i64 [%137, %$32] ; # X
  %162 = phi i64 [%138, %$32] ; # Fun
  %163 = phi i64 [%139, %$32] ; # L
; # (? (== Msg (caar L)) (let Z (car L) (unless (equal Fun (cdr Z)) (...
; # (caar L)
  %164 = inttoptr i64 %163 to i64*
  %165 = load i64, i64* %164
  %166 = inttoptr i64 %165 to i64*
  %167 = load i64, i64* %166
; # (== Msg (caar L))
  %168 = icmp eq i64 %19, %167
  br i1 %168, label %$41, label %$40
$41:
  %169 = phi i64 [%161, %$34] ; # X
  %170 = phi i64 [%162, %$34] ; # Fun
  %171 = phi i64 [%163, %$34] ; # L
; # (let Z (car L) (unless (equal Fun (cdr Z)) (redefMsg Msg Cls)) (s...
; # (car L)
  %172 = inttoptr i64 %171 to i64*
  %173 = load i64, i64* %172
; # (unless (equal Fun (cdr Z)) (redefMsg Msg Cls))
; # (cdr Z)
  %174 = inttoptr i64 %173 to i64*
  %175 = getelementptr i64, i64* %174, i32 1
  %176 = load i64, i64* %175
; # (equal Fun (cdr Z))
  %177 = call i1 @equal(i64 %170, i64 %176)
  br i1 %177, label %$43, label %$42
$42:
  %178 = phi i64 [%169, %$41] ; # X
  %179 = phi i64 [%170, %$41] ; # Fun
  %180 = phi i64 [%171, %$41] ; # L
; # (redefMsg Msg Cls)
  call void @redefMsg(i64 %19, i64 %58)
  br label %$43
$43:
  %181 = phi i64 [%169, %$41], [%178, %$42] ; # X
  %182 = phi i64 [%170, %$41], [%179, %$42] ; # Fun
  %183 = phi i64 [%171, %$41], [%180, %$42] ; # L
; # (set 2 Z Fun)
  %184 = inttoptr i64 %173 to i64*
  %185 = getelementptr i64, i64* %184, i32 1
  store i64 %182, i64* %185
  br label %$35
$40:
  %186 = phi i64 [%161, %$34] ; # X
  %187 = phi i64 [%162, %$34] ; # Fun
  %188 = phi i64 [%163, %$34] ; # L
; # (shift L)
  %189 = inttoptr i64 %188 to i64*
  %190 = getelementptr i64, i64* %189, i32 1
  %191 = load i64, i64* %190
  br label %$31
$35:
  %192 = phi i64 [%155, %$39], [%181, %$43] ; # X
  %193 = phi i64 [%156, %$39], [%182, %$43] ; # Fun
  %194 = phi i64 [%157, %$39], [%183, %$43] ; # L
  %195 = phi i64 [%159, %$39], [%182, %$43] ; # ->
; # (putSrc Cls Msg)
  call void @putSrc(i64 %58, i64 %19)
  ret i64 %19
}

define i64 @evMethod(i64, i64, i64, i64, i64) align 8 {
$1:
; # (let (Y (car Exe) P (set $Bind (push (val $At) $At (val $Bind) Ex...
; # (car Exe)
  %5 = inttoptr i64 %3 to i64*
  %6 = load i64, i64* %5
; # (set $Bind (push (val $At) $At (val $Bind) Exe))
; # (val $At)
  %7 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  %8 = load i64, i64* %7
; # (val $Bind)
  %9 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  %10 = load i64, i64* %9
; # (push (val $At) $At (val $Bind) Exe)
  %11 = alloca i64, i64 4, align 16
  %12 = ptrtoint i64* %11 to i64
  %13 = inttoptr i64 %12 to i64*
  store i64 %8, i64* %13
  %14 = add i64 %12, 8
  %15 = inttoptr i64 %14 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64), i64* %15
  %16 = add i64 %12, 16
  %17 = inttoptr i64 %16 to i64*
  store i64 %10, i64* %17
  %18 = add i64 %12, 24
  %19 = inttoptr i64 %18 to i64*
  store i64 %3, i64* %19
  %20 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %12, i64* %20
; # (set $Bind (setq P (push Obj $This P)))
; # (push Obj $This P)
  %21 = alloca i64, i64 3, align 16
  %22 = ptrtoint i64* %21 to i64
  %23 = inttoptr i64 %22 to i64*
  store i64 %0, i64* %23
  %24 = add i64 %22, 8
  %25 = inttoptr i64 %24 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 488) to i64), i64* %25
  %26 = add i64 %22, 16
  %27 = inttoptr i64 %26 to i64*
  store i64 %12, i64* %27
  %28 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %22, i64* %28
; # (while (pair Y) (let (V (eval (++ X)) Z (++ Y)) (if (atom Z) (set...
  br label %$2
$2:
  %29 = phi i64 [%4, %$1], [%159, %$12] ; # X
  %30 = phi i64 [%6, %$1], [%160, %$12] ; # Y
  %31 = phi i64 [%22, %$1], [%161, %$12] ; # P
; # (pair Y)
  %32 = and i64 %30, 15
  %33 = icmp eq i64 %32, 0
  br i1 %33, label %$3, label %$4
$3:
  %34 = phi i64 [%29, %$2] ; # X
  %35 = phi i64 [%30, %$2] ; # Y
  %36 = phi i64 [%31, %$2] ; # P
; # (let (V (eval (++ X)) Z (++ Y)) (if (atom Z) (set $Bind (setq P (...
; # (++ X)
  %37 = inttoptr i64 %34 to i64*
  %38 = load i64, i64* %37
  %39 = getelementptr i64, i64* %37, i32 1
  %40 = load i64, i64* %39
; # (eval (++ X))
  %41 = and i64 %38, 6
  %42 = icmp ne i64 %41, 0
  br i1 %42, label %$7, label %$6
$7:
  br label %$5
$6:
  %43 = and i64 %38, 8
  %44 = icmp ne i64 %43, 0
  br i1 %44, label %$9, label %$8
$9:
  %45 = inttoptr i64 %38 to i64*
  %46 = load i64, i64* %45
  br label %$5
$8:
  %47 = call i64 @evList(i64 %38)
  br label %$5
$5:
  %48 = phi i64 [%38, %$7], [%46, %$9], [%47, %$8] ; # ->
; # (++ Y)
  %49 = inttoptr i64 %35 to i64*
  %50 = load i64, i64* %49
  %51 = getelementptr i64, i64* %49, i32 1
  %52 = load i64, i64* %51
; # (if (atom Z) (set $Bind (setq P (push V (needChkVar Exe Z) P))) (...
; # (atom Z)
  %53 = and i64 %50, 15
  %54 = icmp ne i64 %53, 0
  br i1 %54, label %$10, label %$11
$10:
  %55 = phi i64 [%40, %$5] ; # X
  %56 = phi i64 [%52, %$5] ; # Y
  %57 = phi i64 [%36, %$5] ; # P
  %58 = phi i64 [%48, %$5] ; # V
  %59 = phi i64 [%50, %$5] ; # Z
; # (set $Bind (setq P (push V (needChkVar Exe Z) P)))
; # (needChkVar Exe Z)
  %60 = and i64 %59, 6
  %61 = icmp ne i64 %60, 0
  br i1 %61, label %$13, label %$14
$13:
  call void @varErr(i64 %3, i64 %59)
  unreachable
$14:
  %62 = icmp uge i64 %59, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %62, label %$16, label %$15
$16:
  %63 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %59
  br label %$15
$15:
  %64 = phi i1 [0, %$14], [%63, %$16] ; # ->
  br i1 %64, label %$17, label %$18
$17:
  call void @protErr(i64 %3, i64 %59)
  unreachable
$18:
; # (push V (needChkVar Exe Z) P)
  %65 = alloca i64, i64 3, align 16
  %66 = ptrtoint i64* %65 to i64
  %67 = inttoptr i64 %66 to i64*
  store i64 %58, i64* %67
  %68 = add i64 %66, 8
  %69 = inttoptr i64 %68 to i64*
  store i64 %59, i64* %69
  %70 = add i64 %66, 16
  %71 = inttoptr i64 %70 to i64*
  store i64 %57, i64* %71
  %72 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %66, i64* %72
  br label %$12
$11:
  %73 = phi i64 [%40, %$5] ; # X
  %74 = phi i64 [%52, %$5] ; # Y
  %75 = phi i64 [%36, %$5] ; # P
  %76 = phi i64 [%48, %$5] ; # V
  %77 = phi i64 [%50, %$5] ; # Z
; # (loop (set $Bind (setq P (push (if (pair V) (++ V) $Nil) (needChk...
  br label %$19
$19:
  %78 = phi i64 [%73, %$11], [%124, %$29] ; # X
  %79 = phi i64 [%74, %$11], [%125, %$29] ; # Y
  %80 = phi i64 [%75, %$11], [%126, %$29] ; # P
  %81 = phi i64 [%76, %$11], [%127, %$29] ; # V
  %82 = phi i64 [%77, %$11], [%128, %$29] ; # Z
; # (set $Bind (setq P (push (if (pair V) (++ V) $Nil) (needChkVar Ex...
; # (if (pair V) (++ V) $Nil)
; # (pair V)
  %83 = and i64 %81, 15
  %84 = icmp eq i64 %83, 0
  br i1 %84, label %$20, label %$21
$20:
  %85 = phi i64 [%78, %$19] ; # X
  %86 = phi i64 [%79, %$19] ; # Y
  %87 = phi i64 [%80, %$19] ; # P
  %88 = phi i64 [%81, %$19] ; # V
  %89 = phi i64 [%82, %$19] ; # Z
; # (++ V)
  %90 = inttoptr i64 %88 to i64*
  %91 = load i64, i64* %90
  %92 = getelementptr i64, i64* %90, i32 1
  %93 = load i64, i64* %92
  br label %$22
$21:
  %94 = phi i64 [%78, %$19] ; # X
  %95 = phi i64 [%79, %$19] ; # Y
  %96 = phi i64 [%80, %$19] ; # P
  %97 = phi i64 [%81, %$19] ; # V
  %98 = phi i64 [%82, %$19] ; # Z
  br label %$22
$22:
  %99 = phi i64 [%85, %$20], [%94, %$21] ; # X
  %100 = phi i64 [%86, %$20], [%95, %$21] ; # Y
  %101 = phi i64 [%87, %$20], [%96, %$21] ; # P
  %102 = phi i64 [%93, %$20], [%97, %$21] ; # V
  %103 = phi i64 [%89, %$20], [%98, %$21] ; # Z
  %104 = phi i64 [%91, %$20], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$21] ; # ->
; # (++ Z)
  %105 = inttoptr i64 %103 to i64*
  %106 = load i64, i64* %105
  %107 = getelementptr i64, i64* %105, i32 1
  %108 = load i64, i64* %107
; # (needChkVar Exe (++ Z))
  %109 = and i64 %106, 6
  %110 = icmp ne i64 %109, 0
  br i1 %110, label %$23, label %$24
$23:
  call void @varErr(i64 %3, i64 %106)
  unreachable
$24:
  %111 = icmp uge i64 %106, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %111, label %$26, label %$25
$26:
  %112 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %106
  br label %$25
$25:
  %113 = phi i1 [0, %$24], [%112, %$26] ; # ->
  br i1 %113, label %$27, label %$28
$27:
  call void @protErr(i64 %3, i64 %106)
  unreachable
$28:
; # (push (if (pair V) (++ V) $Nil) (needChkVar Exe (++ Z)) P)
  %114 = alloca i64, i64 3, align 16
  %115 = ptrtoint i64* %114 to i64
  %116 = inttoptr i64 %115 to i64*
  store i64 %104, i64* %116
  %117 = add i64 %115, 8
  %118 = inttoptr i64 %117 to i64*
  store i64 %106, i64* %118
  %119 = add i64 %115, 16
  %120 = inttoptr i64 %119 to i64*
  store i64 %101, i64* %120
  %121 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %115, i64* %121
; # (? (atom Z))
; # (atom Z)
  %122 = and i64 %108, 15
  %123 = icmp ne i64 %122, 0
  br i1 %123, label %$30, label %$29
$29:
  %124 = phi i64 [%99, %$28] ; # X
  %125 = phi i64 [%100, %$28] ; # Y
  %126 = phi i64 [%115, %$28] ; # P
  %127 = phi i64 [%102, %$28] ; # V
  %128 = phi i64 [%108, %$28] ; # Z
  br label %$19
$30:
  %129 = phi i64 [%99, %$28] ; # X
  %130 = phi i64 [%100, %$28] ; # Y
  %131 = phi i64 [%115, %$28] ; # P
  %132 = phi i64 [%102, %$28] ; # V
  %133 = phi i64 [%108, %$28] ; # Z
  %134 = phi i64 [0, %$28] ; # ->
; # (unless (nil? Z) (set $Bind (setq P (push V (needChkVar Exe Z) P)...
; # (nil? Z)
  %135 = icmp eq i64 %133, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %135, label %$32, label %$31
$31:
  %136 = phi i64 [%129, %$30] ; # X
  %137 = phi i64 [%130, %$30] ; # Y
  %138 = phi i64 [%131, %$30] ; # P
  %139 = phi i64 [%132, %$30] ; # V
  %140 = phi i64 [%133, %$30] ; # Z
; # (set $Bind (setq P (push V (needChkVar Exe Z) P)))
; # (needChkVar Exe Z)
  %141 = and i64 %140, 6
  %142 = icmp ne i64 %141, 0
  br i1 %142, label %$33, label %$34
$33:
  call void @varErr(i64 %3, i64 %140)
  unreachable
$34:
  %143 = icmp uge i64 %140, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %143, label %$36, label %$35
$36:
  %144 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %140
  br label %$35
$35:
  %145 = phi i1 [0, %$34], [%144, %$36] ; # ->
  br i1 %145, label %$37, label %$38
$37:
  call void @protErr(i64 %3, i64 %140)
  unreachable
$38:
; # (push V (needChkVar Exe Z) P)
  %146 = alloca i64, i64 3, align 16
  %147 = ptrtoint i64* %146 to i64
  %148 = inttoptr i64 %147 to i64*
  store i64 %139, i64* %148
  %149 = add i64 %147, 8
  %150 = inttoptr i64 %149 to i64*
  store i64 %140, i64* %150
  %151 = add i64 %147, 16
  %152 = inttoptr i64 %151 to i64*
  store i64 %138, i64* %152
  %153 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %147, i64* %153
  br label %$32
$32:
  %154 = phi i64 [%129, %$30], [%136, %$38] ; # X
  %155 = phi i64 [%130, %$30], [%137, %$38] ; # Y
  %156 = phi i64 [%131, %$30], [%147, %$38] ; # P
  %157 = phi i64 [%132, %$30], [%139, %$38] ; # V
  %158 = phi i64 [%133, %$30], [%140, %$38] ; # Z
  br label %$12
$12:
  %159 = phi i64 [%55, %$18], [%154, %$32] ; # X
  %160 = phi i64 [%56, %$18], [%155, %$32] ; # Y
  %161 = phi i64 [%66, %$18], [%156, %$32] ; # P
  %162 = phi i64 [%58, %$18], [%157, %$32] ; # V
  %163 = phi i64 [%59, %$18], [%158, %$32] ; # Z
  br label %$2
$4:
  %164 = phi i64 [%29, %$2] ; # X
  %165 = phi i64 [%30, %$2] ; # Y
  %166 = phi i64 [%31, %$2] ; # P
; # (prog1 (if (== Y $At) (if (pair X) (let (L (push NIL (eval (car X...
; # (if (== Y $At) (if (pair X) (let (L (push NIL (eval (car X)) NIL)...
; # (== Y $At)
  %167 = icmp eq i64 %165, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64)
  br i1 %167, label %$39, label %$40
$39:
  %168 = phi i64 [%164, %$4] ; # X
  %169 = phi i64 [%165, %$4] ; # Y
  %170 = phi i64 [%166, %$4] ; # P
; # (if (pair X) (let (L (push NIL (eval (car X)) NIL) Q L) (link (of...
; # (pair X)
  %171 = and i64 %168, 15
  %172 = icmp eq i64 %171, 0
  br i1 %172, label %$42, label %$43
$42:
  %173 = phi i64 [%168, %$39] ; # X
  %174 = phi i64 [%169, %$39] ; # Y
  %175 = phi i64 [%170, %$39] ; # P
; # (let (L (push NIL (eval (car X)) NIL) Q L) (link (ofs L 1)) (whil...
; # (car X)
  %176 = inttoptr i64 %173 to i64*
  %177 = load i64, i64* %176
; # (eval (car X))
  %178 = and i64 %177, 6
  %179 = icmp ne i64 %178, 0
  br i1 %179, label %$47, label %$46
$47:
  br label %$45
$46:
  %180 = and i64 %177, 8
  %181 = icmp ne i64 %180, 0
  br i1 %181, label %$49, label %$48
$49:
  %182 = inttoptr i64 %177 to i64*
  %183 = load i64, i64* %182
  br label %$45
$48:
  %184 = call i64 @evList(i64 %177)
  br label %$45
$45:
  %185 = phi i64 [%177, %$47], [%183, %$49], [%184, %$48] ; # ->
; # (push NIL (eval (car X)) NIL)
  %186 = alloca i64, i64 3, align 16
  %187 = ptrtoint i64* %186 to i64
  %188 = add i64 %187, 8
  %189 = inttoptr i64 %188 to i64*
  store i64 %185, i64* %189
; # (ofs L 1)
  %190 = add i64 %187, 8
; # (link (ofs L 1))
  %191 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %192 = load i64, i64* %191
  %193 = inttoptr i64 %190 to i64*
  %194 = getelementptr i64, i64* %193, i32 1
  store i64 %192, i64* %194
  %195 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %190, i64* %195
; # (while (pair (shift X)) (setq L (set L (push NIL (eval (car X)) N...
  br label %$50
$50:
  %196 = phi i64 [%173, %$45], [%205, %$53] ; # X
  %197 = phi i64 [%174, %$45], [%206, %$53] ; # Y
  %198 = phi i64 [%175, %$45], [%207, %$53] ; # P
  %199 = phi i64 [%187, %$45], [%220, %$53] ; # L
; # (shift X)
  %200 = inttoptr i64 %196 to i64*
  %201 = getelementptr i64, i64* %200, i32 1
  %202 = load i64, i64* %201
; # (pair (shift X))
  %203 = and i64 %202, 15
  %204 = icmp eq i64 %203, 0
  br i1 %204, label %$51, label %$52
$51:
  %205 = phi i64 [%202, %$50] ; # X
  %206 = phi i64 [%197, %$50] ; # Y
  %207 = phi i64 [%198, %$50] ; # P
  %208 = phi i64 [%199, %$50] ; # L
; # (set L (push NIL (eval (car X)) NIL))
; # (car X)
  %209 = inttoptr i64 %205 to i64*
  %210 = load i64, i64* %209
; # (eval (car X))
  %211 = and i64 %210, 6
  %212 = icmp ne i64 %211, 0
  br i1 %212, label %$55, label %$54
$55:
  br label %$53
$54:
  %213 = and i64 %210, 8
  %214 = icmp ne i64 %213, 0
  br i1 %214, label %$57, label %$56
$57:
  %215 = inttoptr i64 %210 to i64*
  %216 = load i64, i64* %215
  br label %$53
$56:
  %217 = call i64 @evList(i64 %210)
  br label %$53
$53:
  %218 = phi i64 [%210, %$55], [%216, %$57], [%217, %$56] ; # ->
; # (push NIL (eval (car X)) NIL)
  %219 = alloca i64, i64 3, align 16
  %220 = ptrtoint i64* %219 to i64
  %221 = add i64 %220, 8
  %222 = inttoptr i64 %221 to i64*
  store i64 %218, i64* %222
  %223 = inttoptr i64 %208 to i64*
  store i64 %220, i64* %223
; # (ofs L 1)
  %224 = add i64 %220, 8
; # (link (ofs L 1))
  %225 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %226 = load i64, i64* %225
  %227 = inttoptr i64 %224 to i64*
  %228 = getelementptr i64, i64* %227, i32 1
  store i64 %226, i64* %228
  %229 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %224, i64* %229
  br label %$50
$52:
  %230 = phi i64 [%202, %$50] ; # X
  %231 = phi i64 [%197, %$50] ; # Y
  %232 = phi i64 [%198, %$50] ; # P
  %233 = phi i64 [%199, %$50] ; # L
; # (let Next (val $Next) (set L $Nil $Next Q) (loop (let Sym (val 2 ...
; # (val $Next)
  %234 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 128) to i64) to i64*
  %235 = load i64, i64* %234
; # (set L $Nil $Next Q)
  %236 = inttoptr i64 %233 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %236
  %237 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 128) to i64) to i64*
  store i64 %187, i64* %237
; # (loop (let Sym (val 2 P) (xchg Sym P) (? (== $At Sym)) (setq P (v...
  br label %$58
$58:
  %238 = phi i64 [%230, %$52], [%250, %$59] ; # X
  %239 = phi i64 [%231, %$52], [%251, %$59] ; # Y
  %240 = phi i64 [%232, %$52], [%256, %$59] ; # P
  %241 = phi i64 [%233, %$52], [%253, %$59] ; # L
; # (let Sym (val 2 P) (xchg Sym P) (? (== $At Sym)) (setq P (val 3 P...
; # (val 2 P)
  %242 = inttoptr i64 %240 to i64*
  %243 = getelementptr i64, i64* %242, i32 1
  %244 = load i64, i64* %243
; # (xchg Sym P)
  %245 = inttoptr i64 %244 to i64*
  %246 = load i64, i64* %245
  %247 = inttoptr i64 %240 to i64*
  %248 = load i64, i64* %247
  store i64 %248, i64* %245
  store i64 %246, i64* %247
; # (? (== $At Sym))
; # (== $At Sym)
  %249 = icmp eq i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64), %244
  br i1 %249, label %$60, label %$59
$59:
  %250 = phi i64 [%238, %$58] ; # X
  %251 = phi i64 [%239, %$58] ; # Y
  %252 = phi i64 [%240, %$58] ; # P
  %253 = phi i64 [%241, %$58] ; # L
; # (val 3 P)
  %254 = inttoptr i64 %252 to i64*
  %255 = getelementptr i64, i64* %254, i32 2
  %256 = load i64, i64* %255
  br label %$58
$60:
  %257 = phi i64 [%238, %$58] ; # X
  %258 = phi i64 [%239, %$58] ; # Y
  %259 = phi i64 [%240, %$58] ; # P
  %260 = phi i64 [%241, %$58] ; # L
  %261 = phi i64 [0, %$58] ; # ->
; # (let (TypS (val $Typ) KeyS (val $Key)) (prog2 (set $Typ Typ $Key ...
; # (val $Typ)
  %262 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 136) to i64) to i64*
  %263 = load i64, i64* %262
; # (val $Key)
  %264 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 144) to i64) to i64*
  %265 = load i64, i64* %264
; # (prog2 (set $Typ Typ $Key Key) (run (cdr Exe)) (set $Key KeyS $Ty...
; # (set $Typ Typ $Key Key)
  %266 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 136) to i64) to i64*
  store i64 %1, i64* %266
  %267 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 144) to i64) to i64*
  store i64 %2, i64* %267
; # (cdr Exe)
  %268 = inttoptr i64 %3 to i64*
  %269 = getelementptr i64, i64* %268, i32 1
  %270 = load i64, i64* %269
; # (run (cdr Exe))
  br label %$61
$61:
  %271 = phi i64 [%270, %$60], [%293, %$70] ; # Prg
  %272 = inttoptr i64 %271 to i64*
  %273 = load i64, i64* %272
  %274 = getelementptr i64, i64* %272, i32 1
  %275 = load i64, i64* %274
  %276 = and i64 %275, 15
  %277 = icmp ne i64 %276, 0
  br i1 %277, label %$64, label %$62
$64:
  %278 = phi i64 [%275, %$61] ; # Prg
  %279 = and i64 %273, 6
  %280 = icmp ne i64 %279, 0
  br i1 %280, label %$67, label %$66
$67:
  br label %$65
$66:
  %281 = and i64 %273, 8
  %282 = icmp ne i64 %281, 0
  br i1 %282, label %$69, label %$68
$69:
  %283 = inttoptr i64 %273 to i64*
  %284 = load i64, i64* %283
  br label %$65
$68:
  %285 = call i64 @evList(i64 %273)
  br label %$65
$65:
  %286 = phi i64 [%273, %$67], [%284, %$69], [%285, %$68] ; # ->
  br label %$63
$62:
  %287 = phi i64 [%275, %$61] ; # Prg
  %288 = and i64 %273, 15
  %289 = icmp eq i64 %288, 0
  br i1 %289, label %$71, label %$70
$71:
  %290 = phi i64 [%287, %$62] ; # Prg
  %291 = call i64 @evList(i64 %273)
  %292 = icmp ne i64 %291, 0
  br label %$70
$70:
  %293 = phi i64 [%287, %$62], [%290, %$71] ; # Prg
  %294 = phi i1 [0, %$62], [%292, %$71] ; # ->
  br label %$61
$63:
  %295 = phi i64 [%278, %$65] ; # Prg
  %296 = phi i64 [%286, %$65] ; # ->
; # (set $Key KeyS $Typ TypS $Next Next)
  %297 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 144) to i64) to i64*
  store i64 %265, i64* %297
  %298 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 136) to i64) to i64*
  store i64 %263, i64* %298
  %299 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 128) to i64) to i64*
  store i64 %235, i64* %299
; # (ofs Q 1)
  %300 = add i64 %187, 8
; # (drop (ofs Q 1))
  %301 = inttoptr i64 %300 to i64*
  %302 = getelementptr i64, i64* %301, i32 1
  %303 = load i64, i64* %302
  %304 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %303, i64* %304
  br label %$44
$43:
  %305 = phi i64 [%168, %$39] ; # X
  %306 = phi i64 [%169, %$39] ; # Y
  %307 = phi i64 [%170, %$39] ; # P
; # (let Next (val $Next) (set $Next $Nil) (loop (let Sym (val 2 P) (...
; # (val $Next)
  %308 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 128) to i64) to i64*
  %309 = load i64, i64* %308
; # (set $Next $Nil)
  %310 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 128) to i64) to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %310
; # (loop (let Sym (val 2 P) (xchg Sym P) (? (== $At Sym)) (setq P (v...
  br label %$72
$72:
  %311 = phi i64 [%305, %$43], [%322, %$73] ; # X
  %312 = phi i64 [%306, %$43], [%323, %$73] ; # Y
  %313 = phi i64 [%307, %$43], [%327, %$73] ; # P
; # (let Sym (val 2 P) (xchg Sym P) (? (== $At Sym)) (setq P (val 3 P...
; # (val 2 P)
  %314 = inttoptr i64 %313 to i64*
  %315 = getelementptr i64, i64* %314, i32 1
  %316 = load i64, i64* %315
; # (xchg Sym P)
  %317 = inttoptr i64 %316 to i64*
  %318 = load i64, i64* %317
  %319 = inttoptr i64 %313 to i64*
  %320 = load i64, i64* %319
  store i64 %320, i64* %317
  store i64 %318, i64* %319
; # (? (== $At Sym))
; # (== $At Sym)
  %321 = icmp eq i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64), %316
  br i1 %321, label %$74, label %$73
$73:
  %322 = phi i64 [%311, %$72] ; # X
  %323 = phi i64 [%312, %$72] ; # Y
  %324 = phi i64 [%313, %$72] ; # P
; # (val 3 P)
  %325 = inttoptr i64 %324 to i64*
  %326 = getelementptr i64, i64* %325, i32 2
  %327 = load i64, i64* %326
  br label %$72
$74:
  %328 = phi i64 [%311, %$72] ; # X
  %329 = phi i64 [%312, %$72] ; # Y
  %330 = phi i64 [%313, %$72] ; # P
  %331 = phi i64 [0, %$72] ; # ->
; # (let (TypS (val $Typ) KeyS (val $Key)) (prog2 (set $Typ Typ $Key ...
; # (val $Typ)
  %332 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 136) to i64) to i64*
  %333 = load i64, i64* %332
; # (val $Key)
  %334 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 144) to i64) to i64*
  %335 = load i64, i64* %334
; # (prog2 (set $Typ Typ $Key Key) (run (cdr Exe)) (set $Key KeyS $Ty...
; # (set $Typ Typ $Key Key)
  %336 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 136) to i64) to i64*
  store i64 %1, i64* %336
  %337 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 144) to i64) to i64*
  store i64 %2, i64* %337
; # (cdr Exe)
  %338 = inttoptr i64 %3 to i64*
  %339 = getelementptr i64, i64* %338, i32 1
  %340 = load i64, i64* %339
; # (run (cdr Exe))
  br label %$75
$75:
  %341 = phi i64 [%340, %$74], [%363, %$84] ; # Prg
  %342 = inttoptr i64 %341 to i64*
  %343 = load i64, i64* %342
  %344 = getelementptr i64, i64* %342, i32 1
  %345 = load i64, i64* %344
  %346 = and i64 %345, 15
  %347 = icmp ne i64 %346, 0
  br i1 %347, label %$78, label %$76
$78:
  %348 = phi i64 [%345, %$75] ; # Prg
  %349 = and i64 %343, 6
  %350 = icmp ne i64 %349, 0
  br i1 %350, label %$81, label %$80
$81:
  br label %$79
$80:
  %351 = and i64 %343, 8
  %352 = icmp ne i64 %351, 0
  br i1 %352, label %$83, label %$82
$83:
  %353 = inttoptr i64 %343 to i64*
  %354 = load i64, i64* %353
  br label %$79
$82:
  %355 = call i64 @evList(i64 %343)
  br label %$79
$79:
  %356 = phi i64 [%343, %$81], [%354, %$83], [%355, %$82] ; # ->
  br label %$77
$76:
  %357 = phi i64 [%345, %$75] ; # Prg
  %358 = and i64 %343, 15
  %359 = icmp eq i64 %358, 0
  br i1 %359, label %$85, label %$84
$85:
  %360 = phi i64 [%357, %$76] ; # Prg
  %361 = call i64 @evList(i64 %343)
  %362 = icmp ne i64 %361, 0
  br label %$84
$84:
  %363 = phi i64 [%357, %$76], [%360, %$85] ; # Prg
  %364 = phi i1 [0, %$76], [%362, %$85] ; # ->
  br label %$75
$77:
  %365 = phi i64 [%348, %$79] ; # Prg
  %366 = phi i64 [%356, %$79] ; # ->
; # (set $Key KeyS $Typ TypS $Next Next)
  %367 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 144) to i64) to i64*
  store i64 %335, i64* %367
  %368 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 136) to i64) to i64*
  store i64 %333, i64* %368
  %369 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 128) to i64) to i64*
  store i64 %309, i64* %369
  br label %$44
$44:
  %370 = phi i64 [%257, %$63], [%328, %$77] ; # X
  %371 = phi i64 [%258, %$63], [%329, %$77] ; # Y
  %372 = phi i64 [%259, %$63], [%330, %$77] ; # P
  %373 = phi i64 [%296, %$63], [%366, %$77] ; # ->
  br label %$41
$40:
  %374 = phi i64 [%164, %$4] ; # X
  %375 = phi i64 [%165, %$4] ; # Y
  %376 = phi i64 [%166, %$4] ; # P
; # (unless (nil? Y) (needChkVar Exe Y) (set $Bind (push (val Y) Y P)...
; # (nil? Y)
  %377 = icmp eq i64 %375, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %377, label %$87, label %$86
$86:
  %378 = phi i64 [%374, %$40] ; # X
  %379 = phi i64 [%375, %$40] ; # Y
  %380 = phi i64 [%376, %$40] ; # P
; # (needChkVar Exe Y)
  %381 = and i64 %379, 6
  %382 = icmp ne i64 %381, 0
  br i1 %382, label %$88, label %$89
$88:
  call void @varErr(i64 %3, i64 %379)
  unreachable
$89:
  %383 = icmp uge i64 %379, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %383, label %$91, label %$90
$91:
  %384 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %379
  br label %$90
$90:
  %385 = phi i1 [0, %$89], [%384, %$91] ; # ->
  br i1 %385, label %$92, label %$93
$92:
  call void @protErr(i64 %3, i64 %379)
  unreachable
$93:
; # (set $Bind (push (val Y) Y P) Y X)
; # (val Y)
  %386 = inttoptr i64 %379 to i64*
  %387 = load i64, i64* %386
; # (push (val Y) Y P)
  %388 = alloca i64, i64 3, align 16
  %389 = ptrtoint i64* %388 to i64
  %390 = inttoptr i64 %389 to i64*
  store i64 %387, i64* %390
  %391 = add i64 %389, 8
  %392 = inttoptr i64 %391 to i64*
  store i64 %379, i64* %392
  %393 = add i64 %389, 16
  %394 = inttoptr i64 %393 to i64*
  store i64 %380, i64* %394
  %395 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %389, i64* %395
  %396 = inttoptr i64 %379 to i64*
  store i64 %378, i64* %396
  br label %$87
$87:
  %397 = phi i64 [%374, %$40], [%378, %$93] ; # X
  %398 = phi i64 [%375, %$40], [%379, %$93] ; # Y
  %399 = phi i64 [%376, %$40], [%380, %$93] ; # P
; # (loop (let Sym (val 2 P) (xchg Sym P) (? (== $At Sym)) (setq P (v...
  br label %$94
$94:
  %400 = phi i64 [%397, %$87], [%411, %$95] ; # X
  %401 = phi i64 [%398, %$87], [%412, %$95] ; # Y
  %402 = phi i64 [%399, %$87], [%416, %$95] ; # P
; # (let Sym (val 2 P) (xchg Sym P) (? (== $At Sym)) (setq P (val 3 P...
; # (val 2 P)
  %403 = inttoptr i64 %402 to i64*
  %404 = getelementptr i64, i64* %403, i32 1
  %405 = load i64, i64* %404
; # (xchg Sym P)
  %406 = inttoptr i64 %405 to i64*
  %407 = load i64, i64* %406
  %408 = inttoptr i64 %402 to i64*
  %409 = load i64, i64* %408
  store i64 %409, i64* %406
  store i64 %407, i64* %408
; # (? (== $At Sym))
; # (== $At Sym)
  %410 = icmp eq i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64), %405
  br i1 %410, label %$96, label %$95
$95:
  %411 = phi i64 [%400, %$94] ; # X
  %412 = phi i64 [%401, %$94] ; # Y
  %413 = phi i64 [%402, %$94] ; # P
; # (val 3 P)
  %414 = inttoptr i64 %413 to i64*
  %415 = getelementptr i64, i64* %414, i32 2
  %416 = load i64, i64* %415
  br label %$94
$96:
  %417 = phi i64 [%400, %$94] ; # X
  %418 = phi i64 [%401, %$94] ; # Y
  %419 = phi i64 [%402, %$94] ; # P
  %420 = phi i64 [0, %$94] ; # ->
; # (let (TypS (val $Typ) KeyS (val $Key)) (prog2 (set $Typ Typ $Key ...
; # (val $Typ)
  %421 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 136) to i64) to i64*
  %422 = load i64, i64* %421
; # (val $Key)
  %423 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 144) to i64) to i64*
  %424 = load i64, i64* %423
; # (prog2 (set $Typ Typ $Key Key) (run (cdr Exe)) (set $Key KeyS $Ty...
; # (set $Typ Typ $Key Key)
  %425 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 136) to i64) to i64*
  store i64 %1, i64* %425
  %426 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 144) to i64) to i64*
  store i64 %2, i64* %426
; # (cdr Exe)
  %427 = inttoptr i64 %3 to i64*
  %428 = getelementptr i64, i64* %427, i32 1
  %429 = load i64, i64* %428
; # (run (cdr Exe))
  br label %$97
$97:
  %430 = phi i64 [%429, %$96], [%452, %$106] ; # Prg
  %431 = inttoptr i64 %430 to i64*
  %432 = load i64, i64* %431
  %433 = getelementptr i64, i64* %431, i32 1
  %434 = load i64, i64* %433
  %435 = and i64 %434, 15
  %436 = icmp ne i64 %435, 0
  br i1 %436, label %$100, label %$98
$100:
  %437 = phi i64 [%434, %$97] ; # Prg
  %438 = and i64 %432, 6
  %439 = icmp ne i64 %438, 0
  br i1 %439, label %$103, label %$102
$103:
  br label %$101
$102:
  %440 = and i64 %432, 8
  %441 = icmp ne i64 %440, 0
  br i1 %441, label %$105, label %$104
$105:
  %442 = inttoptr i64 %432 to i64*
  %443 = load i64, i64* %442
  br label %$101
$104:
  %444 = call i64 @evList(i64 %432)
  br label %$101
$101:
  %445 = phi i64 [%432, %$103], [%443, %$105], [%444, %$104] ; # ->
  br label %$99
$98:
  %446 = phi i64 [%434, %$97] ; # Prg
  %447 = and i64 %432, 15
  %448 = icmp eq i64 %447, 0
  br i1 %448, label %$107, label %$106
$107:
  %449 = phi i64 [%446, %$98] ; # Prg
  %450 = call i64 @evList(i64 %432)
  %451 = icmp ne i64 %450, 0
  br label %$106
$106:
  %452 = phi i64 [%446, %$98], [%449, %$107] ; # Prg
  %453 = phi i1 [0, %$98], [%451, %$107] ; # ->
  br label %$97
$99:
  %454 = phi i64 [%437, %$101] ; # Prg
  %455 = phi i64 [%445, %$101] ; # ->
; # (set $Key KeyS $Typ TypS)
  %456 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 144) to i64) to i64*
  store i64 %424, i64* %456
  %457 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 136) to i64) to i64*
  store i64 %422, i64* %457
  br label %$41
$41:
  %458 = phi i64 [%370, %$44], [%417, %$99] ; # X
  %459 = phi i64 [%371, %$44], [%418, %$99] ; # Y
  %460 = phi i64 [%372, %$44], [%419, %$99] ; # P
  %461 = phi i64 [%373, %$44], [%455, %$99] ; # ->
; # (val $Bind)
  %462 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  %463 = load i64, i64* %462
; # (loop (let Sym (val 2 P) (set Sym (val P)) (? (== $At Sym)) (setq...
  br label %$108
$108:
  %464 = phi i64 [%458, %$41], [%474, %$109] ; # X
  %465 = phi i64 [%459, %$41], [%475, %$109] ; # Y
  %466 = phi i64 [%463, %$41], [%479, %$109] ; # P
; # (let Sym (val 2 P) (set Sym (val P)) (? (== $At Sym)) (setq P (va...
; # (val 2 P)
  %467 = inttoptr i64 %466 to i64*
  %468 = getelementptr i64, i64* %467, i32 1
  %469 = load i64, i64* %468
; # (set Sym (val P))
; # (val P)
  %470 = inttoptr i64 %466 to i64*
  %471 = load i64, i64* %470
  %472 = inttoptr i64 %469 to i64*
  store i64 %471, i64* %472
; # (? (== $At Sym))
; # (== $At Sym)
  %473 = icmp eq i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64), %469
  br i1 %473, label %$110, label %$109
$109:
  %474 = phi i64 [%464, %$108] ; # X
  %475 = phi i64 [%465, %$108] ; # Y
  %476 = phi i64 [%466, %$108] ; # P
; # (val 3 P)
  %477 = inttoptr i64 %476 to i64*
  %478 = getelementptr i64, i64* %477, i32 2
  %479 = load i64, i64* %478
  br label %$108
$110:
  %480 = phi i64 [%464, %$108] ; # X
  %481 = phi i64 [%465, %$108] ; # Y
  %482 = phi i64 [%466, %$108] ; # P
  %483 = phi i64 [0, %$108] ; # ->
; # (set $Bind (val 3 P))
; # (val 3 P)
  %484 = inttoptr i64 %482 to i64*
  %485 = getelementptr i64, i64* %484, i32 2
  %486 = load i64, i64* %485
  %487 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %486, i64* %487
  ret i64 %461
}

define i64 @method(i64, i64) align 8 {
$1:
; # (when (pair (val Obj)) (let L @ (while (pair (car L)) (let Y @ (w...
; # (val Obj)
  %2 = inttoptr i64 %0 to i64*
  %3 = load i64, i64* %2
; # (pair (val Obj))
  %4 = and i64 %3, 15
  %5 = icmp eq i64 %4, 0
  br i1 %5, label %$2, label %$3
$2:
; # (let L @ (while (pair (car L)) (let Y @ (when (== Key (car Y)) (r...
; # (while (pair (car L)) (let Y @ (when (== Key (car Y)) (ret (cdr Y...
  br label %$4
$4:
  %6 = phi i64 [%3, %$2], [%26, %$10] ; # L
; # (car L)
  %7 = inttoptr i64 %6 to i64*
  %8 = load i64, i64* %7
; # (pair (car L))
  %9 = and i64 %8, 15
  %10 = icmp eq i64 %9, 0
  br i1 %10, label %$5, label %$6
$5:
  %11 = phi i64 [%6, %$4] ; # L
; # (let Y @ (when (== Key (car Y)) (ret (cdr Y))))
; # (when (== Key (car Y)) (ret (cdr Y)))
; # (car Y)
  %12 = inttoptr i64 %8 to i64*
  %13 = load i64, i64* %12
; # (== Key (car Y))
  %14 = icmp eq i64 %1, %13
  br i1 %14, label %$7, label %$8
$7:
  %15 = phi i64 [%11, %$5] ; # L
; # (cdr Y)
  %16 = inttoptr i64 %8 to i64*
  %17 = getelementptr i64, i64* %16, i32 1
  %18 = load i64, i64* %17
; # (ret (cdr Y))
  ret i64 %18
$8:
  %19 = phi i64 [%11, %$5] ; # L
; # (when (atom (shift L)) (ret 0))
; # (shift L)
  %20 = inttoptr i64 %19 to i64*
  %21 = getelementptr i64, i64* %20, i32 1
  %22 = load i64, i64* %21
; # (atom (shift L))
  %23 = and i64 %22, 15
  %24 = icmp ne i64 %23, 0
  br i1 %24, label %$9, label %$10
$9:
  %25 = phi i64 [%22, %$8] ; # L
; # (ret 0)
  ret i64 0
$10:
  %26 = phi i64 [%22, %$8] ; # L
  br label %$4
$6:
  %27 = phi i64 [%6, %$4] ; # L
; # (stkChk 0)
  %28 = load i8*, i8** @$StkLimit
  %29 = call i8* @llvm.stacksave()
  %30 = icmp ugt i8* %28, %29
  br i1 %30, label %$11, label %$12
$11:
  call void @stkErr(i64 0)
  unreachable
$12:
; # (loop (when (method (car (set $Ret L)) Key) (ret @)) (? (atom (sh...
  br label %$13
$13:
  %31 = phi i64 [%27, %$12], [%43, %$16] ; # L
; # (when (method (car (set $Ret L)) Key) (ret @))
; # (set $Ret L)
  store i64 %31, i64* @$Ret
; # (car (set $Ret L))
  %32 = inttoptr i64 %31 to i64*
  %33 = load i64, i64* %32
; # (method (car (set $Ret L)) Key)
  %34 = call i64 @method(i64 %33, i64 %1)
  %35 = icmp ne i64 %34, 0
  br i1 %35, label %$14, label %$15
$14:
  %36 = phi i64 [%31, %$13] ; # L
; # (ret @)
  ret i64 %34
$15:
  %37 = phi i64 [%31, %$13] ; # L
; # (? (atom (shift L)))
; # (shift L)
  %38 = inttoptr i64 %37 to i64*
  %39 = getelementptr i64, i64* %38, i32 1
  %40 = load i64, i64* %39
; # (atom (shift L))
  %41 = and i64 %40, 15
  %42 = icmp ne i64 %41, 0
  br i1 %42, label %$17, label %$16
$16:
  %43 = phi i64 [%40, %$15] ; # L
  br label %$13
$17:
  %44 = phi i64 [%40, %$15] ; # L
  %45 = phi i64 [0, %$15] ; # ->
  br label %$3
$3:
  ret i64 0
}

define i64 @__Meth(i64, i64) align 8 {
$1:
; # (let (X (cdr Exe) Obj (save (eval (car X)))) (when (sym? (val (ta...
; # (cdr Exe)
  %2 = inttoptr i64 %0 to i64*
  %3 = getelementptr i64, i64* %2, i32 1
  %4 = load i64, i64* %3
; # (car X)
  %5 = inttoptr i64 %4 to i64*
  %6 = load i64, i64* %5
; # (eval (car X))
  %7 = and i64 %6, 6
  %8 = icmp ne i64 %7, 0
  br i1 %8, label %$4, label %$3
$4:
  br label %$2
$3:
  %9 = and i64 %6, 8
  %10 = icmp ne i64 %9, 0
  br i1 %10, label %$6, label %$5
$6:
  %11 = inttoptr i64 %6 to i64*
  %12 = load i64, i64* %11
  br label %$2
$5:
  %13 = call i64 @evList(i64 %6)
  br label %$2
$2:
  %14 = phi i64 [%6, %$4], [%12, %$6], [%13, %$5] ; # ->
; # (save (eval (car X)))
  %15 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %16 = load i64, i64* %15
  %17 = alloca i64, i64 2, align 16
  %18 = ptrtoint i64* %17 to i64
  %19 = inttoptr i64 %18 to i64*
  store i64 %14, i64* %19
  %20 = add i64 %18, 8
  %21 = inttoptr i64 %20 to i64*
  store i64 %16, i64* %21
  %22 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %18, i64* %22
; # (when (sym? (val (tail (needSymb Exe Obj)))) (dbFetch Exe Obj))
; # (needSymb Exe Obj)
  %23 = xor i64 %14, 8
  %24 = and i64 %23, 14
  %25 = icmp eq i64 %24, 0
  br i1 %25, label %$8, label %$7
$7:
  call void @symErr(i64 %0, i64 %14)
  unreachable
$8:
; # (tail (needSymb Exe Obj))
  %26 = add i64 %14, -8
; # (val (tail (needSymb Exe Obj)))
  %27 = inttoptr i64 %26 to i64*
  %28 = load i64, i64* %27
; # (sym? (val (tail (needSymb Exe Obj))))
  %29 = and i64 %28, 8
  %30 = icmp ne i64 %29, 0
  br i1 %30, label %$9, label %$10
$9:
; # (dbFetch Exe Obj)
  call void @dbFetch(i64 %0, i64 %14)
  br label %$10
$10:
; # (set $Ret 0)
  store i64 0, i64* @$Ret
; # (if (method Obj Key) (evMethod Obj (val $Ret) Key @ (cdr X)) (err...
; # (method Obj Key)
  %31 = call i64 @method(i64 %14, i64 %1)
  %32 = icmp ne i64 %31, 0
  br i1 %32, label %$11, label %$12
$11:
; # (val $Ret)
  %33 = load i64, i64* @$Ret
; # (cdr X)
  %34 = inttoptr i64 %4 to i64*
  %35 = getelementptr i64, i64* %34, i32 1
  %36 = load i64, i64* %35
; # (evMethod Obj (val $Ret) Key @ (cdr X))
  %37 = call i64 @evMethod(i64 %14, i64 %33, i64 %1, i64 %31, i64 %36)
  br label %$13
$12:
; # (err Exe Key ($ "Bad message") null)
  call void @err(i64 %0, i64 %1, i8* bitcast ([12 x i8]* @$73 to i8*), i8* null)
  unreachable
$13:
  %38 = phi i64 [%37, %$11] ; # ->
; # (drop *Safe)
  %39 = inttoptr i64 %18 to i64*
  %40 = getelementptr i64, i64* %39, i32 1
  %41 = load i64, i64* %40
  %42 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %41, i64* %42
  ret i64 %38
}

define i64 @_Box(i64) align 8 {
$1:
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (consSym ZERO (eval (cadr Exe)))
  %14 = call i64 @consSym(i64 2, i64 %13)
  ret i64 %14
}

define i64 @_New(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (eval (++ X)) Obj (save (cond ((pair Y) (cons...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (cond ((pair Y) (consSym ZERO Y)) ((nil? Y) (consSym ZERO ZERO)) ...
; # (pair Y)
  %16 = and i64 %15, 15
  %17 = icmp eq i64 %16, 0
  br i1 %17, label %$9, label %$8
$9:
  %18 = phi i64 [%7, %$2] ; # X
; # (consSym ZERO Y)
  %19 = call i64 @consSym(i64 2, i64 %15)
  br label %$7
$8:
  %20 = phi i64 [%7, %$2] ; # X
; # (nil? Y)
  %21 = icmp eq i64 %15, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %21, label %$11, label %$10
$11:
  %22 = phi i64 [%20, %$8] ; # X
; # (consSym ZERO ZERO)
  %23 = call i64 @consSym(i64 2, i64 2)
  br label %$7
$10:
  %24 = phi i64 [%20, %$8] ; # X
; # (or (t? Y) (num? Y))
; # (t? Y)
  %25 = icmp eq i64 %15, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %25, label %$12, label %$13
$13:
  %26 = phi i64 [%24, %$10] ; # X
; # (num? Y)
  %27 = and i64 %15, 6
  %28 = icmp ne i64 %27, 0
  br label %$12
$12:
  %29 = phi i64 [%24, %$10], [%26, %$13] ; # X
  %30 = phi i1 [1, %$10], [%28, %$13] ; # ->
  br i1 %30, label %$15, label %$14
$15:
  %31 = phi i64 [%29, %$12] ; # X
; # (let Nm (newId Exe (if (num? Y) (i32 (int @)) 1)) (prog1 (extern ...
; # (if (num? Y) (i32 (int @)) 1)
; # (num? Y)
  %32 = and i64 %15, 6
  %33 = icmp ne i64 %32, 0
  br i1 %33, label %$16, label %$17
$16:
  %34 = phi i64 [%31, %$15] ; # X
; # (int @)
  %35 = lshr i64 %15, 4
; # (i32 (int @))
  %36 = trunc i64 %35 to i32
  br label %$18
$17:
  %37 = phi i64 [%31, %$15] ; # X
  br label %$18
$18:
  %38 = phi i64 [%34, %$16], [%37, %$17] ; # X
  %39 = phi i32 [%36, %$16], [1, %$17] ; # ->
; # (newId Exe (if (num? Y) (i32 (int @)) 1))
  %40 = call i64 @newId(i64 %0, i32 %39)
; # (prog1 (extern Nm) (set (tail @) (sign (shr 1 (add Nm Nm) 1))))
; # (extern Nm)
  %41 = call i64 @extern(i64 %40)
; # (set (tail @) (sign (shr 1 (add Nm Nm) 1)))
; # (tail @)
  %42 = add i64 %41, -8
; # (add Nm Nm)
  %43 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %40, i64 %40)
  %44 = extractvalue {i64, i1} %43, 1
  %45 = extractvalue {i64, i1} %43, 0
; # (shr 1 (add Nm Nm) 1)
  %46 = call i64 @llvm.fshr.i64(i64 1, i64 %45, i64 1)
; # (sign (shr 1 (add Nm Nm) 1))
  %47 = or i64 %46, 8
  %48 = inttoptr i64 %42 to i64*
  store i64 %47, i64* %48
  br label %$7
$14:
  %49 = phi i64 [%29, %$12] ; # X
  br label %$7
$7:
  %50 = phi i64 [%18, %$9], [%22, %$11], [%38, %$18], [%49, %$14] ; # X
  %51 = phi i64 [%19, %$9], [%23, %$11], [%41, %$18], [%15, %$14] ; # ->
; # (save (cond ((pair Y) (consSym ZERO Y)) ((nil? Y) (consSym ZERO Z...
  %52 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %53 = load i64, i64* %52
  %54 = alloca i64, i64 2, align 16
  %55 = ptrtoint i64* %54 to i64
  %56 = inttoptr i64 %55 to i64*
  store i64 %51, i64* %56
  %57 = add i64 %55, 8
  %58 = inttoptr i64 %57 to i64*
  store i64 %53, i64* %58
  %59 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %55, i64* %59
; # (unless (pair Y) (set Obj (eval (++ X))))
; # (pair Y)
  %60 = and i64 %15, 15
  %61 = icmp eq i64 %60, 0
  br i1 %61, label %$20, label %$19
$19:
  %62 = phi i64 [%50, %$7] ; # X
; # (set Obj (eval (++ X)))
; # (++ X)
  %63 = inttoptr i64 %62 to i64*
  %64 = load i64, i64* %63
  %65 = getelementptr i64, i64* %63, i32 1
  %66 = load i64, i64* %65
; # (eval (++ X))
  %67 = and i64 %64, 6
  %68 = icmp ne i64 %67, 0
  br i1 %68, label %$23, label %$22
$23:
  br label %$21
$22:
  %69 = and i64 %64, 8
  %70 = icmp ne i64 %69, 0
  br i1 %70, label %$25, label %$24
$25:
  %71 = inttoptr i64 %64 to i64*
  %72 = load i64, i64* %71
  br label %$21
$24:
  %73 = call i64 @evList(i64 %64)
  br label %$21
$21:
  %74 = phi i64 [%64, %$23], [%72, %$25], [%73, %$24] ; # ->
  %75 = inttoptr i64 %51 to i64*
  store i64 %74, i64* %75
  br label %$20
$20:
  %76 = phi i64 [%50, %$7], [%66, %$21] ; # X
; # (set $Ret 0)
  store i64 0, i64* @$Ret
; # (cond ((method Obj $T) (evMethod Obj (val $Ret) $T @ X)) ((pair X...
; # (method Obj $T)
  %77 = call i64 @method(i64 %51, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64))
  %78 = icmp ne i64 %77, 0
  br i1 %78, label %$28, label %$27
$28:
  %79 = phi i64 [%76, %$20] ; # X
; # (val $Ret)
  %80 = load i64, i64* @$Ret
; # (evMethod Obj (val $Ret) $T @ X)
  %81 = call i64 @evMethod(i64 %51, i64 %80, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), i64 %77, i64 %79)
  br label %$26
$27:
  %82 = phi i64 [%76, %$20] ; # X
; # (pair X)
  %83 = and i64 %82, 15
  %84 = icmp eq i64 %83, 0
  br i1 %84, label %$30, label %$29
$30:
  %85 = phi i64 [%82, %$27] ; # X
; # (let K (link (push NIL NIL)) (loop (when (== ZERO (set K (eval (+...
; # (push NIL NIL)
  %86 = alloca i64, i64 2, align 16
  %87 = ptrtoint i64* %86 to i64
; # (link (push NIL NIL))
  %88 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %89 = load i64, i64* %88
  %90 = inttoptr i64 %87 to i64*
  %91 = getelementptr i64, i64* %90, i32 1
  store i64 %89, i64* %91
  %92 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %87, i64* %92
; # (loop (when (== ZERO (set K (eval (++ X)))) (argErr Exe ZERO)) (p...
  br label %$31
$31:
  %93 = phi i64 [%85, %$30], [%126, %$44] ; # X
; # (when (== ZERO (set K (eval (++ X)))) (argErr Exe ZERO))
; # (set K (eval (++ X)))
; # (++ X)
  %94 = inttoptr i64 %93 to i64*
  %95 = load i64, i64* %94
  %96 = getelementptr i64, i64* %94, i32 1
  %97 = load i64, i64* %96
; # (eval (++ X))
  %98 = and i64 %95, 6
  %99 = icmp ne i64 %98, 0
  br i1 %99, label %$34, label %$33
$34:
  br label %$32
$33:
  %100 = and i64 %95, 8
  %101 = icmp ne i64 %100, 0
  br i1 %101, label %$36, label %$35
$36:
  %102 = inttoptr i64 %95 to i64*
  %103 = load i64, i64* %102
  br label %$32
$35:
  %104 = call i64 @evList(i64 %95)
  br label %$32
$32:
  %105 = phi i64 [%95, %$34], [%103, %$36], [%104, %$35] ; # ->
  %106 = inttoptr i64 %87 to i64*
  store i64 %105, i64* %106
; # (== ZERO (set K (eval (++ X))))
  %107 = icmp eq i64 2, %105
  br i1 %107, label %$37, label %$38
$37:
  %108 = phi i64 [%97, %$32] ; # X
; # (argErr Exe ZERO)
  call void @argErr(i64 %0, i64 2)
  unreachable
$38:
  %109 = phi i64 [%97, %$32] ; # X
; # (val K)
  %110 = inttoptr i64 %87 to i64*
  %111 = load i64, i64* %110
; # (++ X)
  %112 = inttoptr i64 %109 to i64*
  %113 = load i64, i64* %112
  %114 = getelementptr i64, i64* %112, i32 1
  %115 = load i64, i64* %114
; # (eval (++ X))
  %116 = and i64 %113, 6
  %117 = icmp ne i64 %116, 0
  br i1 %117, label %$41, label %$40
$41:
  br label %$39
$40:
  %118 = and i64 %113, 8
  %119 = icmp ne i64 %118, 0
  br i1 %119, label %$43, label %$42
$43:
  %120 = inttoptr i64 %113 to i64*
  %121 = load i64, i64* %120
  br label %$39
$42:
  %122 = call i64 @evList(i64 %113)
  br label %$39
$39:
  %123 = phi i64 [%113, %$41], [%121, %$43], [%122, %$42] ; # ->
; # (put Obj (val K) (eval (++ X)))
  call void @put(i64 %51, i64 %111, i64 %123)
; # (? (atom X))
; # (atom X)
  %124 = and i64 %115, 15
  %125 = icmp ne i64 %124, 0
  br i1 %125, label %$45, label %$44
$44:
  %126 = phi i64 [%115, %$39] ; # X
  br label %$31
$45:
  %127 = phi i64 [%115, %$39] ; # X
  %128 = phi i64 [0, %$39] ; # ->
  br label %$26
$29:
  %129 = phi i64 [%82, %$27] ; # X
  br label %$26
$26:
  %130 = phi i64 [%79, %$28], [%127, %$45], [%129, %$29] ; # X
  %131 = phi i64 [%81, %$28], [%128, %$45], [0, %$29] ; # ->
; # (drop *Safe)
  %132 = inttoptr i64 %55 to i64*
  %133 = getelementptr i64, i64* %132, i32 1
  %134 = load i64, i64* %133
  %135 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %134, i64* %135
  ret i64 %51
}

define i64 @_Type(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (eval (car X))) (ifn (symb? Y) $Nil (when (sy...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (car X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (car X))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (ifn (symb? Y) $Nil (when (sym? (val (tail Y))) (dbFetch Exe Y)) ...
; # (symb? Y)
  %14 = xor i64 %13, 8
  %15 = and i64 %14, 14
  %16 = icmp eq i64 %15, 0
  br i1 %16, label %$8, label %$7
$7:
  br label %$9
$8:
; # (when (sym? (val (tail Y))) (dbFetch Exe Y))
; # (tail Y)
  %17 = add i64 %13, -8
; # (val (tail Y))
  %18 = inttoptr i64 %17 to i64*
  %19 = load i64, i64* %18
; # (sym? (val (tail Y)))
  %20 = and i64 %19, 8
  %21 = icmp ne i64 %20, 0
  br i1 %21, label %$10, label %$11
$10:
; # (dbFetch Exe Y)
  call void @dbFetch(i64 %0, i64 %13)
  br label %$11
$11:
; # (let (V (val Y) Z V) (loop (? (atom V) $Nil) (? (atom (car V)) (l...
; # (val Y)
  %22 = inttoptr i64 %13 to i64*
  %23 = load i64, i64* %22
; # (loop (? (atom V) $Nil) (? (atom (car V)) (let R V (loop (? (not ...
  br label %$12
$12:
  %24 = phi i64 [%23, %$11], [%66, %$29] ; # V
; # (? (atom V) $Nil)
; # (atom V)
  %25 = and i64 %24, 15
  %26 = icmp ne i64 %25, 0
  br i1 %26, label %$15, label %$13
$15:
  %27 = phi i64 [%24, %$12] ; # V
  br label %$14
$13:
  %28 = phi i64 [%24, %$12] ; # V
; # (? (atom (car V)) (let R V (loop (? (not (symb? (car V))) $Nil) (...
; # (car V)
  %29 = inttoptr i64 %28 to i64*
  %30 = load i64, i64* %29
; # (atom (car V))
  %31 = and i64 %30, 15
  %32 = icmp ne i64 %31, 0
  br i1 %32, label %$17, label %$16
$17:
  %33 = phi i64 [%28, %$13] ; # V
; # (let R V (loop (? (not (symb? (car V))) $Nil) (? (atom (shift V))...
; # (loop (? (not (symb? (car V))) $Nil) (? (atom (shift V)) (if (nil...
  br label %$18
$18:
  %34 = phi i64 [%33, %$17], [%57, %$27] ; # V
; # (? (not (symb? (car V))) $Nil)
; # (car V)
  %35 = inttoptr i64 %34 to i64*
  %36 = load i64, i64* %35
; # (symb? (car V))
  %37 = xor i64 %36, 8
  %38 = and i64 %37, 14
  %39 = icmp eq i64 %38, 0
; # (not (symb? (car V)))
  %40 = icmp eq i1 %39, 0
  br i1 %40, label %$21, label %$19
$21:
  %41 = phi i64 [%34, %$18] ; # V
  br label %$20
$19:
  %42 = phi i64 [%34, %$18] ; # V
; # (? (atom (shift V)) (if (nil? V) R $Nil))
; # (shift V)
  %43 = inttoptr i64 %42 to i64*
  %44 = getelementptr i64, i64* %43, i32 1
  %45 = load i64, i64* %44
; # (atom (shift V))
  %46 = and i64 %45, 15
  %47 = icmp ne i64 %46, 0
  br i1 %47, label %$23, label %$22
$23:
  %48 = phi i64 [%45, %$19] ; # V
; # (if (nil? V) R $Nil)
; # (nil? V)
  %49 = icmp eq i64 %48, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %49, label %$24, label %$25
$24:
  %50 = phi i64 [%48, %$23] ; # V
  br label %$26
$25:
  %51 = phi i64 [%48, %$23] ; # V
  br label %$26
$26:
  %52 = phi i64 [%50, %$24], [%51, %$25] ; # V
  %53 = phi i64 [%33, %$24], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$25] ; # ->
  br label %$20
$22:
  %54 = phi i64 [%45, %$19] ; # V
; # (? (== Z V) $Nil)
; # (== Z V)
  %55 = icmp eq i64 %23, %54
  br i1 %55, label %$28, label %$27
$28:
  %56 = phi i64 [%54, %$22] ; # V
  br label %$20
$27:
  %57 = phi i64 [%54, %$22] ; # V
  br label %$18
$20:
  %58 = phi i64 [%41, %$21], [%52, %$26], [%56, %$28] ; # V
  %59 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$21], [%53, %$26], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$28] ; # ->
  br label %$14
$16:
  %60 = phi i64 [%28, %$13] ; # V
; # (? (== Z (shift V)) $Nil)
; # (shift V)
  %61 = inttoptr i64 %60 to i64*
  %62 = getelementptr i64, i64* %61, i32 1
  %63 = load i64, i64* %62
; # (== Z (shift V))
  %64 = icmp eq i64 %23, %63
  br i1 %64, label %$30, label %$29
$30:
  %65 = phi i64 [%63, %$16] ; # V
  br label %$14
$29:
  %66 = phi i64 [%63, %$16] ; # V
  br label %$12
$14:
  %67 = phi i64 [%27, %$15], [%58, %$20], [%65, %$30] ; # V
  %68 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$15], [%59, %$20], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$30] ; # ->
  br label %$9
$9:
  %69 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$7], [%68, %$14] ; # ->
  ret i64 %69
}

define i1 @isa(i64, i64) align 8 {
$1:
; # (let (V (val Obj) Z V) (loop (? (atom V) NO) (? (atom (car V)) (s...
; # (val Obj)
  %2 = inttoptr i64 %1 to i64*
  %3 = load i64, i64* %2
; # (loop (? (atom V) NO) (? (atom (car V)) (stkChk 0) (loop (? (not ...
  br label %$2
$2:
  %4 = phi i64 [%3, %$1], [%50, %$22] ; # V
; # (? (atom V) NO)
; # (atom V)
  %5 = and i64 %4, 15
  %6 = icmp ne i64 %5, 0
  br i1 %6, label %$5, label %$3
$5:
  %7 = phi i64 [%4, %$2] ; # V
  br label %$4
$3:
  %8 = phi i64 [%4, %$2] ; # V
; # (? (atom (car V)) (stkChk 0) (loop (? (not (symb? (car V))) NO) (...
; # (car V)
  %9 = inttoptr i64 %8 to i64*
  %10 = load i64, i64* %9
; # (atom (car V))
  %11 = and i64 %10, 15
  %12 = icmp ne i64 %11, 0
  br i1 %12, label %$7, label %$6
$7:
  %13 = phi i64 [%8, %$3] ; # V
; # (stkChk 0)
  %14 = load i8*, i8** @$StkLimit
  %15 = call i8* @llvm.stacksave()
  %16 = icmp ugt i8* %14, %15
  br i1 %16, label %$8, label %$9
$8:
  call void @stkErr(i64 0)
  unreachable
$9:
; # (loop (? (not (symb? (car V))) NO) (? (== @ Cls) YES) (? (isa Cls...
  br label %$10
$10:
  %17 = phi i64 [%13, %$9], [%41, %$20] ; # V
; # (? (not (symb? (car V))) NO)
; # (car V)
  %18 = inttoptr i64 %17 to i64*
  %19 = load i64, i64* %18
; # (symb? (car V))
  %20 = xor i64 %19, 8
  %21 = and i64 %20, 14
  %22 = icmp eq i64 %21, 0
; # (not (symb? (car V)))
  %23 = icmp eq i1 %22, 0
  br i1 %23, label %$13, label %$11
$13:
  %24 = phi i64 [%17, %$10] ; # V
  br label %$12
$11:
  %25 = phi i64 [%17, %$10] ; # V
; # (? (== @ Cls) YES)
; # (== @ Cls)
  %26 = icmp eq i64 %19, %0
  br i1 %26, label %$15, label %$14
$15:
  %27 = phi i64 [%25, %$11] ; # V
  br label %$12
$14:
  %28 = phi i64 [%25, %$11] ; # V
; # (? (isa Cls @) YES)
; # (isa Cls @)
  %29 = call i1 @isa(i64 %0, i64 %19)
  br i1 %29, label %$17, label %$16
$17:
  %30 = phi i64 [%28, %$14] ; # V
  br label %$12
$16:
  %31 = phi i64 [%28, %$14] ; # V
; # (? (atom (shift V)) NO)
; # (shift V)
  %32 = inttoptr i64 %31 to i64*
  %33 = getelementptr i64, i64* %32, i32 1
  %34 = load i64, i64* %33
; # (atom (shift V))
  %35 = and i64 %34, 15
  %36 = icmp ne i64 %35, 0
  br i1 %36, label %$19, label %$18
$19:
  %37 = phi i64 [%34, %$16] ; # V
  br label %$12
$18:
  %38 = phi i64 [%34, %$16] ; # V
; # (? (== Z V) NO)
; # (== Z V)
  %39 = icmp eq i64 %3, %38
  br i1 %39, label %$21, label %$20
$21:
  %40 = phi i64 [%38, %$18] ; # V
  br label %$12
$20:
  %41 = phi i64 [%38, %$18] ; # V
  br label %$10
$12:
  %42 = phi i64 [%24, %$13], [%27, %$15], [%30, %$17], [%37, %$19], [%40, %$21] ; # V
  %43 = phi i1 [0, %$13], [1, %$15], [1, %$17], [0, %$19], [0, %$21] ; # ->
  br label %$4
$6:
  %44 = phi i64 [%8, %$3] ; # V
; # (? (== Z (shift V)) NO)
; # (shift V)
  %45 = inttoptr i64 %44 to i64*
  %46 = getelementptr i64, i64* %45, i32 1
  %47 = load i64, i64* %46
; # (== Z (shift V))
  %48 = icmp eq i64 %3, %47
  br i1 %48, label %$23, label %$22
$23:
  %49 = phi i64 [%47, %$6] ; # V
  br label %$4
$22:
  %50 = phi i64 [%47, %$6] ; # V
  br label %$2
$4:
  %51 = phi i64 [%7, %$5], [%42, %$12], [%49, %$23] ; # V
  %52 = phi i1 [0, %$5], [%43, %$12], [0, %$23] ; # ->
  ret i1 %52
}

define i64 @_Isa(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (save (eval (++ X))) Z (eval (car X))) (ifn (...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (save (eval (++ X)))
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %17 = load i64, i64* %16
  %18 = alloca i64, i64 2, align 16
  %19 = ptrtoint i64* %18 to i64
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = add i64 %19, 8
  %22 = inttoptr i64 %21 to i64*
  store i64 %17, i64* %22
  %23 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %19, i64* %23
; # (car X)
  %24 = inttoptr i64 %7 to i64*
  %25 = load i64, i64* %24
; # (eval (car X))
  %26 = and i64 %25, 6
  %27 = icmp ne i64 %26, 0
  br i1 %27, label %$9, label %$8
$9:
  br label %$7
$8:
  %28 = and i64 %25, 8
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %$11, label %$10
$11:
  %30 = inttoptr i64 %25 to i64*
  %31 = load i64, i64* %30
  br label %$7
$10:
  %32 = call i64 @evList(i64 %25)
  br label %$7
$7:
  %33 = phi i64 [%25, %$9], [%31, %$11], [%32, %$10] ; # ->
; # (ifn (symb? Z) $Nil (when (sym? (val (tail Z))) (dbFetch Exe Z)) ...
; # (symb? Z)
  %34 = xor i64 %33, 8
  %35 = and i64 %34, 14
  %36 = icmp eq i64 %35, 0
  br i1 %36, label %$13, label %$12
$12:
  %37 = phi i64 [%15, %$7] ; # Y
  br label %$14
$13:
  %38 = phi i64 [%15, %$7] ; # Y
; # (when (sym? (val (tail Z))) (dbFetch Exe Z))
; # (tail Z)
  %39 = add i64 %33, -8
; # (val (tail Z))
  %40 = inttoptr i64 %39 to i64*
  %41 = load i64, i64* %40
; # (sym? (val (tail Z)))
  %42 = and i64 %41, 8
  %43 = icmp ne i64 %42, 0
  br i1 %43, label %$15, label %$16
$15:
  %44 = phi i64 [%38, %$13] ; # Y
; # (dbFetch Exe Z)
  call void @dbFetch(i64 %0, i64 %33)
  br label %$16
$16:
  %45 = phi i64 [%38, %$13], [%44, %$15] ; # Y
; # (cond ((pair Y) (loop (? (not (isa (car Y) Z)) $Nil) (? (atom (sh...
; # (pair Y)
  %46 = and i64 %45, 15
  %47 = icmp eq i64 %46, 0
  br i1 %47, label %$19, label %$18
$19:
  %48 = phi i64 [%45, %$16] ; # Y
; # (loop (? (not (isa (car Y) Z)) $Nil) (? (atom (shift Y)) Z))
  br label %$20
$20:
  %49 = phi i64 [%48, %$19], [%62, %$24] ; # Y
; # (? (not (isa (car Y) Z)) $Nil)
; # (car Y)
  %50 = inttoptr i64 %49 to i64*
  %51 = load i64, i64* %50
; # (isa (car Y) Z)
  %52 = call i1 @isa(i64 %51, i64 %33)
; # (not (isa (car Y) Z))
  %53 = icmp eq i1 %52, 0
  br i1 %53, label %$23, label %$21
$23:
  %54 = phi i64 [%49, %$20] ; # Y
  br label %$22
$21:
  %55 = phi i64 [%49, %$20] ; # Y
; # (? (atom (shift Y)) Z)
; # (shift Y)
  %56 = inttoptr i64 %55 to i64*
  %57 = getelementptr i64, i64* %56, i32 1
  %58 = load i64, i64* %57
; # (atom (shift Y))
  %59 = and i64 %58, 15
  %60 = icmp ne i64 %59, 0
  br i1 %60, label %$25, label %$24
$25:
  %61 = phi i64 [%58, %$21] ; # Y
  br label %$22
$24:
  %62 = phi i64 [%58, %$21] ; # Y
  br label %$20
$22:
  %63 = phi i64 [%54, %$23], [%61, %$25] ; # Y
  %64 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$23], [%33, %$25] ; # ->
  br label %$17
$18:
  %65 = phi i64 [%45, %$16] ; # Y
; # (isa Y Z)
  %66 = call i1 @isa(i64 %65, i64 %33)
  br i1 %66, label %$27, label %$26
$27:
  %67 = phi i64 [%65, %$18] ; # Y
  br label %$17
$26:
  %68 = phi i64 [%65, %$18] ; # Y
  br label %$17
$17:
  %69 = phi i64 [%63, %$22], [%67, %$27], [%68, %$26] ; # Y
  %70 = phi i64 [%64, %$22], [%33, %$27], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$26] ; # ->
  br label %$14
$14:
  %71 = phi i64 [%37, %$12], [%69, %$17] ; # Y
  %72 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$12], [%70, %$17] ; # ->
; # (drop *Safe)
  %73 = inttoptr i64 %19 to i64*
  %74 = getelementptr i64, i64* %73, i32 1
  %75 = load i64, i64* %74
  %76 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %75, i64* %76
  ret i64 %72
}

define i64 @_Method(i64) align 8 {
$1:
; # (let (X (cdr Exe) Msg (save (eval (++ X))) Obj (needSymb Exe (eva...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (save (eval (++ X)))
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %17 = load i64, i64* %16
  %18 = alloca i64, i64 2, align 16
  %19 = ptrtoint i64* %18 to i64
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = add i64 %19, 8
  %22 = inttoptr i64 %21 to i64*
  store i64 %17, i64* %22
  %23 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %19, i64* %23
; # (car X)
  %24 = inttoptr i64 %7 to i64*
  %25 = load i64, i64* %24
; # (eval (car X))
  %26 = and i64 %25, 6
  %27 = icmp ne i64 %26, 0
  br i1 %27, label %$9, label %$8
$9:
  br label %$7
$8:
  %28 = and i64 %25, 8
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %$11, label %$10
$11:
  %30 = inttoptr i64 %25 to i64*
  %31 = load i64, i64* %30
  br label %$7
$10:
  %32 = call i64 @evList(i64 %25)
  br label %$7
$7:
  %33 = phi i64 [%25, %$9], [%31, %$11], [%32, %$10] ; # ->
; # (needSymb Exe (eval (car X)))
  %34 = xor i64 %33, 8
  %35 = and i64 %34, 14
  %36 = icmp eq i64 %35, 0
  br i1 %36, label %$13, label %$12
$12:
  call void @symErr(i64 %0, i64 %33)
  unreachable
$13:
; # (when (sym? (val (tail Obj))) (dbFetch Exe Obj))
; # (tail Obj)
  %37 = add i64 %33, -8
; # (val (tail Obj))
  %38 = inttoptr i64 %37 to i64*
  %39 = load i64, i64* %38
; # (sym? (val (tail Obj)))
  %40 = and i64 %39, 8
  %41 = icmp ne i64 %40, 0
  br i1 %41, label %$14, label %$15
$14:
; # (dbFetch Exe Obj)
  call void @dbFetch(i64 %0, i64 %33)
  br label %$15
$15:
; # (if (method Obj Msg) @ $Nil)
; # (method Obj Msg)
  %42 = call i64 @method(i64 %33, i64 %15)
  %43 = icmp ne i64 %42, 0
  br i1 %43, label %$16, label %$17
$16:
  br label %$18
$17:
  br label %$18
$18:
  %44 = phi i64 [%42, %$16], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$17] ; # ->
; # (drop *Safe)
  %45 = inttoptr i64 %19 to i64*
  %46 = getelementptr i64, i64* %45, i32 1
  %47 = load i64, i64* %46
  %48 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %47, i64* %48
  ret i64 %44
}

define i64 @_Send(i64) align 8 {
$1:
; # (let (X (cdr Exe) Msg (save (eval (++ X))) Obj (save (needSymb Ex...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (save (eval (++ X)))
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %17 = load i64, i64* %16
  %18 = alloca i64, i64 2, align 16
  %19 = ptrtoint i64* %18 to i64
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = add i64 %19, 8
  %22 = inttoptr i64 %21 to i64*
  store i64 %17, i64* %22
  %23 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %19, i64* %23
; # (car X)
  %24 = inttoptr i64 %7 to i64*
  %25 = load i64, i64* %24
; # (eval (car X))
  %26 = and i64 %25, 6
  %27 = icmp ne i64 %26, 0
  br i1 %27, label %$9, label %$8
$9:
  br label %$7
$8:
  %28 = and i64 %25, 8
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %$11, label %$10
$11:
  %30 = inttoptr i64 %25 to i64*
  %31 = load i64, i64* %30
  br label %$7
$10:
  %32 = call i64 @evList(i64 %25)
  br label %$7
$7:
  %33 = phi i64 [%25, %$9], [%31, %$11], [%32, %$10] ; # ->
; # (needSymb Exe (eval (car X)))
  %34 = xor i64 %33, 8
  %35 = and i64 %34, 14
  %36 = icmp eq i64 %35, 0
  br i1 %36, label %$13, label %$12
$12:
  call void @symErr(i64 %0, i64 %33)
  unreachable
$13:
; # (save (needSymb Exe (eval (car X))))
  %37 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %38 = load i64, i64* %37
  %39 = alloca i64, i64 2, align 16
  %40 = ptrtoint i64* %39 to i64
  %41 = inttoptr i64 %40 to i64*
  store i64 %33, i64* %41
  %42 = add i64 %40, 8
  %43 = inttoptr i64 %42 to i64*
  store i64 %38, i64* %43
  %44 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %40, i64* %44
; # (when (sym? (val (tail Obj))) (dbFetch Exe Obj))
; # (tail Obj)
  %45 = add i64 %33, -8
; # (val (tail Obj))
  %46 = inttoptr i64 %45 to i64*
  %47 = load i64, i64* %46
; # (sym? (val (tail Obj)))
  %48 = and i64 %47, 8
  %49 = icmp ne i64 %48, 0
  br i1 %49, label %$14, label %$15
$14:
; # (dbFetch Exe Obj)
  call void @dbFetch(i64 %0, i64 %33)
  br label %$15
$15:
; # (set $Ret 0)
  store i64 0, i64* @$Ret
; # (if (method Obj Msg) (evMethod Obj (val $Ret) Msg @ (cdr X)) (err...
; # (method Obj Msg)
  %50 = call i64 @method(i64 %33, i64 %15)
  %51 = icmp ne i64 %50, 0
  br i1 %51, label %$16, label %$17
$16:
; # (val $Ret)
  %52 = load i64, i64* @$Ret
; # (cdr X)
  %53 = inttoptr i64 %7 to i64*
  %54 = getelementptr i64, i64* %53, i32 1
  %55 = load i64, i64* %54
; # (evMethod Obj (val $Ret) Msg @ (cdr X))
  %56 = call i64 @evMethod(i64 %33, i64 %52, i64 %15, i64 %50, i64 %55)
  br label %$18
$17:
; # (err Exe Msg ($ "Bad message") null)
  call void @err(i64 %0, i64 %15, i8* bitcast ([12 x i8]* @$73 to i8*), i8* null)
  unreachable
$18:
  %57 = phi i64 [%56, %$16] ; # ->
; # (drop *Safe)
  %58 = inttoptr i64 %19 to i64*
  %59 = getelementptr i64, i64* %58, i32 1
  %60 = load i64, i64* %59
  %61 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %60, i64* %61
  ret i64 %57
}

define i64 @_Try(i64) align 8 {
$1:
; # (let (X (cdr Exe) Msg (save (eval (++ X))) Obj (save (eval (car X...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (save (eval (++ X)))
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %17 = load i64, i64* %16
  %18 = alloca i64, i64 2, align 16
  %19 = ptrtoint i64* %18 to i64
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = add i64 %19, 8
  %22 = inttoptr i64 %21 to i64*
  store i64 %17, i64* %22
  %23 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %19, i64* %23
; # (car X)
  %24 = inttoptr i64 %7 to i64*
  %25 = load i64, i64* %24
; # (eval (car X))
  %26 = and i64 %25, 6
  %27 = icmp ne i64 %26, 0
  br i1 %27, label %$9, label %$8
$9:
  br label %$7
$8:
  %28 = and i64 %25, 8
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %$11, label %$10
$11:
  %30 = inttoptr i64 %25 to i64*
  %31 = load i64, i64* %30
  br label %$7
$10:
  %32 = call i64 @evList(i64 %25)
  br label %$7
$7:
  %33 = phi i64 [%25, %$9], [%31, %$11], [%32, %$10] ; # ->
; # (save (eval (car X)))
  %34 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %35 = load i64, i64* %34
  %36 = alloca i64, i64 2, align 16
  %37 = ptrtoint i64* %36 to i64
  %38 = inttoptr i64 %37 to i64*
  store i64 %33, i64* %38
  %39 = add i64 %37, 8
  %40 = inttoptr i64 %39 to i64*
  store i64 %35, i64* %40
  %41 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %37, i64* %41
; # (ifn (symb? Obj) $Nil (when (sym? (val (tail Obj))) (unless (isLi...
; # (symb? Obj)
  %42 = xor i64 %33, 8
  %43 = and i64 %42, 14
  %44 = icmp eq i64 %43, 0
  br i1 %44, label %$13, label %$12
$12:
  br label %$14
$13:
; # (when (sym? (val (tail Obj))) (unless (isLife Obj) (goto 1)) (dbF...
; # (tail Obj)
  %45 = add i64 %33, -8
; # (val (tail Obj))
  %46 = inttoptr i64 %45 to i64*
  %47 = load i64, i64* %46
; # (sym? (val (tail Obj)))
  %48 = and i64 %47, 8
  %49 = icmp ne i64 %48, 0
  br i1 %49, label %$15, label %$16
$15:
; # (unless (isLife Obj) (goto 1))
; # (isLife Obj)
  %50 = call i1 @isLife(i64 %33)
  br i1 %50, label %$18, label %$17
$17:
; # (goto 1)
  br label %$-1
$18:
; # (dbFetch Exe Obj)
  call void @dbFetch(i64 %0, i64 %33)
  br label %$16
$16:
; # (set $Ret 0)
  store i64 0, i64* @$Ret
; # (if (method Obj Msg) (evMethod Obj (val $Ret) Msg @ (cdr X)) (: 1...
; # (method Obj Msg)
  %51 = call i64 @method(i64 %33, i64 %15)
  %52 = icmp ne i64 %51, 0
  br i1 %52, label %$19, label %$20
$19:
; # (val $Ret)
  %53 = load i64, i64* @$Ret
; # (cdr X)
  %54 = inttoptr i64 %7 to i64*
  %55 = getelementptr i64, i64* %54, i32 1
  %56 = load i64, i64* %55
; # (evMethod Obj (val $Ret) Msg @ (cdr X))
  %57 = call i64 @evMethod(i64 %33, i64 %53, i64 %15, i64 %51, i64 %56)
  br label %$21
$20:
; # (: 1 $Nil)
  br label %$-1
$-1:
  br label %$21
$21:
  %58 = phi i64 [%57, %$19], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$-1] ; # ->
  br label %$14
$14:
  %59 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$12], [%58, %$21] ; # ->
; # (drop *Safe)
  %60 = inttoptr i64 %19 to i64*
  %61 = getelementptr i64, i64* %60, i32 1
  %62 = load i64, i64* %61
  %63 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %62, i64* %63
  ret i64 %59
}

define i64 @_Super(i64) align 8 {
$1:
; # (let (Lst (val (if (val $Typ) (car @) (val $This))) Key (val $Key...
; # (if (val $Typ) (car @) (val $This))
; # (val $Typ)
  %1 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 136) to i64) to i64*
  %2 = load i64, i64* %1
  %3 = icmp ne i64 %2, 0
  br i1 %3, label %$2, label %$3
$2:
; # (car @)
  %4 = inttoptr i64 %2 to i64*
  %5 = load i64, i64* %4
  br label %$4
$3:
; # (val $This)
  %6 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 488) to i64) to i64*
  %7 = load i64, i64* %6
  br label %$4
$4:
  %8 = phi i64 [%5, %$2], [%7, %$3] ; # ->
; # (val (if (val $Typ) (car @) (val $This)))
  %9 = inttoptr i64 %8 to i64*
  %10 = load i64, i64* %9
; # (val $Key)
  %11 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 144) to i64) to i64*
  %12 = load i64, i64* %11
; # (while (pair (car Lst)) (shift Lst))
  br label %$5
$5:
  %13 = phi i64 [%10, %$4], [%21, %$6] ; # Lst
; # (car Lst)
  %14 = inttoptr i64 %13 to i64*
  %15 = load i64, i64* %14
; # (pair (car Lst))
  %16 = and i64 %15, 15
  %17 = icmp eq i64 %16, 0
  br i1 %17, label %$6, label %$7
$6:
  %18 = phi i64 [%13, %$5] ; # Lst
; # (shift Lst)
  %19 = inttoptr i64 %18 to i64*
  %20 = getelementptr i64, i64* %19, i32 1
  %21 = load i64, i64* %20
  br label %$5
$7:
  %22 = phi i64 [%13, %$5] ; # Lst
; # (loop (when (atom Lst) (err Exe Key ($ "Bad super") null)) (? (me...
  br label %$8
$8:
  %23 = phi i64 [%22, %$7], [%46, %$11] ; # Lst
; # (when (atom Lst) (err Exe Key ($ "Bad super") null))
; # (atom Lst)
  %24 = and i64 %23, 15
  %25 = icmp ne i64 %24, 0
  br i1 %25, label %$9, label %$10
$9:
  %26 = phi i64 [%23, %$8] ; # Lst
; # (err Exe Key ($ "Bad super") null)
  call void @err(i64 %0, i64 %12, i8* bitcast ([10 x i8]* @$74 to i8*), i8* null)
  unreachable
$10:
  %27 = phi i64 [%23, %$8] ; # Lst
; # (? (method (car (set $Ret Lst)) Key) (let (TypS (val $Typ) KeyS (...
; # (set $Ret Lst)
  store i64 %27, i64* @$Ret
; # (car (set $Ret Lst))
  %28 = inttoptr i64 %27 to i64*
  %29 = load i64, i64* %28
; # (method (car (set $Ret Lst)) Key)
  %30 = call i64 @method(i64 %29, i64 %12)
  %31 = icmp ne i64 %30, 0
  br i1 %31, label %$13, label %$11
$13:
  %32 = phi i64 [%27, %$10] ; # Lst
; # (let (TypS (val $Typ) KeyS (val $Key)) (set $Typ (val $Ret) $Key ...
; # (val $Typ)
  %33 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 136) to i64) to i64*
  %34 = load i64, i64* %33
; # (val $Key)
  %35 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 144) to i64) to i64*
  %36 = load i64, i64* %35
; # (set $Typ (val $Ret) $Key Key)
; # (val $Ret)
  %37 = load i64, i64* @$Ret
  %38 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 136) to i64) to i64*
  store i64 %37, i64* %38
  %39 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 144) to i64) to i64*
  store i64 %12, i64* %39
; # (prog1 (evExpr @ Exe) (set $Key KeyS $Typ TypS))
; # (evExpr @ Exe)
  %40 = call i64 @evExpr(i64 %30, i64 %0)
; # (set $Key KeyS $Typ TypS)
  %41 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 144) to i64) to i64*
  store i64 %36, i64* %41
  %42 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 136) to i64) to i64*
  store i64 %34, i64* %42
  br label %$12
$11:
  %43 = phi i64 [%27, %$10] ; # Lst
; # (shift Lst)
  %44 = inttoptr i64 %43 to i64*
  %45 = getelementptr i64, i64* %44, i32 1
  %46 = load i64, i64* %45
  br label %$8
$12:
  %47 = phi i64 [%32, %$13] ; # Lst
  %48 = phi i64 [%40, %$13] ; # ->
  ret i64 %48
}

define i64 @extra(i64, i64) align 8 {
$1:
; # (let Lst (val Obj) (while (pair (car Lst)) (shift Lst)) (loop (? ...
; # (val Obj)
  %2 = inttoptr i64 %0 to i64*
  %3 = load i64, i64* %2
; # (while (pair (car Lst)) (shift Lst))
  br label %$2
$2:
  %4 = phi i64 [%3, %$1], [%12, %$3] ; # Lst
; # (car Lst)
  %5 = inttoptr i64 %4 to i64*
  %6 = load i64, i64* %5
; # (pair (car Lst))
  %7 = and i64 %6, 15
  %8 = icmp eq i64 %7, 0
  br i1 %8, label %$3, label %$4
$3:
  %9 = phi i64 [%4, %$2] ; # Lst
; # (shift Lst)
  %10 = inttoptr i64 %9 to i64*
  %11 = getelementptr i64, i64* %10, i32 1
  %12 = load i64, i64* %11
  br label %$2
$4:
  %13 = phi i64 [%4, %$2] ; # Lst
; # (loop (? (atom Lst) 1) (? (== Lst (val $Typ)) (loop (? (atom (shi...
  br label %$5
$5:
  %14 = phi i64 [%13, %$4], [%70, %$21] ; # Lst
; # (? (atom Lst) 1)
; # (atom Lst)
  %15 = and i64 %14, 15
  %16 = icmp ne i64 %15, 0
  br i1 %16, label %$8, label %$6
$8:
  %17 = phi i64 [%14, %$5] ; # Lst
  br label %$7
$6:
  %18 = phi i64 [%14, %$5] ; # Lst
; # (? (== Lst (val $Typ)) (loop (? (atom (shift Lst)) 0) (? (method ...
; # (val $Typ)
  %19 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 136) to i64) to i64*
  %20 = load i64, i64* %19
; # (== Lst (val $Typ))
  %21 = icmp eq i64 %18, %20
  br i1 %21, label %$10, label %$9
$10:
  %22 = phi i64 [%18, %$6] ; # Lst
; # (loop (? (atom (shift Lst)) 0) (? (method (car (set $Ret Lst)) Ke...
  br label %$11
$11:
  %23 = phi i64 [%22, %$10], [%36, %$15] ; # Lst
; # (? (atom (shift Lst)) 0)
; # (shift Lst)
  %24 = inttoptr i64 %23 to i64*
  %25 = getelementptr i64, i64* %24, i32 1
  %26 = load i64, i64* %25
; # (atom (shift Lst))
  %27 = and i64 %26, 15
  %28 = icmp ne i64 %27, 0
  br i1 %28, label %$14, label %$12
$14:
  %29 = phi i64 [%26, %$11] ; # Lst
  br label %$13
$12:
  %30 = phi i64 [%26, %$11] ; # Lst
; # (? (method (car (set $Ret Lst)) Key) @)
; # (set $Ret Lst)
  store i64 %30, i64* @$Ret
; # (car (set $Ret Lst))
  %31 = inttoptr i64 %30 to i64*
  %32 = load i64, i64* %31
; # (method (car (set $Ret Lst)) Key)
  %33 = call i64 @method(i64 %32, i64 %1)
  %34 = icmp ne i64 %33, 0
  br i1 %34, label %$16, label %$15
$16:
  %35 = phi i64 [%30, %$12] ; # Lst
  br label %$13
$15:
  %36 = phi i64 [%30, %$12] ; # Lst
  br label %$11
$13:
  %37 = phi i64 [%29, %$14], [%35, %$16] ; # Lst
  %38 = phi i64 [0, %$14], [%33, %$16] ; # ->
  br label %$7
$9:
  %39 = phi i64 [%18, %$6] ; # Lst
; # (stkChk 0)
  %40 = load i8*, i8** @$StkLimit
  %41 = call i8* @llvm.stacksave()
  %42 = icmp ugt i8* %40, %41
  br i1 %42, label %$17, label %$18
$17:
  call void @stkErr(i64 0)
  unreachable
$18:
; # (? (> (extra (car Lst) Key) 1) @)
; # (car Lst)
  %43 = inttoptr i64 %39 to i64*
  %44 = load i64, i64* %43
; # (extra (car Lst) Key)
  %45 = call i64 @extra(i64 %44, i64 %1)
; # (> (extra (car Lst) Key) 1)
  %46 = icmp ugt i64 %45, 1
  br i1 %46, label %$20, label %$19
$20:
  %47 = phi i64 [%39, %$18] ; # Lst
  br label %$7
$19:
  %48 = phi i64 [%39, %$18] ; # Lst
; # (? (=0 @) (loop (? (atom (shift Lst)) 0) (? (method (car (set $Re...
; # (=0 @)
  %49 = icmp eq i64 %45, 0
  br i1 %49, label %$22, label %$21
$22:
  %50 = phi i64 [%48, %$19] ; # Lst
; # (loop (? (atom (shift Lst)) 0) (? (method (car (set $Ret Lst)) Ke...
  br label %$23
$23:
  %51 = phi i64 [%50, %$22], [%64, %$27] ; # Lst
; # (? (atom (shift Lst)) 0)
; # (shift Lst)
  %52 = inttoptr i64 %51 to i64*
  %53 = getelementptr i64, i64* %52, i32 1
  %54 = load i64, i64* %53
; # (atom (shift Lst))
  %55 = and i64 %54, 15
  %56 = icmp ne i64 %55, 0
  br i1 %56, label %$26, label %$24
$26:
  %57 = phi i64 [%54, %$23] ; # Lst
  br label %$25
$24:
  %58 = phi i64 [%54, %$23] ; # Lst
; # (? (method (car (set $Ret Lst)) Key) @)
; # (set $Ret Lst)
  store i64 %58, i64* @$Ret
; # (car (set $Ret Lst))
  %59 = inttoptr i64 %58 to i64*
  %60 = load i64, i64* %59
; # (method (car (set $Ret Lst)) Key)
  %61 = call i64 @method(i64 %60, i64 %1)
  %62 = icmp ne i64 %61, 0
  br i1 %62, label %$28, label %$27
$28:
  %63 = phi i64 [%58, %$24] ; # Lst
  br label %$25
$27:
  %64 = phi i64 [%58, %$24] ; # Lst
  br label %$23
$25:
  %65 = phi i64 [%57, %$26], [%63, %$28] ; # Lst
  %66 = phi i64 [0, %$26], [%61, %$28] ; # ->
  br label %$7
$21:
  %67 = phi i64 [%48, %$19] ; # Lst
; # (shift Lst)
  %68 = inttoptr i64 %67 to i64*
  %69 = getelementptr i64, i64* %68, i32 1
  %70 = load i64, i64* %69
  br label %$5
$7:
  %71 = phi i64 [%17, %$8], [%37, %$13], [%47, %$20], [%65, %$25] ; # Lst
  %72 = phi i64 [1, %$8], [%38, %$13], [%45, %$20], [%66, %$25] ; # ->
  ret i64 %72
}

define i64 @_Extra(i64) align 8 {
$1:
; # (let Key (val $Key) (unless (> (extra (val $This) Key) 1) (err Ex...
; # (val $Key)
  %1 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 144) to i64) to i64*
  %2 = load i64, i64* %1
; # (unless (> (extra (val $This) Key) 1) (err Exe Key ($ "Bad extra"...
; # (val $This)
  %3 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 488) to i64) to i64*
  %4 = load i64, i64* %3
; # (extra (val $This) Key)
  %5 = call i64 @extra(i64 %4, i64 %2)
; # (> (extra (val $This) Key) 1)
  %6 = icmp ugt i64 %5, 1
  br i1 %6, label %$3, label %$2
$2:
; # (err Exe Key ($ "Bad extra") null)
  call void @err(i64 %0, i64 %2, i8* bitcast ([10 x i8]* @$75 to i8*), i8* null)
  unreachable
$3:
; # (let (TypS (val $Typ) KeyS (val $Key)) (set $Typ (val $Ret) $Key ...
; # (val $Typ)
  %7 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 136) to i64) to i64*
  %8 = load i64, i64* %7
; # (val $Key)
  %9 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 144) to i64) to i64*
  %10 = load i64, i64* %9
; # (set $Typ (val $Ret) $Key Key)
; # (val $Ret)
  %11 = load i64, i64* @$Ret
  %12 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 136) to i64) to i64*
  store i64 %11, i64* %12
  %13 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 144) to i64) to i64*
  store i64 %2, i64* %13
; # (prog1 (evExpr @ Exe) (set $Key KeyS $Typ TypS))
; # (evExpr @ Exe)
  %14 = call i64 @evExpr(i64 %5, i64 %0)
; # (set $Key KeyS $Typ TypS)
  %15 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 144) to i64) to i64*
  store i64 %10, i64* %15
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 136) to i64) to i64*
  store i64 %8, i64* %16
  ret i64 %14
}

define i64 @_And(i64) align 8 {
$1:
; # (let X (cdr Exe) (loop (let Y (eval (car X)) (? (nil? Y) Y) (set ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (loop (let Y (eval (car X)) (? (nil? Y) Y) (set $At Y) (? (atom (...
  br label %$2
$2:
  %4 = phi i64 [%3, %$1], [%25, %$11] ; # X
; # (let Y (eval (car X)) (? (nil? Y) Y) (set $At Y) (? (atom (shift ...
; # (car X)
  %5 = inttoptr i64 %4 to i64*
  %6 = load i64, i64* %5
; # (eval (car X))
  %7 = and i64 %6, 6
  %8 = icmp ne i64 %7, 0
  br i1 %8, label %$5, label %$4
$5:
  br label %$3
$4:
  %9 = and i64 %6, 8
  %10 = icmp ne i64 %9, 0
  br i1 %10, label %$7, label %$6
$7:
  %11 = inttoptr i64 %6 to i64*
  %12 = load i64, i64* %11
  br label %$3
$6:
  %13 = call i64 @evList(i64 %6)
  br label %$3
$3:
  %14 = phi i64 [%6, %$5], [%12, %$7], [%13, %$6] ; # ->
; # (? (nil? Y) Y)
; # (nil? Y)
  %15 = icmp eq i64 %14, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %15, label %$10, label %$8
$10:
  %16 = phi i64 [%4, %$3] ; # X
  br label %$9
$8:
  %17 = phi i64 [%4, %$3] ; # X
; # (set $At Y)
  %18 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  store i64 %14, i64* %18
; # (? (atom (shift X)) Y)
; # (shift X)
  %19 = inttoptr i64 %17 to i64*
  %20 = getelementptr i64, i64* %19, i32 1
  %21 = load i64, i64* %20
; # (atom (shift X))
  %22 = and i64 %21, 15
  %23 = icmp ne i64 %22, 0
  br i1 %23, label %$12, label %$11
$12:
  %24 = phi i64 [%21, %$8] ; # X
  br label %$9
$11:
  %25 = phi i64 [%21, %$8] ; # X
  br label %$2
$9:
  %26 = phi i64 [%16, %$10], [%24, %$12] ; # X
  %27 = phi i64 [%14, %$10], [%14, %$12] ; # ->
  ret i64 %27
}

define i64 @_Or(i64) align 8 {
$1:
; # (let X (cdr Exe) (loop (let Y (eval (car X)) (? (not (nil? Y)) (s...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (loop (let Y (eval (car X)) (? (not (nil? Y)) (set $At Y)) (? (at...
  br label %$2
$2:
  %4 = phi i64 [%3, %$1], [%26, %$11] ; # X
; # (let Y (eval (car X)) (? (not (nil? Y)) (set $At Y)) (? (atom (sh...
; # (car X)
  %5 = inttoptr i64 %4 to i64*
  %6 = load i64, i64* %5
; # (eval (car X))
  %7 = and i64 %6, 6
  %8 = icmp ne i64 %7, 0
  br i1 %8, label %$5, label %$4
$5:
  br label %$3
$4:
  %9 = and i64 %6, 8
  %10 = icmp ne i64 %9, 0
  br i1 %10, label %$7, label %$6
$7:
  %11 = inttoptr i64 %6 to i64*
  %12 = load i64, i64* %11
  br label %$3
$6:
  %13 = call i64 @evList(i64 %6)
  br label %$3
$3:
  %14 = phi i64 [%6, %$5], [%12, %$7], [%13, %$6] ; # ->
; # (? (not (nil? Y)) (set $At Y))
; # (nil? Y)
  %15 = icmp eq i64 %14, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
; # (not (nil? Y))
  %16 = icmp eq i1 %15, 0
  br i1 %16, label %$10, label %$8
$10:
  %17 = phi i64 [%4, %$3] ; # X
; # (set $At Y)
  %18 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  store i64 %14, i64* %18
  br label %$9
$8:
  %19 = phi i64 [%4, %$3] ; # X
; # (? (atom (shift X)) Y)
; # (shift X)
  %20 = inttoptr i64 %19 to i64*
  %21 = getelementptr i64, i64* %20, i32 1
  %22 = load i64, i64* %21
; # (atom (shift X))
  %23 = and i64 %22, 15
  %24 = icmp ne i64 %23, 0
  br i1 %24, label %$12, label %$11
$12:
  %25 = phi i64 [%22, %$8] ; # X
  br label %$9
$11:
  %26 = phi i64 [%22, %$8] ; # X
  br label %$2
$9:
  %27 = phi i64 [%17, %$10], [%25, %$12] ; # X
  %28 = phi i64 [%14, %$10], [%14, %$12] ; # ->
  ret i64 %28
}

define i64 @_Nand(i64) align 8 {
$1:
; # (let X (cdr Exe) (loop (let Y (eval (car X)) (? (nil? Y) $T) (set...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (loop (let Y (eval (car X)) (? (nil? Y) $T) (set $At Y) (? (atom ...
  br label %$2
$2:
  %4 = phi i64 [%3, %$1], [%25, %$11] ; # X
; # (let Y (eval (car X)) (? (nil? Y) $T) (set $At Y) (? (atom (shift...
; # (car X)
  %5 = inttoptr i64 %4 to i64*
  %6 = load i64, i64* %5
; # (eval (car X))
  %7 = and i64 %6, 6
  %8 = icmp ne i64 %7, 0
  br i1 %8, label %$5, label %$4
$5:
  br label %$3
$4:
  %9 = and i64 %6, 8
  %10 = icmp ne i64 %9, 0
  br i1 %10, label %$7, label %$6
$7:
  %11 = inttoptr i64 %6 to i64*
  %12 = load i64, i64* %11
  br label %$3
$6:
  %13 = call i64 @evList(i64 %6)
  br label %$3
$3:
  %14 = phi i64 [%6, %$5], [%12, %$7], [%13, %$6] ; # ->
; # (? (nil? Y) $T)
; # (nil? Y)
  %15 = icmp eq i64 %14, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %15, label %$10, label %$8
$10:
  %16 = phi i64 [%4, %$3] ; # X
  br label %$9
$8:
  %17 = phi i64 [%4, %$3] ; # X
; # (set $At Y)
  %18 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  store i64 %14, i64* %18
; # (? (atom (shift X)) $Nil)
; # (shift X)
  %19 = inttoptr i64 %17 to i64*
  %20 = getelementptr i64, i64* %19, i32 1
  %21 = load i64, i64* %20
; # (atom (shift X))
  %22 = and i64 %21, 15
  %23 = icmp ne i64 %22, 0
  br i1 %23, label %$12, label %$11
$12:
  %24 = phi i64 [%21, %$8] ; # X
  br label %$9
$11:
  %25 = phi i64 [%21, %$8] ; # X
  br label %$2
$9:
  %26 = phi i64 [%16, %$10], [%24, %$12] ; # X
  %27 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$12] ; # ->
  ret i64 %27
}

define i64 @_Nor(i64) align 8 {
$1:
; # (let X (cdr Exe) (loop (let Y (eval (car X)) (? (not (nil? Y)) (s...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (loop (let Y (eval (car X)) (? (not (nil? Y)) (set $At Y) $Nil) (...
  br label %$2
$2:
  %4 = phi i64 [%3, %$1], [%26, %$11] ; # X
; # (let Y (eval (car X)) (? (not (nil? Y)) (set $At Y) $Nil) (? (ato...
; # (car X)
  %5 = inttoptr i64 %4 to i64*
  %6 = load i64, i64* %5
; # (eval (car X))
  %7 = and i64 %6, 6
  %8 = icmp ne i64 %7, 0
  br i1 %8, label %$5, label %$4
$5:
  br label %$3
$4:
  %9 = and i64 %6, 8
  %10 = icmp ne i64 %9, 0
  br i1 %10, label %$7, label %$6
$7:
  %11 = inttoptr i64 %6 to i64*
  %12 = load i64, i64* %11
  br label %$3
$6:
  %13 = call i64 @evList(i64 %6)
  br label %$3
$3:
  %14 = phi i64 [%6, %$5], [%12, %$7], [%13, %$6] ; # ->
; # (? (not (nil? Y)) (set $At Y) $Nil)
; # (nil? Y)
  %15 = icmp eq i64 %14, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
; # (not (nil? Y))
  %16 = icmp eq i1 %15, 0
  br i1 %16, label %$10, label %$8
$10:
  %17 = phi i64 [%4, %$3] ; # X
; # (set $At Y)
  %18 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  store i64 %14, i64* %18
  br label %$9
$8:
  %19 = phi i64 [%4, %$3] ; # X
; # (? (atom (shift X)) $T)
; # (shift X)
  %20 = inttoptr i64 %19 to i64*
  %21 = getelementptr i64, i64* %20, i32 1
  %22 = load i64, i64* %21
; # (atom (shift X))
  %23 = and i64 %22, 15
  %24 = icmp ne i64 %23, 0
  br i1 %24, label %$12, label %$11
$12:
  %25 = phi i64 [%22, %$8] ; # X
  br label %$9
$11:
  %26 = phi i64 [%22, %$8] ; # X
  br label %$2
$9:
  %27 = phi i64 [%17, %$10], [%25, %$12] ; # X
  %28 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$12] ; # ->
  ret i64 %28
}

define i64 @_Xor(i64) align 8 {
$1:
; # (let X (cdr Exe) (if (nil? (eval (++ X))) (if (nil? (eval (car X)...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (if (nil? (eval (++ X))) (if (nil? (eval (car X))) @ $T) (if (nil...
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (nil? (eval (++ X)))
  %16 = icmp eq i64 %15, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %16, label %$7, label %$8
$7:
  %17 = phi i64 [%7, %$2] ; # X
; # (if (nil? (eval (car X))) @ $T)
; # (car X)
  %18 = inttoptr i64 %17 to i64*
  %19 = load i64, i64* %18
; # (eval (car X))
  %20 = and i64 %19, 6
  %21 = icmp ne i64 %20, 0
  br i1 %21, label %$12, label %$11
$12:
  br label %$10
$11:
  %22 = and i64 %19, 8
  %23 = icmp ne i64 %22, 0
  br i1 %23, label %$14, label %$13
$14:
  %24 = inttoptr i64 %19 to i64*
  %25 = load i64, i64* %24
  br label %$10
$13:
  %26 = call i64 @evList(i64 %19)
  br label %$10
$10:
  %27 = phi i64 [%19, %$12], [%25, %$14], [%26, %$13] ; # ->
; # (nil? (eval (car X)))
  %28 = icmp eq i64 %27, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %28, label %$15, label %$16
$15:
  %29 = phi i64 [%17, %$10] ; # X
  br label %$17
$16:
  %30 = phi i64 [%17, %$10] ; # X
  br label %$17
$17:
  %31 = phi i64 [%29, %$15], [%30, %$16] ; # X
  %32 = phi i64 [%27, %$15], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$16] ; # ->
  br label %$9
$8:
  %33 = phi i64 [%7, %$2] ; # X
; # (if (nil? (eval (car X))) $T $Nil)
; # (car X)
  %34 = inttoptr i64 %33 to i64*
  %35 = load i64, i64* %34
; # (eval (car X))
  %36 = and i64 %35, 6
  %37 = icmp ne i64 %36, 0
  br i1 %37, label %$20, label %$19
$20:
  br label %$18
$19:
  %38 = and i64 %35, 8
  %39 = icmp ne i64 %38, 0
  br i1 %39, label %$22, label %$21
$22:
  %40 = inttoptr i64 %35 to i64*
  %41 = load i64, i64* %40
  br label %$18
$21:
  %42 = call i64 @evList(i64 %35)
  br label %$18
$18:
  %43 = phi i64 [%35, %$20], [%41, %$22], [%42, %$21] ; # ->
; # (nil? (eval (car X)))
  %44 = icmp eq i64 %43, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %44, label %$23, label %$24
$23:
  %45 = phi i64 [%33, %$18] ; # X
  br label %$25
$24:
  %46 = phi i64 [%33, %$18] ; # X
  br label %$25
$25:
  %47 = phi i64 [%45, %$23], [%46, %$24] ; # X
  %48 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$23], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$24] ; # ->
  br label %$9
$9:
  %49 = phi i64 [%31, %$17], [%47, %$25] ; # X
  %50 = phi i64 [%32, %$17], [%48, %$25] ; # ->
  ret i64 %50
}

define i64 @_Bool(i64) align 8 {
$1:
; # (if (nil? (eval (cadr Exe))) @ $T)
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (nil? (eval (cadr Exe)))
  %14 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %14, label %$7, label %$8
$7:
  br label %$9
$8:
  br label %$9
$9:
  %15 = phi i64 [%13, %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$8] ; # ->
  ret i64 %15
}

define i64 @_Not(i64) align 8 {
$1:
; # (if (nil? (eval (cadr Exe))) $T (set $At @) $Nil)
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (nil? (eval (cadr Exe)))
  %14 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %14, label %$7, label %$8
$7:
  br label %$9
$8:
; # (set $At @)
  %15 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  store i64 %13, i64* %15
  br label %$9
$9:
  %16 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # ->
  ret i64 %16
}

define i64 @_Nil(i64) align 8 {
$1:
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (exec (cdr Exe))
  br label %$2
$2:
  %4 = phi i64 [%3, %$1], [%16, %$5] ; # Prg
  %5 = inttoptr i64 %4 to i64*
  %6 = load i64, i64* %5
  %7 = getelementptr i64, i64* %5, i32 1
  %8 = load i64, i64* %7
  %9 = and i64 %6, 15
  %10 = icmp eq i64 %9, 0
  br i1 %10, label %$3, label %$4
$3:
  %11 = phi i64 [%8, %$2] ; # Prg
  %12 = call i64 @evList(i64 %6)
  br label %$4
$4:
  %13 = phi i64 [%8, %$2], [%11, %$3] ; # Prg
  %14 = and i64 %13, 15
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$6, label %$5
$5:
  %16 = phi i64 [%13, %$4] ; # Prg
  br label %$2
$6:
  %17 = phi i64 [%13, %$4] ; # Prg
  %18 = phi i64 [0, %$4] ; # ->
  ret i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
}

define i64 @_T(i64) align 8 {
$1:
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (exec (cdr Exe))
  br label %$2
$2:
  %4 = phi i64 [%3, %$1], [%16, %$5] ; # Prg
  %5 = inttoptr i64 %4 to i64*
  %6 = load i64, i64* %5
  %7 = getelementptr i64, i64* %5, i32 1
  %8 = load i64, i64* %7
  %9 = and i64 %6, 15
  %10 = icmp eq i64 %9, 0
  br i1 %10, label %$3, label %$4
$3:
  %11 = phi i64 [%8, %$2] ; # Prg
  %12 = call i64 @evList(i64 %6)
  br label %$4
$4:
  %13 = phi i64 [%8, %$2], [%11, %$3] ; # Prg
  %14 = and i64 %13, 15
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$6, label %$5
$5:
  %16 = phi i64 [%13, %$4] ; # Prg
  br label %$2
$6:
  %17 = phi i64 [%13, %$4] ; # Prg
  %18 = phi i64 [0, %$4] ; # ->
  ret i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
}

define i64 @_Prog(i64) align 8 {
$1:
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (run (cdr Exe))
  br label %$2
$2:
  %4 = phi i64 [%3, %$1], [%26, %$11] ; # Prg
  %5 = inttoptr i64 %4 to i64*
  %6 = load i64, i64* %5
  %7 = getelementptr i64, i64* %5, i32 1
  %8 = load i64, i64* %7
  %9 = and i64 %8, 15
  %10 = icmp ne i64 %9, 0
  br i1 %10, label %$5, label %$3
$5:
  %11 = phi i64 [%8, %$2] ; # Prg
  %12 = and i64 %6, 6
  %13 = icmp ne i64 %12, 0
  br i1 %13, label %$8, label %$7
$8:
  br label %$6
$7:
  %14 = and i64 %6, 8
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$10, label %$9
$10:
  %16 = inttoptr i64 %6 to i64*
  %17 = load i64, i64* %16
  br label %$6
$9:
  %18 = call i64 @evList(i64 %6)
  br label %$6
$6:
  %19 = phi i64 [%6, %$8], [%17, %$10], [%18, %$9] ; # ->
  br label %$4
$3:
  %20 = phi i64 [%8, %$2] ; # Prg
  %21 = and i64 %6, 15
  %22 = icmp eq i64 %21, 0
  br i1 %22, label %$12, label %$11
$12:
  %23 = phi i64 [%20, %$3] ; # Prg
  %24 = call i64 @evList(i64 %6)
  %25 = icmp ne i64 %24, 0
  br label %$11
$11:
  %26 = phi i64 [%20, %$3], [%23, %$12] ; # Prg
  %27 = phi i1 [0, %$3], [%25, %$12] ; # ->
  br label %$2
$4:
  %28 = phi i64 [%11, %$6] ; # Prg
  %29 = phi i64 [%19, %$6] ; # ->
  ret i64 %29
}

define i64 @_Prog1(i64) align 8 {
$1:
; # (let X (cdr Exe) (prog1 (set $At (save (eval (++ X)))) (exec X)))...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (prog1 (set $At (save (eval (++ X)))) (exec X))
; # (set $At (save (eval (++ X))))
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (save (eval (++ X)))
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %17 = load i64, i64* %16
  %18 = alloca i64, i64 2, align 16
  %19 = ptrtoint i64* %18 to i64
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = add i64 %19, 8
  %22 = inttoptr i64 %21 to i64*
  store i64 %17, i64* %22
  %23 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %19, i64* %23
  %24 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  store i64 %15, i64* %24
; # (exec X)
  br label %$7
$7:
  %25 = phi i64 [%7, %$2], [%37, %$10] ; # Prg
  %26 = inttoptr i64 %25 to i64*
  %27 = load i64, i64* %26
  %28 = getelementptr i64, i64* %26, i32 1
  %29 = load i64, i64* %28
  %30 = and i64 %27, 15
  %31 = icmp eq i64 %30, 0
  br i1 %31, label %$8, label %$9
$8:
  %32 = phi i64 [%29, %$7] ; # Prg
  %33 = call i64 @evList(i64 %27)
  br label %$9
$9:
  %34 = phi i64 [%29, %$7], [%32, %$8] ; # Prg
  %35 = and i64 %34, 15
  %36 = icmp ne i64 %35, 0
  br i1 %36, label %$11, label %$10
$10:
  %37 = phi i64 [%34, %$9] ; # Prg
  br label %$7
$11:
  %38 = phi i64 [%34, %$9] ; # Prg
  %39 = phi i64 [0, %$9] ; # ->
; # (drop *Safe)
  %40 = inttoptr i64 %19 to i64*
  %41 = getelementptr i64, i64* %40, i32 1
  %42 = load i64, i64* %41
  %43 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %42, i64* %43
  ret i64 %15
}

define i64 @_Prog2(i64) align 8 {
$1:
; # (let X (cdr Exe) (prog2 (eval (++ X)) (set $At (save (eval (++ X)...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (prog2 (eval (++ X)) (set $At (save (eval (++ X)))) (exec X))
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (set $At (save (eval (++ X))))
; # (++ X)
  %16 = inttoptr i64 %7 to i64*
  %17 = load i64, i64* %16
  %18 = getelementptr i64, i64* %16, i32 1
  %19 = load i64, i64* %18
; # (eval (++ X))
  %20 = and i64 %17, 6
  %21 = icmp ne i64 %20, 0
  br i1 %21, label %$9, label %$8
$9:
  br label %$7
$8:
  %22 = and i64 %17, 8
  %23 = icmp ne i64 %22, 0
  br i1 %23, label %$11, label %$10
$11:
  %24 = inttoptr i64 %17 to i64*
  %25 = load i64, i64* %24
  br label %$7
$10:
  %26 = call i64 @evList(i64 %17)
  br label %$7
$7:
  %27 = phi i64 [%17, %$9], [%25, %$11], [%26, %$10] ; # ->
; # (save (eval (++ X)))
  %28 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %29 = load i64, i64* %28
  %30 = alloca i64, i64 2, align 16
  %31 = ptrtoint i64* %30 to i64
  %32 = inttoptr i64 %31 to i64*
  store i64 %27, i64* %32
  %33 = add i64 %31, 8
  %34 = inttoptr i64 %33 to i64*
  store i64 %29, i64* %34
  %35 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %31, i64* %35
  %36 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  store i64 %27, i64* %36
; # (exec X)
  br label %$12
$12:
  %37 = phi i64 [%19, %$7], [%49, %$15] ; # Prg
  %38 = inttoptr i64 %37 to i64*
  %39 = load i64, i64* %38
  %40 = getelementptr i64, i64* %38, i32 1
  %41 = load i64, i64* %40
  %42 = and i64 %39, 15
  %43 = icmp eq i64 %42, 0
  br i1 %43, label %$13, label %$14
$13:
  %44 = phi i64 [%41, %$12] ; # Prg
  %45 = call i64 @evList(i64 %39)
  br label %$14
$14:
  %46 = phi i64 [%41, %$12], [%44, %$13] ; # Prg
  %47 = and i64 %46, 15
  %48 = icmp ne i64 %47, 0
  br i1 %48, label %$16, label %$15
$15:
  %49 = phi i64 [%46, %$14] ; # Prg
  br label %$12
$16:
  %50 = phi i64 [%46, %$14] ; # Prg
  %51 = phi i64 [0, %$14] ; # ->
; # (drop *Safe)
  %52 = inttoptr i64 %31 to i64*
  %53 = getelementptr i64, i64* %52, i32 1
  %54 = load i64, i64* %53
  %55 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %54, i64* %55
  ret i64 %27
}

define i64 @_If(i64) align 8 {
$1:
; # (let X (cdr Exe) (if (nil? (eval (++ X))) (run (cdr X)) (set $At ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (if (nil? (eval (++ X))) (run (cdr X)) (set $At @) (eval (car X))...
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (nil? (eval (++ X)))
  %16 = icmp eq i64 %15, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %16, label %$7, label %$8
$7:
  %17 = phi i64 [%7, %$2] ; # X
; # (cdr X)
  %18 = inttoptr i64 %17 to i64*
  %19 = getelementptr i64, i64* %18, i32 1
  %20 = load i64, i64* %19
; # (run (cdr X))
  br label %$10
$10:
  %21 = phi i64 [%20, %$7], [%43, %$19] ; # Prg
  %22 = inttoptr i64 %21 to i64*
  %23 = load i64, i64* %22
  %24 = getelementptr i64, i64* %22, i32 1
  %25 = load i64, i64* %24
  %26 = and i64 %25, 15
  %27 = icmp ne i64 %26, 0
  br i1 %27, label %$13, label %$11
$13:
  %28 = phi i64 [%25, %$10] ; # Prg
  %29 = and i64 %23, 6
  %30 = icmp ne i64 %29, 0
  br i1 %30, label %$16, label %$15
$16:
  br label %$14
$15:
  %31 = and i64 %23, 8
  %32 = icmp ne i64 %31, 0
  br i1 %32, label %$18, label %$17
$18:
  %33 = inttoptr i64 %23 to i64*
  %34 = load i64, i64* %33
  br label %$14
$17:
  %35 = call i64 @evList(i64 %23)
  br label %$14
$14:
  %36 = phi i64 [%23, %$16], [%34, %$18], [%35, %$17] ; # ->
  br label %$12
$11:
  %37 = phi i64 [%25, %$10] ; # Prg
  %38 = and i64 %23, 15
  %39 = icmp eq i64 %38, 0
  br i1 %39, label %$20, label %$19
$20:
  %40 = phi i64 [%37, %$11] ; # Prg
  %41 = call i64 @evList(i64 %23)
  %42 = icmp ne i64 %41, 0
  br label %$19
$19:
  %43 = phi i64 [%37, %$11], [%40, %$20] ; # Prg
  %44 = phi i1 [0, %$11], [%42, %$20] ; # ->
  br label %$10
$12:
  %45 = phi i64 [%28, %$14] ; # Prg
  %46 = phi i64 [%36, %$14] ; # ->
  br label %$9
$8:
  %47 = phi i64 [%7, %$2] ; # X
; # (set $At @)
  %48 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  store i64 %15, i64* %48
; # (car X)
  %49 = inttoptr i64 %47 to i64*
  %50 = load i64, i64* %49
; # (eval (car X))
  %51 = and i64 %50, 6
  %52 = icmp ne i64 %51, 0
  br i1 %52, label %$23, label %$22
$23:
  br label %$21
$22:
  %53 = and i64 %50, 8
  %54 = icmp ne i64 %53, 0
  br i1 %54, label %$25, label %$24
$25:
  %55 = inttoptr i64 %50 to i64*
  %56 = load i64, i64* %55
  br label %$21
$24:
  %57 = call i64 @evList(i64 %50)
  br label %$21
$21:
  %58 = phi i64 [%50, %$23], [%56, %$25], [%57, %$24] ; # ->
  br label %$9
$9:
  %59 = phi i64 [%17, %$12], [%47, %$21] ; # X
  %60 = phi i64 [%46, %$12], [%58, %$21] ; # ->
  ret i64 %60
}

define i64 @_Ifn(i64) align 8 {
$1:
; # (let X (cdr Exe) (if (nil? (eval (++ X))) (eval (car X)) (set $At...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (if (nil? (eval (++ X))) (eval (car X)) (set $At @) (run (cdr X))...
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (nil? (eval (++ X)))
  %16 = icmp eq i64 %15, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %16, label %$7, label %$8
$7:
  %17 = phi i64 [%7, %$2] ; # X
; # (car X)
  %18 = inttoptr i64 %17 to i64*
  %19 = load i64, i64* %18
; # (eval (car X))
  %20 = and i64 %19, 6
  %21 = icmp ne i64 %20, 0
  br i1 %21, label %$12, label %$11
$12:
  br label %$10
$11:
  %22 = and i64 %19, 8
  %23 = icmp ne i64 %22, 0
  br i1 %23, label %$14, label %$13
$14:
  %24 = inttoptr i64 %19 to i64*
  %25 = load i64, i64* %24
  br label %$10
$13:
  %26 = call i64 @evList(i64 %19)
  br label %$10
$10:
  %27 = phi i64 [%19, %$12], [%25, %$14], [%26, %$13] ; # ->
  br label %$9
$8:
  %28 = phi i64 [%7, %$2] ; # X
; # (set $At @)
  %29 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  store i64 %15, i64* %29
; # (cdr X)
  %30 = inttoptr i64 %28 to i64*
  %31 = getelementptr i64, i64* %30, i32 1
  %32 = load i64, i64* %31
; # (run (cdr X))
  br label %$15
$15:
  %33 = phi i64 [%32, %$8], [%55, %$24] ; # Prg
  %34 = inttoptr i64 %33 to i64*
  %35 = load i64, i64* %34
  %36 = getelementptr i64, i64* %34, i32 1
  %37 = load i64, i64* %36
  %38 = and i64 %37, 15
  %39 = icmp ne i64 %38, 0
  br i1 %39, label %$18, label %$16
$18:
  %40 = phi i64 [%37, %$15] ; # Prg
  %41 = and i64 %35, 6
  %42 = icmp ne i64 %41, 0
  br i1 %42, label %$21, label %$20
$21:
  br label %$19
$20:
  %43 = and i64 %35, 8
  %44 = icmp ne i64 %43, 0
  br i1 %44, label %$23, label %$22
$23:
  %45 = inttoptr i64 %35 to i64*
  %46 = load i64, i64* %45
  br label %$19
$22:
  %47 = call i64 @evList(i64 %35)
  br label %$19
$19:
  %48 = phi i64 [%35, %$21], [%46, %$23], [%47, %$22] ; # ->
  br label %$17
$16:
  %49 = phi i64 [%37, %$15] ; # Prg
  %50 = and i64 %35, 15
  %51 = icmp eq i64 %50, 0
  br i1 %51, label %$25, label %$24
$25:
  %52 = phi i64 [%49, %$16] ; # Prg
  %53 = call i64 @evList(i64 %35)
  %54 = icmp ne i64 %53, 0
  br label %$24
$24:
  %55 = phi i64 [%49, %$16], [%52, %$25] ; # Prg
  %56 = phi i1 [0, %$16], [%54, %$25] ; # ->
  br label %$15
$17:
  %57 = phi i64 [%40, %$19] ; # Prg
  %58 = phi i64 [%48, %$19] ; # ->
  br label %$9
$9:
  %59 = phi i64 [%17, %$10], [%28, %$17] ; # X
  %60 = phi i64 [%27, %$10], [%58, %$17] ; # ->
  ret i64 %60
}

define i64 @_If2(i64) align 8 {
$1:
; # (let X (cdr Exe) (if (nil? (eval (++ X))) (if (nil? (eval (++ X))...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (if (nil? (eval (++ X))) (if (nil? (eval (++ X))) (run (cdr (cddr...
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (nil? (eval (++ X)))
  %16 = icmp eq i64 %15, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %16, label %$7, label %$8
$7:
  %17 = phi i64 [%7, %$2] ; # X
; # (if (nil? (eval (++ X))) (run (cdr (cddr X))) (set $At @) (eval (...
; # (++ X)
  %18 = inttoptr i64 %17 to i64*
  %19 = load i64, i64* %18
  %20 = getelementptr i64, i64* %18, i32 1
  %21 = load i64, i64* %20
; # (eval (++ X))
  %22 = and i64 %19, 6
  %23 = icmp ne i64 %22, 0
  br i1 %23, label %$12, label %$11
$12:
  br label %$10
$11:
  %24 = and i64 %19, 8
  %25 = icmp ne i64 %24, 0
  br i1 %25, label %$14, label %$13
$14:
  %26 = inttoptr i64 %19 to i64*
  %27 = load i64, i64* %26
  br label %$10
$13:
  %28 = call i64 @evList(i64 %19)
  br label %$10
$10:
  %29 = phi i64 [%19, %$12], [%27, %$14], [%28, %$13] ; # ->
; # (nil? (eval (++ X)))
  %30 = icmp eq i64 %29, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %30, label %$15, label %$16
$15:
  %31 = phi i64 [%21, %$10] ; # X
; # (cddr X)
  %32 = inttoptr i64 %31 to i64*
  %33 = getelementptr i64, i64* %32, i32 1
  %34 = load i64, i64* %33
  %35 = inttoptr i64 %34 to i64*
  %36 = getelementptr i64, i64* %35, i32 1
  %37 = load i64, i64* %36
; # (cdr (cddr X))
  %38 = inttoptr i64 %37 to i64*
  %39 = getelementptr i64, i64* %38, i32 1
  %40 = load i64, i64* %39
; # (run (cdr (cddr X)))
  br label %$18
$18:
  %41 = phi i64 [%40, %$15], [%63, %$27] ; # Prg
  %42 = inttoptr i64 %41 to i64*
  %43 = load i64, i64* %42
  %44 = getelementptr i64, i64* %42, i32 1
  %45 = load i64, i64* %44
  %46 = and i64 %45, 15
  %47 = icmp ne i64 %46, 0
  br i1 %47, label %$21, label %$19
$21:
  %48 = phi i64 [%45, %$18] ; # Prg
  %49 = and i64 %43, 6
  %50 = icmp ne i64 %49, 0
  br i1 %50, label %$24, label %$23
$24:
  br label %$22
$23:
  %51 = and i64 %43, 8
  %52 = icmp ne i64 %51, 0
  br i1 %52, label %$26, label %$25
$26:
  %53 = inttoptr i64 %43 to i64*
  %54 = load i64, i64* %53
  br label %$22
$25:
  %55 = call i64 @evList(i64 %43)
  br label %$22
$22:
  %56 = phi i64 [%43, %$24], [%54, %$26], [%55, %$25] ; # ->
  br label %$20
$19:
  %57 = phi i64 [%45, %$18] ; # Prg
  %58 = and i64 %43, 15
  %59 = icmp eq i64 %58, 0
  br i1 %59, label %$28, label %$27
$28:
  %60 = phi i64 [%57, %$19] ; # Prg
  %61 = call i64 @evList(i64 %43)
  %62 = icmp ne i64 %61, 0
  br label %$27
$27:
  %63 = phi i64 [%57, %$19], [%60, %$28] ; # Prg
  %64 = phi i1 [0, %$19], [%62, %$28] ; # ->
  br label %$18
$20:
  %65 = phi i64 [%48, %$22] ; # Prg
  %66 = phi i64 [%56, %$22] ; # ->
  br label %$17
$16:
  %67 = phi i64 [%21, %$10] ; # X
; # (set $At @)
  %68 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  store i64 %29, i64* %68
; # (cddr X)
  %69 = inttoptr i64 %67 to i64*
  %70 = getelementptr i64, i64* %69, i32 1
  %71 = load i64, i64* %70
  %72 = inttoptr i64 %71 to i64*
  %73 = getelementptr i64, i64* %72, i32 1
  %74 = load i64, i64* %73
; # (car (cddr X))
  %75 = inttoptr i64 %74 to i64*
  %76 = load i64, i64* %75
; # (eval (car (cddr X)))
  %77 = and i64 %76, 6
  %78 = icmp ne i64 %77, 0
  br i1 %78, label %$31, label %$30
$31:
  br label %$29
$30:
  %79 = and i64 %76, 8
  %80 = icmp ne i64 %79, 0
  br i1 %80, label %$33, label %$32
$33:
  %81 = inttoptr i64 %76 to i64*
  %82 = load i64, i64* %81
  br label %$29
$32:
  %83 = call i64 @evList(i64 %76)
  br label %$29
$29:
  %84 = phi i64 [%76, %$31], [%82, %$33], [%83, %$32] ; # ->
  br label %$17
$17:
  %85 = phi i64 [%31, %$20], [%67, %$29] ; # X
  %86 = phi i64 [%66, %$20], [%84, %$29] ; # ->
  br label %$9
$8:
  %87 = phi i64 [%7, %$2] ; # X
; # (set $At @)
  %88 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  store i64 %15, i64* %88
; # (if (nil? (eval (++ X))) (eval (cadr X)) (set $At @) (eval (car X...
; # (++ X)
  %89 = inttoptr i64 %87 to i64*
  %90 = load i64, i64* %89
  %91 = getelementptr i64, i64* %89, i32 1
  %92 = load i64, i64* %91
; # (eval (++ X))
  %93 = and i64 %90, 6
  %94 = icmp ne i64 %93, 0
  br i1 %94, label %$36, label %$35
$36:
  br label %$34
$35:
  %95 = and i64 %90, 8
  %96 = icmp ne i64 %95, 0
  br i1 %96, label %$38, label %$37
$38:
  %97 = inttoptr i64 %90 to i64*
  %98 = load i64, i64* %97
  br label %$34
$37:
  %99 = call i64 @evList(i64 %90)
  br label %$34
$34:
  %100 = phi i64 [%90, %$36], [%98, %$38], [%99, %$37] ; # ->
; # (nil? (eval (++ X)))
  %101 = icmp eq i64 %100, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %101, label %$39, label %$40
$39:
  %102 = phi i64 [%92, %$34] ; # X
; # (cadr X)
  %103 = inttoptr i64 %102 to i64*
  %104 = getelementptr i64, i64* %103, i32 1
  %105 = load i64, i64* %104
  %106 = inttoptr i64 %105 to i64*
  %107 = load i64, i64* %106
; # (eval (cadr X))
  %108 = and i64 %107, 6
  %109 = icmp ne i64 %108, 0
  br i1 %109, label %$44, label %$43
$44:
  br label %$42
$43:
  %110 = and i64 %107, 8
  %111 = icmp ne i64 %110, 0
  br i1 %111, label %$46, label %$45
$46:
  %112 = inttoptr i64 %107 to i64*
  %113 = load i64, i64* %112
  br label %$42
$45:
  %114 = call i64 @evList(i64 %107)
  br label %$42
$42:
  %115 = phi i64 [%107, %$44], [%113, %$46], [%114, %$45] ; # ->
  br label %$41
$40:
  %116 = phi i64 [%92, %$34] ; # X
; # (set $At @)
  %117 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  store i64 %100, i64* %117
; # (car X)
  %118 = inttoptr i64 %116 to i64*
  %119 = load i64, i64* %118
; # (eval (car X))
  %120 = and i64 %119, 6
  %121 = icmp ne i64 %120, 0
  br i1 %121, label %$49, label %$48
$49:
  br label %$47
$48:
  %122 = and i64 %119, 8
  %123 = icmp ne i64 %122, 0
  br i1 %123, label %$51, label %$50
$51:
  %124 = inttoptr i64 %119 to i64*
  %125 = load i64, i64* %124
  br label %$47
$50:
  %126 = call i64 @evList(i64 %119)
  br label %$47
$47:
  %127 = phi i64 [%119, %$49], [%125, %$51], [%126, %$50] ; # ->
  br label %$41
$41:
  %128 = phi i64 [%102, %$42], [%116, %$47] ; # X
  %129 = phi i64 [%115, %$42], [%127, %$47] ; # ->
  br label %$9
$9:
  %130 = phi i64 [%85, %$17], [%128, %$41] ; # X
  %131 = phi i64 [%86, %$17], [%129, %$41] ; # ->
  ret i64 %131
}

define i64 @_IfAt2(i64) align 8 {
$1:
; # (let X (cdr Exe) (set $At (eval (++ X))) (if (nil? (val $At2)) (r...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (set $At (eval (++ X)))
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  store i64 %15, i64* %16
; # (if (nil? (val $At2)) (run (cdr X)) (eval (car X)))
; # (val $At2)
  %17 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 456) to i64) to i64*
  %18 = load i64, i64* %17
; # (nil? (val $At2))
  %19 = icmp eq i64 %18, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %19, label %$7, label %$8
$7:
  %20 = phi i64 [%7, %$2] ; # X
; # (cdr X)
  %21 = inttoptr i64 %20 to i64*
  %22 = getelementptr i64, i64* %21, i32 1
  %23 = load i64, i64* %22
; # (run (cdr X))
  br label %$10
$10:
  %24 = phi i64 [%23, %$7], [%46, %$19] ; # Prg
  %25 = inttoptr i64 %24 to i64*
  %26 = load i64, i64* %25
  %27 = getelementptr i64, i64* %25, i32 1
  %28 = load i64, i64* %27
  %29 = and i64 %28, 15
  %30 = icmp ne i64 %29, 0
  br i1 %30, label %$13, label %$11
$13:
  %31 = phi i64 [%28, %$10] ; # Prg
  %32 = and i64 %26, 6
  %33 = icmp ne i64 %32, 0
  br i1 %33, label %$16, label %$15
$16:
  br label %$14
$15:
  %34 = and i64 %26, 8
  %35 = icmp ne i64 %34, 0
  br i1 %35, label %$18, label %$17
$18:
  %36 = inttoptr i64 %26 to i64*
  %37 = load i64, i64* %36
  br label %$14
$17:
  %38 = call i64 @evList(i64 %26)
  br label %$14
$14:
  %39 = phi i64 [%26, %$16], [%37, %$18], [%38, %$17] ; # ->
  br label %$12
$11:
  %40 = phi i64 [%28, %$10] ; # Prg
  %41 = and i64 %26, 15
  %42 = icmp eq i64 %41, 0
  br i1 %42, label %$20, label %$19
$20:
  %43 = phi i64 [%40, %$11] ; # Prg
  %44 = call i64 @evList(i64 %26)
  %45 = icmp ne i64 %44, 0
  br label %$19
$19:
  %46 = phi i64 [%40, %$11], [%43, %$20] ; # Prg
  %47 = phi i1 [0, %$11], [%45, %$20] ; # ->
  br label %$10
$12:
  %48 = phi i64 [%31, %$14] ; # Prg
  %49 = phi i64 [%39, %$14] ; # ->
  br label %$9
$8:
  %50 = phi i64 [%7, %$2] ; # X
; # (car X)
  %51 = inttoptr i64 %50 to i64*
  %52 = load i64, i64* %51
; # (eval (car X))
  %53 = and i64 %52, 6
  %54 = icmp ne i64 %53, 0
  br i1 %54, label %$23, label %$22
$23:
  br label %$21
$22:
  %55 = and i64 %52, 8
  %56 = icmp ne i64 %55, 0
  br i1 %56, label %$25, label %$24
$25:
  %57 = inttoptr i64 %52 to i64*
  %58 = load i64, i64* %57
  br label %$21
$24:
  %59 = call i64 @evList(i64 %52)
  br label %$21
$21:
  %60 = phi i64 [%52, %$23], [%58, %$25], [%59, %$24] ; # ->
  br label %$9
$9:
  %61 = phi i64 [%20, %$12], [%50, %$21] ; # X
  %62 = phi i64 [%49, %$12], [%60, %$21] ; # ->
  ret i64 %62
}

define i64 @_When(i64) align 8 {
$1:
; # (let X (cdr Exe) (if (nil? (eval (++ X))) @ (set $At @) (run X)))...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (if (nil? (eval (++ X))) @ (set $At @) (run X))
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (nil? (eval (++ X)))
  %16 = icmp eq i64 %15, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %16, label %$7, label %$8
$7:
  %17 = phi i64 [%7, %$2] ; # X
  br label %$9
$8:
  %18 = phi i64 [%7, %$2] ; # X
; # (set $At @)
  %19 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  store i64 %15, i64* %19
; # (run X)
  br label %$10
$10:
  %20 = phi i64 [%18, %$8], [%42, %$19] ; # Prg
  %21 = inttoptr i64 %20 to i64*
  %22 = load i64, i64* %21
  %23 = getelementptr i64, i64* %21, i32 1
  %24 = load i64, i64* %23
  %25 = and i64 %24, 15
  %26 = icmp ne i64 %25, 0
  br i1 %26, label %$13, label %$11
$13:
  %27 = phi i64 [%24, %$10] ; # Prg
  %28 = and i64 %22, 6
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %$16, label %$15
$16:
  br label %$14
$15:
  %30 = and i64 %22, 8
  %31 = icmp ne i64 %30, 0
  br i1 %31, label %$18, label %$17
$18:
  %32 = inttoptr i64 %22 to i64*
  %33 = load i64, i64* %32
  br label %$14
$17:
  %34 = call i64 @evList(i64 %22)
  br label %$14
$14:
  %35 = phi i64 [%22, %$16], [%33, %$18], [%34, %$17] ; # ->
  br label %$12
$11:
  %36 = phi i64 [%24, %$10] ; # Prg
  %37 = and i64 %22, 15
  %38 = icmp eq i64 %37, 0
  br i1 %38, label %$20, label %$19
$20:
  %39 = phi i64 [%36, %$11] ; # Prg
  %40 = call i64 @evList(i64 %22)
  %41 = icmp ne i64 %40, 0
  br label %$19
$19:
  %42 = phi i64 [%36, %$11], [%39, %$20] ; # Prg
  %43 = phi i1 [0, %$11], [%41, %$20] ; # ->
  br label %$10
$12:
  %44 = phi i64 [%27, %$14] ; # Prg
  %45 = phi i64 [%35, %$14] ; # ->
  br label %$9
$9:
  %46 = phi i64 [%17, %$7], [%18, %$12] ; # X
  %47 = phi i64 [%15, %$7], [%45, %$12] ; # ->
  ret i64 %47
}

define i64 @_Unless(i64) align 8 {
$1:
; # (let X (cdr Exe) (if (nil? (eval (++ X))) (run X) (set $At @) $Ni...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (if (nil? (eval (++ X))) (run X) (set $At @) $Nil)
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (nil? (eval (++ X)))
  %16 = icmp eq i64 %15, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %16, label %$7, label %$8
$7:
  %17 = phi i64 [%7, %$2] ; # X
; # (run X)
  br label %$10
$10:
  %18 = phi i64 [%17, %$7], [%40, %$19] ; # Prg
  %19 = inttoptr i64 %18 to i64*
  %20 = load i64, i64* %19
  %21 = getelementptr i64, i64* %19, i32 1
  %22 = load i64, i64* %21
  %23 = and i64 %22, 15
  %24 = icmp ne i64 %23, 0
  br i1 %24, label %$13, label %$11
$13:
  %25 = phi i64 [%22, %$10] ; # Prg
  %26 = and i64 %20, 6
  %27 = icmp ne i64 %26, 0
  br i1 %27, label %$16, label %$15
$16:
  br label %$14
$15:
  %28 = and i64 %20, 8
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %$18, label %$17
$18:
  %30 = inttoptr i64 %20 to i64*
  %31 = load i64, i64* %30
  br label %$14
$17:
  %32 = call i64 @evList(i64 %20)
  br label %$14
$14:
  %33 = phi i64 [%20, %$16], [%31, %$18], [%32, %$17] ; # ->
  br label %$12
$11:
  %34 = phi i64 [%22, %$10] ; # Prg
  %35 = and i64 %20, 15
  %36 = icmp eq i64 %35, 0
  br i1 %36, label %$20, label %$19
$20:
  %37 = phi i64 [%34, %$11] ; # Prg
  %38 = call i64 @evList(i64 %20)
  %39 = icmp ne i64 %38, 0
  br label %$19
$19:
  %40 = phi i64 [%34, %$11], [%37, %$20] ; # Prg
  %41 = phi i1 [0, %$11], [%39, %$20] ; # ->
  br label %$10
$12:
  %42 = phi i64 [%25, %$14] ; # Prg
  %43 = phi i64 [%33, %$14] ; # ->
  br label %$9
$8:
  %44 = phi i64 [%7, %$2] ; # X
; # (set $At @)
  %45 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  store i64 %15, i64* %45
  br label %$9
$9:
  %46 = phi i64 [%17, %$12], [%44, %$8] ; # X
  %47 = phi i64 [%43, %$12], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # ->
  ret i64 %47
}

define i64 @_Cond(i64) align 8 {
$1:
; # (let X Exe (loop (? (atom (shift X)) $Nil) (let Y (car X) (? (not...
; # (loop (? (atom (shift X)) $Nil) (let Y (car X) (? (not (nil? (eva...
  br label %$2
$2:
  %1 = phi i64 [%0, %$1], [%54, %$11] ; # X
; # (? (atom (shift X)) $Nil)
; # (shift X)
  %2 = inttoptr i64 %1 to i64*
  %3 = getelementptr i64, i64* %2, i32 1
  %4 = load i64, i64* %3
; # (atom (shift X))
  %5 = and i64 %4, 15
  %6 = icmp ne i64 %5, 0
  br i1 %6, label %$5, label %$3
$5:
  %7 = phi i64 [%4, %$2] ; # X
  br label %$4
$3:
  %8 = phi i64 [%4, %$2] ; # X
; # (let Y (car X) (? (not (nil? (eval (car Y)))) (set $At @) (run (c...
; # (car X)
  %9 = inttoptr i64 %8 to i64*
  %10 = load i64, i64* %9
; # (? (not (nil? (eval (car Y)))) (set $At @) (run (cdr Y)))
; # (car Y)
  %11 = inttoptr i64 %10 to i64*
  %12 = load i64, i64* %11
; # (eval (car Y))
  %13 = and i64 %12, 6
  %14 = icmp ne i64 %13, 0
  br i1 %14, label %$8, label %$7
$8:
  br label %$6
$7:
  %15 = and i64 %12, 8
  %16 = icmp ne i64 %15, 0
  br i1 %16, label %$10, label %$9
$10:
  %17 = inttoptr i64 %12 to i64*
  %18 = load i64, i64* %17
  br label %$6
$9:
  %19 = call i64 @evList(i64 %12)
  br label %$6
$6:
  %20 = phi i64 [%12, %$8], [%18, %$10], [%19, %$9] ; # ->
; # (nil? (eval (car Y)))
  %21 = icmp eq i64 %20, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
; # (not (nil? (eval (car Y))))
  %22 = icmp eq i1 %21, 0
  br i1 %22, label %$12, label %$11
$12:
  %23 = phi i64 [%8, %$6] ; # X
; # (set $At @)
  %24 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  store i64 %20, i64* %24
; # (cdr Y)
  %25 = inttoptr i64 %10 to i64*
  %26 = getelementptr i64, i64* %25, i32 1
  %27 = load i64, i64* %26
; # (run (cdr Y))
  br label %$13
$13:
  %28 = phi i64 [%27, %$12], [%50, %$22] ; # Prg
  %29 = inttoptr i64 %28 to i64*
  %30 = load i64, i64* %29
  %31 = getelementptr i64, i64* %29, i32 1
  %32 = load i64, i64* %31
  %33 = and i64 %32, 15
  %34 = icmp ne i64 %33, 0
  br i1 %34, label %$16, label %$14
$16:
  %35 = phi i64 [%32, %$13] ; # Prg
  %36 = and i64 %30, 6
  %37 = icmp ne i64 %36, 0
  br i1 %37, label %$19, label %$18
$19:
  br label %$17
$18:
  %38 = and i64 %30, 8
  %39 = icmp ne i64 %38, 0
  br i1 %39, label %$21, label %$20
$21:
  %40 = inttoptr i64 %30 to i64*
  %41 = load i64, i64* %40
  br label %$17
$20:
  %42 = call i64 @evList(i64 %30)
  br label %$17
$17:
  %43 = phi i64 [%30, %$19], [%41, %$21], [%42, %$20] ; # ->
  br label %$15
$14:
  %44 = phi i64 [%32, %$13] ; # Prg
  %45 = and i64 %30, 15
  %46 = icmp eq i64 %45, 0
  br i1 %46, label %$23, label %$22
$23:
  %47 = phi i64 [%44, %$14] ; # Prg
  %48 = call i64 @evList(i64 %30)
  %49 = icmp ne i64 %48, 0
  br label %$22
$22:
  %50 = phi i64 [%44, %$14], [%47, %$23] ; # Prg
  %51 = phi i1 [0, %$14], [%49, %$23] ; # ->
  br label %$13
$15:
  %52 = phi i64 [%35, %$17] ; # Prg
  %53 = phi i64 [%43, %$17] ; # ->
  br label %$4
$11:
  %54 = phi i64 [%8, %$6] ; # X
  br label %$2
$4:
  %55 = phi i64 [%7, %$5], [%23, %$15] ; # X
  %56 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$5], [%53, %$15] ; # ->
  ret i64 %56
}

define i64 @_Nond(i64) align 8 {
$1:
; # (let X Exe (loop (? (atom (shift X)) $Nil) (let Y (car X) (? (nil...
; # (loop (? (atom (shift X)) $Nil) (let Y (car X) (? (nil? (eval (ca...
  br label %$2
$2:
  %1 = phi i64 [%0, %$1], [%52, %$11] ; # X
; # (? (atom (shift X)) $Nil)
; # (shift X)
  %2 = inttoptr i64 %1 to i64*
  %3 = getelementptr i64, i64* %2, i32 1
  %4 = load i64, i64* %3
; # (atom (shift X))
  %5 = and i64 %4, 15
  %6 = icmp ne i64 %5, 0
  br i1 %6, label %$5, label %$3
$5:
  %7 = phi i64 [%4, %$2] ; # X
  br label %$4
$3:
  %8 = phi i64 [%4, %$2] ; # X
; # (let Y (car X) (? (nil? (eval (car Y))) (run (cdr Y))))
; # (car X)
  %9 = inttoptr i64 %8 to i64*
  %10 = load i64, i64* %9
; # (? (nil? (eval (car Y))) (run (cdr Y)))
; # (car Y)
  %11 = inttoptr i64 %10 to i64*
  %12 = load i64, i64* %11
; # (eval (car Y))
  %13 = and i64 %12, 6
  %14 = icmp ne i64 %13, 0
  br i1 %14, label %$8, label %$7
$8:
  br label %$6
$7:
  %15 = and i64 %12, 8
  %16 = icmp ne i64 %15, 0
  br i1 %16, label %$10, label %$9
$10:
  %17 = inttoptr i64 %12 to i64*
  %18 = load i64, i64* %17
  br label %$6
$9:
  %19 = call i64 @evList(i64 %12)
  br label %$6
$6:
  %20 = phi i64 [%12, %$8], [%18, %$10], [%19, %$9] ; # ->
; # (nil? (eval (car Y)))
  %21 = icmp eq i64 %20, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %21, label %$12, label %$11
$12:
  %22 = phi i64 [%8, %$6] ; # X
; # (cdr Y)
  %23 = inttoptr i64 %10 to i64*
  %24 = getelementptr i64, i64* %23, i32 1
  %25 = load i64, i64* %24
; # (run (cdr Y))
  br label %$13
$13:
  %26 = phi i64 [%25, %$12], [%48, %$22] ; # Prg
  %27 = inttoptr i64 %26 to i64*
  %28 = load i64, i64* %27
  %29 = getelementptr i64, i64* %27, i32 1
  %30 = load i64, i64* %29
  %31 = and i64 %30, 15
  %32 = icmp ne i64 %31, 0
  br i1 %32, label %$16, label %$14
$16:
  %33 = phi i64 [%30, %$13] ; # Prg
  %34 = and i64 %28, 6
  %35 = icmp ne i64 %34, 0
  br i1 %35, label %$19, label %$18
$19:
  br label %$17
$18:
  %36 = and i64 %28, 8
  %37 = icmp ne i64 %36, 0
  br i1 %37, label %$21, label %$20
$21:
  %38 = inttoptr i64 %28 to i64*
  %39 = load i64, i64* %38
  br label %$17
$20:
  %40 = call i64 @evList(i64 %28)
  br label %$17
$17:
  %41 = phi i64 [%28, %$19], [%39, %$21], [%40, %$20] ; # ->
  br label %$15
$14:
  %42 = phi i64 [%30, %$13] ; # Prg
  %43 = and i64 %28, 15
  %44 = icmp eq i64 %43, 0
  br i1 %44, label %$23, label %$22
$23:
  %45 = phi i64 [%42, %$14] ; # Prg
  %46 = call i64 @evList(i64 %28)
  %47 = icmp ne i64 %46, 0
  br label %$22
$22:
  %48 = phi i64 [%42, %$14], [%45, %$23] ; # Prg
  %49 = phi i1 [0, %$14], [%47, %$23] ; # ->
  br label %$13
$15:
  %50 = phi i64 [%33, %$17] ; # Prg
  %51 = phi i64 [%41, %$17] ; # ->
  br label %$4
$11:
  %52 = phi i64 [%8, %$6] ; # X
; # (set $At @)
  %53 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  store i64 %20, i64* %53
  br label %$2
$4:
  %54 = phi i64 [%7, %$5], [%22, %$15] ; # X
  %55 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$5], [%51, %$15] ; # ->
  ret i64 %55
}

define i64 @_Case(i64) align 8 {
$1:
; # (let (X (cdr Exe) A (set $At (eval (car X)))) (loop (? (atom (shi...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (set $At (eval (car X)))
; # (car X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (car X))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
  %14 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  store i64 %13, i64* %14
; # (loop (? (atom (shift X)) $Nil) (let (Y (car X) Z (car Y)) (? (or...
  br label %$7
$7:
  %15 = phi i64 [%3, %$2], [%83, %$22] ; # X
; # (? (atom (shift X)) $Nil)
; # (shift X)
  %16 = inttoptr i64 %15 to i64*
  %17 = getelementptr i64, i64* %16, i32 1
  %18 = load i64, i64* %17
; # (atom (shift X))
  %19 = and i64 %18, 15
  %20 = icmp ne i64 %19, 0
  br i1 %20, label %$10, label %$8
$10:
  %21 = phi i64 [%18, %$7] ; # X
  br label %$9
$8:
  %22 = phi i64 [%18, %$7] ; # X
; # (let (Y (car X) Z (car Y)) (? (or (t? Z) (if (atom Z) (equal Z A)...
; # (car X)
  %23 = inttoptr i64 %22 to i64*
  %24 = load i64, i64* %23
; # (car Y)
  %25 = inttoptr i64 %24 to i64*
  %26 = load i64, i64* %25
; # (? (or (t? Z) (if (atom Z) (equal Z A) (member A Z))) (run (cdr Y...
; # (or (t? Z) (if (atom Z) (equal Z A) (member A Z)))
; # (t? Z)
  %27 = icmp eq i64 %26, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %27, label %$11, label %$12
$12:
  %28 = phi i64 [%22, %$8] ; # X
; # (if (atom Z) (equal Z A) (member A Z))
; # (atom Z)
  %29 = and i64 %26, 15
  %30 = icmp ne i64 %29, 0
  br i1 %30, label %$13, label %$14
$13:
  %31 = phi i64 [%28, %$12] ; # X
; # (equal Z A)
  %32 = call i1 @equal(i64 %26, i64 %13)
  br label %$15
$14:
  %33 = phi i64 [%28, %$12] ; # X
; # (member A Z)
  br label %$16
$16:
  %34 = phi i64 [%26, %$14], [%46, %$20] ; # L
  %35 = and i64 %34, 15
  %36 = icmp ne i64 %35, 0
  br i1 %36, label %$19, label %$17
$19:
  %37 = phi i64 [%34, %$16] ; # L
  br label %$18
$17:
  %38 = phi i64 [%34, %$16] ; # L
  %39 = inttoptr i64 %38 to i64*
  %40 = load i64, i64* %39
  %41 = call i1 @equal(i64 %13, i64 %40)
  br i1 %41, label %$21, label %$20
$21:
  %42 = phi i64 [%38, %$17] ; # L
  br label %$18
$20:
  %43 = phi i64 [%38, %$17] ; # L
  %44 = inttoptr i64 %43 to i64*
  %45 = getelementptr i64, i64* %44, i32 1
  %46 = load i64, i64* %45
  br label %$16
$18:
  %47 = phi i64 [%37, %$19], [%42, %$21] ; # L
  %48 = phi i1 [0, %$19], [1, %$21] ; # ->
  br label %$15
$15:
  %49 = phi i64 [%31, %$13], [%33, %$18] ; # X
  %50 = phi i1 [%32, %$13], [%48, %$18] ; # ->
  br label %$11
$11:
  %51 = phi i64 [%22, %$8], [%49, %$15] ; # X
  %52 = phi i1 [1, %$8], [%50, %$15] ; # ->
  br i1 %52, label %$23, label %$22
$23:
  %53 = phi i64 [%51, %$11] ; # X
; # (cdr Y)
  %54 = inttoptr i64 %24 to i64*
  %55 = getelementptr i64, i64* %54, i32 1
  %56 = load i64, i64* %55
; # (run (cdr Y))
  br label %$24
$24:
  %57 = phi i64 [%56, %$23], [%79, %$33] ; # Prg
  %58 = inttoptr i64 %57 to i64*
  %59 = load i64, i64* %58
  %60 = getelementptr i64, i64* %58, i32 1
  %61 = load i64, i64* %60
  %62 = and i64 %61, 15
  %63 = icmp ne i64 %62, 0
  br i1 %63, label %$27, label %$25
$27:
  %64 = phi i64 [%61, %$24] ; # Prg
  %65 = and i64 %59, 6
  %66 = icmp ne i64 %65, 0
  br i1 %66, label %$30, label %$29
$30:
  br label %$28
$29:
  %67 = and i64 %59, 8
  %68 = icmp ne i64 %67, 0
  br i1 %68, label %$32, label %$31
$32:
  %69 = inttoptr i64 %59 to i64*
  %70 = load i64, i64* %69
  br label %$28
$31:
  %71 = call i64 @evList(i64 %59)
  br label %$28
$28:
  %72 = phi i64 [%59, %$30], [%70, %$32], [%71, %$31] ; # ->
  br label %$26
$25:
  %73 = phi i64 [%61, %$24] ; # Prg
  %74 = and i64 %59, 15
  %75 = icmp eq i64 %74, 0
  br i1 %75, label %$34, label %$33
$34:
  %76 = phi i64 [%73, %$25] ; # Prg
  %77 = call i64 @evList(i64 %59)
  %78 = icmp ne i64 %77, 0
  br label %$33
$33:
  %79 = phi i64 [%73, %$25], [%76, %$34] ; # Prg
  %80 = phi i1 [0, %$25], [%78, %$34] ; # ->
  br label %$24
$26:
  %81 = phi i64 [%64, %$28] ; # Prg
  %82 = phi i64 [%72, %$28] ; # ->
  br label %$9
$22:
  %83 = phi i64 [%51, %$11] ; # X
  br label %$7
$9:
  %84 = phi i64 [%21, %$10], [%53, %$26] ; # X
  %85 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$10], [%82, %$26] ; # ->
  ret i64 %85
}

define i64 @_Casq(i64) align 8 {
$1:
; # (let (X (cdr Exe) A (set $At (eval (car X)))) (loop (? (atom (shi...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (set $At (eval (car X)))
; # (car X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (car X))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
  %14 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  store i64 %13, i64* %14
; # (loop (? (atom (shift X)) $Nil) (let (Y (car X) Z (car Y)) (? (or...
  br label %$7
$7:
  %15 = phi i64 [%3, %$2], [%78, %$20] ; # X
; # (? (atom (shift X)) $Nil)
; # (shift X)
  %16 = inttoptr i64 %15 to i64*
  %17 = getelementptr i64, i64* %16, i32 1
  %18 = load i64, i64* %17
; # (atom (shift X))
  %19 = and i64 %18, 15
  %20 = icmp ne i64 %19, 0
  br i1 %20, label %$10, label %$8
$10:
  %21 = phi i64 [%18, %$7] ; # X
  br label %$9
$8:
  %22 = phi i64 [%18, %$7] ; # X
; # (let (Y (car X) Z (car Y)) (? (or (t? Z) (== Z A) (memq A Z)) (ru...
; # (car X)
  %23 = inttoptr i64 %22 to i64*
  %24 = load i64, i64* %23
; # (car Y)
  %25 = inttoptr i64 %24 to i64*
  %26 = load i64, i64* %25
; # (? (or (t? Z) (== Z A) (memq A Z)) (run (cdr Y)))
; # (or (t? Z) (== Z A) (memq A Z))
; # (t? Z)
  %27 = icmp eq i64 %26, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %27, label %$11, label %$12
$12:
  %28 = phi i64 [%22, %$8] ; # X
; # (== Z A)
  %29 = icmp eq i64 %26, %13
  br i1 %29, label %$11, label %$13
$13:
  %30 = phi i64 [%28, %$12] ; # X
; # (memq A Z)
  br label %$14
$14:
  %31 = phi i64 [%26, %$13], [%43, %$18] ; # L
  %32 = and i64 %31, 15
  %33 = icmp ne i64 %32, 0
  br i1 %33, label %$17, label %$15
$17:
  %34 = phi i64 [%31, %$14] ; # L
  br label %$16
$15:
  %35 = phi i64 [%31, %$14] ; # L
  %36 = inttoptr i64 %35 to i64*
  %37 = load i64, i64* %36
  %38 = icmp eq i64 %13, %37
  br i1 %38, label %$19, label %$18
$19:
  %39 = phi i64 [%35, %$15] ; # L
  br label %$16
$18:
  %40 = phi i64 [%35, %$15] ; # L
  %41 = inttoptr i64 %40 to i64*
  %42 = getelementptr i64, i64* %41, i32 1
  %43 = load i64, i64* %42
  br label %$14
$16:
  %44 = phi i64 [%34, %$17], [%39, %$19] ; # L
  %45 = phi i1 [0, %$17], [1, %$19] ; # ->
  br label %$11
$11:
  %46 = phi i64 [%22, %$8], [%28, %$12], [%30, %$16] ; # X
  %47 = phi i1 [1, %$8], [1, %$12], [%45, %$16] ; # ->
  br i1 %47, label %$21, label %$20
$21:
  %48 = phi i64 [%46, %$11] ; # X
; # (cdr Y)
  %49 = inttoptr i64 %24 to i64*
  %50 = getelementptr i64, i64* %49, i32 1
  %51 = load i64, i64* %50
; # (run (cdr Y))
  br label %$22
$22:
  %52 = phi i64 [%51, %$21], [%74, %$31] ; # Prg
  %53 = inttoptr i64 %52 to i64*
  %54 = load i64, i64* %53
  %55 = getelementptr i64, i64* %53, i32 1
  %56 = load i64, i64* %55
  %57 = and i64 %56, 15
  %58 = icmp ne i64 %57, 0
  br i1 %58, label %$25, label %$23
$25:
  %59 = phi i64 [%56, %$22] ; # Prg
  %60 = and i64 %54, 6
  %61 = icmp ne i64 %60, 0
  br i1 %61, label %$28, label %$27
$28:
  br label %$26
$27:
  %62 = and i64 %54, 8
  %63 = icmp ne i64 %62, 0
  br i1 %63, label %$30, label %$29
$30:
  %64 = inttoptr i64 %54 to i64*
  %65 = load i64, i64* %64
  br label %$26
$29:
  %66 = call i64 @evList(i64 %54)
  br label %$26
$26:
  %67 = phi i64 [%54, %$28], [%65, %$30], [%66, %$29] ; # ->
  br label %$24
$23:
  %68 = phi i64 [%56, %$22] ; # Prg
  %69 = and i64 %54, 15
  %70 = icmp eq i64 %69, 0
  br i1 %70, label %$32, label %$31
$32:
  %71 = phi i64 [%68, %$23] ; # Prg
  %72 = call i64 @evList(i64 %54)
  %73 = icmp ne i64 %72, 0
  br label %$31
$31:
  %74 = phi i64 [%68, %$23], [%71, %$32] ; # Prg
  %75 = phi i1 [0, %$23], [%73, %$32] ; # ->
  br label %$22
$24:
  %76 = phi i64 [%59, %$26] ; # Prg
  %77 = phi i64 [%67, %$26] ; # ->
  br label %$9
$20:
  %78 = phi i64 [%46, %$11] ; # X
  br label %$7
$9:
  %79 = phi i64 [%21, %$10], [%48, %$24] ; # X
  %80 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$10], [%77, %$24] ; # ->
  ret i64 %80
}

define i64 @_State(i64) align 8 {
$1:
; # (let (X (cdr Exe) Var (save (needChkVar Exe (eval (car X))))) (lo...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (car X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (car X))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (needChkVar Exe (eval (car X)))
  %14 = and i64 %13, 6
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$7, label %$8
$7:
  call void @varErr(i64 %0, i64 %13)
  unreachable
$8:
  %16 = icmp uge i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %16, label %$10, label %$9
$10:
  %17 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %13
  br label %$9
$9:
  %18 = phi i1 [0, %$8], [%17, %$10] ; # ->
  br i1 %18, label %$11, label %$12
$11:
  call void @protErr(i64 %0, i64 %13)
  unreachable
$12:
; # (save (needChkVar Exe (eval (car X))))
  %19 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %20 = load i64, i64* %19
  %21 = alloca i64, i64 2, align 16
  %22 = ptrtoint i64* %21 to i64
  %23 = inttoptr i64 %22 to i64*
  store i64 %13, i64* %23
  %24 = add i64 %22, 8
  %25 = inttoptr i64 %24 to i64*
  store i64 %20, i64* %25
  %26 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %22, i64* %26
; # (loop (? (atom (shift X)) $Nil) (let (Y (car X) Z (car Y)) (when ...
  br label %$13
$13:
  %27 = phi i64 [%3, %$12], [%120, %$28] ; # X
; # (? (atom (shift X)) $Nil)
; # (shift X)
  %28 = inttoptr i64 %27 to i64*
  %29 = getelementptr i64, i64* %28, i32 1
  %30 = load i64, i64* %29
; # (atom (shift X))
  %31 = and i64 %30, 15
  %32 = icmp ne i64 %31, 0
  br i1 %32, label %$16, label %$14
$16:
  %33 = phi i64 [%30, %$13] ; # X
  br label %$15
$14:
  %34 = phi i64 [%30, %$13] ; # X
; # (let (Y (car X) Z (car Y)) (when (or (t? Z) (let V (val Var) (or ...
; # (car X)
  %35 = inttoptr i64 %34 to i64*
  %36 = load i64, i64* %35
; # (car Y)
  %37 = inttoptr i64 %36 to i64*
  %38 = load i64, i64* %37
; # (when (or (t? Z) (let V (val Var) (or (== Z V) (memq V Z)))) (? (...
; # (or (t? Z) (let V (val Var) (or (== Z V) (memq V Z))))
; # (t? Z)
  %39 = icmp eq i64 %38, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %39, label %$17, label %$18
$18:
  %40 = phi i64 [%34, %$14] ; # X
  %41 = phi i64 [%36, %$14] ; # Y
; # (let V (val Var) (or (== Z V) (memq V Z)))
; # (val Var)
  %42 = inttoptr i64 %13 to i64*
  %43 = load i64, i64* %42
; # (or (== Z V) (memq V Z))
; # (== Z V)
  %44 = icmp eq i64 %38, %43
  br i1 %44, label %$19, label %$20
$20:
  %45 = phi i64 [%40, %$18] ; # X
  %46 = phi i64 [%41, %$18] ; # Y
; # (memq V Z)
  br label %$21
$21:
  %47 = phi i64 [%38, %$20], [%59, %$25] ; # L
  %48 = and i64 %47, 15
  %49 = icmp ne i64 %48, 0
  br i1 %49, label %$24, label %$22
$24:
  %50 = phi i64 [%47, %$21] ; # L
  br label %$23
$22:
  %51 = phi i64 [%47, %$21] ; # L
  %52 = inttoptr i64 %51 to i64*
  %53 = load i64, i64* %52
  %54 = icmp eq i64 %43, %53
  br i1 %54, label %$26, label %$25
$26:
  %55 = phi i64 [%51, %$22] ; # L
  br label %$23
$25:
  %56 = phi i64 [%51, %$22] ; # L
  %57 = inttoptr i64 %56 to i64*
  %58 = getelementptr i64, i64* %57, i32 1
  %59 = load i64, i64* %58
  br label %$21
$23:
  %60 = phi i64 [%50, %$24], [%55, %$26] ; # L
  %61 = phi i1 [0, %$24], [1, %$26] ; # ->
  br label %$19
$19:
  %62 = phi i64 [%40, %$18], [%45, %$23] ; # X
  %63 = phi i64 [%41, %$18], [%46, %$23] ; # Y
  %64 = phi i1 [1, %$18], [%61, %$23] ; # ->
  br label %$17
$17:
  %65 = phi i64 [%34, %$14], [%62, %$19] ; # X
  %66 = phi i64 [%36, %$14], [%63, %$19] ; # Y
  %67 = phi i1 [1, %$14], [%64, %$19] ; # ->
  br i1 %67, label %$27, label %$28
$27:
  %68 = phi i64 [%65, %$17] ; # X
  %69 = phi i64 [%66, %$17] ; # Y
; # (? (not (nil? (eval (car (shift Y))))) (set Var (set $At @)) (run...
; # (shift Y)
  %70 = inttoptr i64 %69 to i64*
  %71 = getelementptr i64, i64* %70, i32 1
  %72 = load i64, i64* %71
; # (car (shift Y))
  %73 = inttoptr i64 %72 to i64*
  %74 = load i64, i64* %73
; # (eval (car (shift Y)))
  %75 = and i64 %74, 6
  %76 = icmp ne i64 %75, 0
  br i1 %76, label %$31, label %$30
$31:
  br label %$29
$30:
  %77 = and i64 %74, 8
  %78 = icmp ne i64 %77, 0
  br i1 %78, label %$33, label %$32
$33:
  %79 = inttoptr i64 %74 to i64*
  %80 = load i64, i64* %79
  br label %$29
$32:
  %81 = call i64 @evList(i64 %74)
  br label %$29
$29:
  %82 = phi i64 [%74, %$31], [%80, %$33], [%81, %$32] ; # ->
; # (nil? (eval (car (shift Y))))
  %83 = icmp eq i64 %82, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
; # (not (nil? (eval (car (shift Y)))))
  %84 = icmp eq i1 %83, 0
  br i1 %84, label %$35, label %$34
$35:
  %85 = phi i64 [%68, %$29] ; # X
  %86 = phi i64 [%72, %$29] ; # Y
; # (set Var (set $At @))
; # (set $At @)
  %87 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  store i64 %82, i64* %87
  %88 = inttoptr i64 %13 to i64*
  store i64 %82, i64* %88
; # (cdr Y)
  %89 = inttoptr i64 %86 to i64*
  %90 = getelementptr i64, i64* %89, i32 1
  %91 = load i64, i64* %90
; # (run (cdr Y))
  br label %$36
$36:
  %92 = phi i64 [%91, %$35], [%114, %$45] ; # Prg
  %93 = inttoptr i64 %92 to i64*
  %94 = load i64, i64* %93
  %95 = getelementptr i64, i64* %93, i32 1
  %96 = load i64, i64* %95
  %97 = and i64 %96, 15
  %98 = icmp ne i64 %97, 0
  br i1 %98, label %$39, label %$37
$39:
  %99 = phi i64 [%96, %$36] ; # Prg
  %100 = and i64 %94, 6
  %101 = icmp ne i64 %100, 0
  br i1 %101, label %$42, label %$41
$42:
  br label %$40
$41:
  %102 = and i64 %94, 8
  %103 = icmp ne i64 %102, 0
  br i1 %103, label %$44, label %$43
$44:
  %104 = inttoptr i64 %94 to i64*
  %105 = load i64, i64* %104
  br label %$40
$43:
  %106 = call i64 @evList(i64 %94)
  br label %$40
$40:
  %107 = phi i64 [%94, %$42], [%105, %$44], [%106, %$43] ; # ->
  br label %$38
$37:
  %108 = phi i64 [%96, %$36] ; # Prg
  %109 = and i64 %94, 15
  %110 = icmp eq i64 %109, 0
  br i1 %110, label %$46, label %$45
$46:
  %111 = phi i64 [%108, %$37] ; # Prg
  %112 = call i64 @evList(i64 %94)
  %113 = icmp ne i64 %112, 0
  br label %$45
$45:
  %114 = phi i64 [%108, %$37], [%111, %$46] ; # Prg
  %115 = phi i1 [0, %$37], [%113, %$46] ; # ->
  br label %$36
$38:
  %116 = phi i64 [%99, %$40] ; # Prg
  %117 = phi i64 [%107, %$40] ; # ->
  br label %$15
$34:
  %118 = phi i64 [%68, %$29] ; # X
  %119 = phi i64 [%72, %$29] ; # Y
  br label %$28
$28:
  %120 = phi i64 [%65, %$17], [%118, %$34] ; # X
  %121 = phi i64 [%66, %$17], [%119, %$34] ; # Y
  br label %$13
$15:
  %122 = phi i64 [%33, %$16], [%85, %$38] ; # X
  %123 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$16], [%117, %$38] ; # ->
; # (drop *Safe)
  %124 = inttoptr i64 %22 to i64*
  %125 = getelementptr i64, i64* %124, i32 1
  %126 = load i64, i64* %125
  %127 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %126, i64* %127
  ret i64 %123
}

define i64 @_While(i64) align 8 {
$1:
; # (let (X (cdr Exe) E (++ X) R (save $Nil)) (until (nil? (eval E)) ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (save $Nil)
  %8 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %9 = load i64, i64* %8
  %10 = alloca i64, i64 2, align 16
  %11 = ptrtoint i64* %10 to i64
  %12 = inttoptr i64 %11 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %12
  %13 = add i64 %11, 8
  %14 = inttoptr i64 %13 to i64*
  store i64 %9, i64* %14
  %15 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %11, i64* %15
; # (until (nil? (eval E)) (set $At @) (setq R (safe (run X))))
  br label %$2
$2:
  %16 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$1], [%53, %$12] ; # R
; # (eval E)
  %17 = and i64 %5, 6
  %18 = icmp ne i64 %17, 0
  br i1 %18, label %$5, label %$4
$5:
  br label %$3
$4:
  %19 = and i64 %5, 8
  %20 = icmp ne i64 %19, 0
  br i1 %20, label %$7, label %$6
$7:
  %21 = inttoptr i64 %5 to i64*
  %22 = load i64, i64* %21
  br label %$3
$6:
  %23 = call i64 @evList(i64 %5)
  br label %$3
$3:
  %24 = phi i64 [%5, %$5], [%22, %$7], [%23, %$6] ; # ->
; # (nil? (eval E))
  %25 = icmp eq i64 %24, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %25, label %$9, label %$8
$8:
  %26 = phi i64 [%16, %$3] ; # R
; # (set $At @)
  %27 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  store i64 %24, i64* %27
; # (run X)
  br label %$10
$10:
  %28 = phi i64 [%7, %$8], [%50, %$19] ; # Prg
  %29 = inttoptr i64 %28 to i64*
  %30 = load i64, i64* %29
  %31 = getelementptr i64, i64* %29, i32 1
  %32 = load i64, i64* %31
  %33 = and i64 %32, 15
  %34 = icmp ne i64 %33, 0
  br i1 %34, label %$13, label %$11
$13:
  %35 = phi i64 [%32, %$10] ; # Prg
  %36 = and i64 %30, 6
  %37 = icmp ne i64 %36, 0
  br i1 %37, label %$16, label %$15
$16:
  br label %$14
$15:
  %38 = and i64 %30, 8
  %39 = icmp ne i64 %38, 0
  br i1 %39, label %$18, label %$17
$18:
  %40 = inttoptr i64 %30 to i64*
  %41 = load i64, i64* %40
  br label %$14
$17:
  %42 = call i64 @evList(i64 %30)
  br label %$14
$14:
  %43 = phi i64 [%30, %$16], [%41, %$18], [%42, %$17] ; # ->
  br label %$12
$11:
  %44 = phi i64 [%32, %$10] ; # Prg
  %45 = and i64 %30, 15
  %46 = icmp eq i64 %45, 0
  br i1 %46, label %$20, label %$19
$20:
  %47 = phi i64 [%44, %$11] ; # Prg
  %48 = call i64 @evList(i64 %30)
  %49 = icmp ne i64 %48, 0
  br label %$19
$19:
  %50 = phi i64 [%44, %$11], [%47, %$20] ; # Prg
  %51 = phi i1 [0, %$11], [%49, %$20] ; # ->
  br label %$10
$12:
  %52 = phi i64 [%35, %$14] ; # Prg
  %53 = phi i64 [%43, %$14] ; # ->
; # (safe (run X))
  %54 = inttoptr i64 %11 to i64*
  store i64 %53, i64* %54
  br label %$2
$9:
  %55 = phi i64 [%16, %$3] ; # R
; # (drop *Safe)
  %56 = inttoptr i64 %11 to i64*
  %57 = getelementptr i64, i64* %56, i32 1
  %58 = load i64, i64* %57
  %59 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %58, i64* %59
  ret i64 %55
}

define i64 @_Until(i64) align 8 {
$1:
; # (let (X (cdr Exe) E (++ X) R (save $Nil)) (while (nil? (eval E)) ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (save $Nil)
  %8 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %9 = load i64, i64* %8
  %10 = alloca i64, i64 2, align 16
  %11 = ptrtoint i64* %10 to i64
  %12 = inttoptr i64 %11 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %12
  %13 = add i64 %11, 8
  %14 = inttoptr i64 %13 to i64*
  store i64 %9, i64* %14
  %15 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %11, i64* %15
; # (while (nil? (eval E)) (setq R (safe (run X))))
  br label %$2
$2:
  %16 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$1], [%52, %$12] ; # R
; # (eval E)
  %17 = and i64 %5, 6
  %18 = icmp ne i64 %17, 0
  br i1 %18, label %$5, label %$4
$5:
  br label %$3
$4:
  %19 = and i64 %5, 8
  %20 = icmp ne i64 %19, 0
  br i1 %20, label %$7, label %$6
$7:
  %21 = inttoptr i64 %5 to i64*
  %22 = load i64, i64* %21
  br label %$3
$6:
  %23 = call i64 @evList(i64 %5)
  br label %$3
$3:
  %24 = phi i64 [%5, %$5], [%22, %$7], [%23, %$6] ; # ->
; # (nil? (eval E))
  %25 = icmp eq i64 %24, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %25, label %$8, label %$9
$8:
  %26 = phi i64 [%16, %$3] ; # R
; # (run X)
  br label %$10
$10:
  %27 = phi i64 [%7, %$8], [%49, %$19] ; # Prg
  %28 = inttoptr i64 %27 to i64*
  %29 = load i64, i64* %28
  %30 = getelementptr i64, i64* %28, i32 1
  %31 = load i64, i64* %30
  %32 = and i64 %31, 15
  %33 = icmp ne i64 %32, 0
  br i1 %33, label %$13, label %$11
$13:
  %34 = phi i64 [%31, %$10] ; # Prg
  %35 = and i64 %29, 6
  %36 = icmp ne i64 %35, 0
  br i1 %36, label %$16, label %$15
$16:
  br label %$14
$15:
  %37 = and i64 %29, 8
  %38 = icmp ne i64 %37, 0
  br i1 %38, label %$18, label %$17
$18:
  %39 = inttoptr i64 %29 to i64*
  %40 = load i64, i64* %39
  br label %$14
$17:
  %41 = call i64 @evList(i64 %29)
  br label %$14
$14:
  %42 = phi i64 [%29, %$16], [%40, %$18], [%41, %$17] ; # ->
  br label %$12
$11:
  %43 = phi i64 [%31, %$10] ; # Prg
  %44 = and i64 %29, 15
  %45 = icmp eq i64 %44, 0
  br i1 %45, label %$20, label %$19
$20:
  %46 = phi i64 [%43, %$11] ; # Prg
  %47 = call i64 @evList(i64 %29)
  %48 = icmp ne i64 %47, 0
  br label %$19
$19:
  %49 = phi i64 [%43, %$11], [%46, %$20] ; # Prg
  %50 = phi i1 [0, %$11], [%48, %$20] ; # ->
  br label %$10
$12:
  %51 = phi i64 [%34, %$14] ; # Prg
  %52 = phi i64 [%42, %$14] ; # ->
; # (safe (run X))
  %53 = inttoptr i64 %11 to i64*
  store i64 %52, i64* %53
  br label %$2
$9:
  %54 = phi i64 [%16, %$3] ; # R
; # (set $At @)
  %55 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  store i64 %24, i64* %55
; # (drop *Safe)
  %56 = inttoptr i64 %11 to i64*
  %57 = getelementptr i64, i64* %56, i32 1
  %58 = load i64, i64* %57
  %59 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %58, i64* %59
  ret i64 %54
}

define i64 @_At(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (needPair Exe (eval (car X))) Z (cdr Y)) (con...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (car X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (car X))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (needPair Exe (eval (car X)))
  %14 = and i64 %13, 15
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$7, label %$8
$7:
  call void @pairErr(i64 %0, i64 %13)
  unreachable
$8:
; # (cdr Y)
  %16 = inttoptr i64 %13 to i64*
  %17 = getelementptr i64, i64* %16, i32 1
  %18 = load i64, i64* %17
; # (cond ((nil? Z) @) ((< (+ (car Y) (hex "10")) Z) (set Y @) $Nil) ...
; # (nil? Z)
  %19 = icmp eq i64 %18, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %19, label %$11, label %$10
$11:
  br label %$9
$10:
; # (car Y)
  %20 = inttoptr i64 %13 to i64*
  %21 = load i64, i64* %20
; # (+ (car Y) (hex "10"))
  %22 = add i64 %21, 16
; # (< (+ (car Y) (hex "10")) Z)
  %23 = icmp ult i64 %22, %18
  br i1 %23, label %$13, label %$12
$13:
; # (set Y @)
  %24 = inttoptr i64 %13 to i64*
  store i64 %22, i64* %24
  br label %$9
$12:
; # (set Y ZERO)
  %25 = inttoptr i64 %13 to i64*
  store i64 2, i64* %25
; # (cdr X)
  %26 = inttoptr i64 %3 to i64*
  %27 = getelementptr i64, i64* %26, i32 1
  %28 = load i64, i64* %27
; # (run (cdr X))
  br label %$14
$14:
  %29 = phi i64 [%28, %$12], [%51, %$23] ; # Prg
  %30 = inttoptr i64 %29 to i64*
  %31 = load i64, i64* %30
  %32 = getelementptr i64, i64* %30, i32 1
  %33 = load i64, i64* %32
  %34 = and i64 %33, 15
  %35 = icmp ne i64 %34, 0
  br i1 %35, label %$17, label %$15
$17:
  %36 = phi i64 [%33, %$14] ; # Prg
  %37 = and i64 %31, 6
  %38 = icmp ne i64 %37, 0
  br i1 %38, label %$20, label %$19
$20:
  br label %$18
$19:
  %39 = and i64 %31, 8
  %40 = icmp ne i64 %39, 0
  br i1 %40, label %$22, label %$21
$22:
  %41 = inttoptr i64 %31 to i64*
  %42 = load i64, i64* %41
  br label %$18
$21:
  %43 = call i64 @evList(i64 %31)
  br label %$18
$18:
  %44 = phi i64 [%31, %$20], [%42, %$22], [%43, %$21] ; # ->
  br label %$16
$15:
  %45 = phi i64 [%33, %$14] ; # Prg
  %46 = and i64 %31, 15
  %47 = icmp eq i64 %46, 0
  br i1 %47, label %$24, label %$23
$24:
  %48 = phi i64 [%45, %$15] ; # Prg
  %49 = call i64 @evList(i64 %31)
  %50 = icmp ne i64 %49, 0
  br label %$23
$23:
  %51 = phi i64 [%45, %$15], [%48, %$24] ; # Prg
  %52 = phi i1 [0, %$15], [%50, %$24] ; # ->
  br label %$14
$16:
  %53 = phi i64 [%36, %$18] ; # Prg
  %54 = phi i64 [%44, %$18] ; # ->
  br label %$9
$9:
  %55 = phi i64 [%18, %$11], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$13], [%54, %$16] ; # ->
  ret i64 %55
}

define i64 @loop1(i64) align 8 {
$1:
; # (loop (let E (car X) (unless (num? E) (setq E (cond ((sym? E) (va...
  br label %$2
$2:
  %1 = phi i64 [%0, %$1], [%141, %$49] ; # X
; # (let E (car X) (unless (num? E) (setq E (cond ((sym? E) (val E)) ...
; # (car X)
  %2 = inttoptr i64 %1 to i64*
  %3 = load i64, i64* %2
; # (unless (num? E) (setq E (cond ((sym? E) (val E)) ((nil? (car E))...
; # (num? E)
  %4 = and i64 %3, 6
  %5 = icmp ne i64 %4, 0
  br i1 %5, label %$4, label %$3
$3:
  %6 = phi i64 [%1, %$2] ; # X
  %7 = phi i64 [%3, %$2] ; # E
; # (cond ((sym? E) (val E)) ((nil? (car E)) (? (nil? (eval (car (shi...
; # (sym? E)
  %8 = and i64 %7, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$7, label %$6
$7:
  %10 = phi i64 [%6, %$3] ; # X
  %11 = phi i64 [%7, %$3] ; # E
; # (val E)
  %12 = inttoptr i64 %11 to i64*
  %13 = load i64, i64* %12
  br label %$5
$6:
  %14 = phi i64 [%6, %$3] ; # X
  %15 = phi i64 [%7, %$3] ; # E
; # (car E)
  %16 = inttoptr i64 %15 to i64*
  %17 = load i64, i64* %16
; # (nil? (car E))
  %18 = icmp eq i64 %17, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %18, label %$9, label %$8
$9:
  %19 = phi i64 [%14, %$6] ; # X
  %20 = phi i64 [%15, %$6] ; # E
; # (? (nil? (eval (car (shift E)))) (run (cdr E)))
; # (shift E)
  %21 = inttoptr i64 %20 to i64*
  %22 = getelementptr i64, i64* %21, i32 1
  %23 = load i64, i64* %22
; # (car (shift E))
  %24 = inttoptr i64 %23 to i64*
  %25 = load i64, i64* %24
; # (eval (car (shift E)))
  %26 = and i64 %25, 6
  %27 = icmp ne i64 %26, 0
  br i1 %27, label %$12, label %$11
$12:
  br label %$10
$11:
  %28 = and i64 %25, 8
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %$14, label %$13
$14:
  %30 = inttoptr i64 %25 to i64*
  %31 = load i64, i64* %30
  br label %$10
$13:
  %32 = call i64 @evList(i64 %25)
  br label %$10
$10:
  %33 = phi i64 [%25, %$12], [%31, %$14], [%32, %$13] ; # ->
; # (nil? (eval (car (shift E))))
  %34 = icmp eq i64 %33, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %34, label %$17, label %$15
$17:
  %35 = phi i64 [%19, %$10] ; # X
  %36 = phi i64 [%23, %$10] ; # E
; # (cdr E)
  %37 = inttoptr i64 %36 to i64*
  %38 = getelementptr i64, i64* %37, i32 1
  %39 = load i64, i64* %38
; # (run (cdr E))
  br label %$18
$18:
  %40 = phi i64 [%39, %$17], [%62, %$27] ; # Prg
  %41 = inttoptr i64 %40 to i64*
  %42 = load i64, i64* %41
  %43 = getelementptr i64, i64* %41, i32 1
  %44 = load i64, i64* %43
  %45 = and i64 %44, 15
  %46 = icmp ne i64 %45, 0
  br i1 %46, label %$21, label %$19
$21:
  %47 = phi i64 [%44, %$18] ; # Prg
  %48 = and i64 %42, 6
  %49 = icmp ne i64 %48, 0
  br i1 %49, label %$24, label %$23
$24:
  br label %$22
$23:
  %50 = and i64 %42, 8
  %51 = icmp ne i64 %50, 0
  br i1 %51, label %$26, label %$25
$26:
  %52 = inttoptr i64 %42 to i64*
  %53 = load i64, i64* %52
  br label %$22
$25:
  %54 = call i64 @evList(i64 %42)
  br label %$22
$22:
  %55 = phi i64 [%42, %$24], [%53, %$26], [%54, %$25] ; # ->
  br label %$20
$19:
  %56 = phi i64 [%44, %$18] ; # Prg
  %57 = and i64 %42, 15
  %58 = icmp eq i64 %57, 0
  br i1 %58, label %$28, label %$27
$28:
  %59 = phi i64 [%56, %$19] ; # Prg
  %60 = call i64 @evList(i64 %42)
  %61 = icmp ne i64 %60, 0
  br label %$27
$27:
  %62 = phi i64 [%56, %$19], [%59, %$28] ; # Prg
  %63 = phi i1 [0, %$19], [%61, %$28] ; # ->
  br label %$18
$20:
  %64 = phi i64 [%47, %$22] ; # Prg
  %65 = phi i64 [%55, %$22] ; # ->
  br label %$16
$15:
  %66 = phi i64 [%19, %$10] ; # X
  %67 = phi i64 [%23, %$10] ; # E
; # (set $At @)
  %68 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  store i64 %33, i64* %68
  br label %$5
$8:
  %69 = phi i64 [%14, %$6] ; # X
  %70 = phi i64 [%15, %$6] ; # E
; # (car E)
  %71 = inttoptr i64 %70 to i64*
  %72 = load i64, i64* %71
; # (t? (car E))
  %73 = icmp eq i64 %72, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %73, label %$30, label %$29
$30:
  %74 = phi i64 [%69, %$8] ; # X
  %75 = phi i64 [%70, %$8] ; # E
; # (? (not (nil? (eval (car (shift E))))) (set $At @) (run (cdr E)))...
; # (shift E)
  %76 = inttoptr i64 %75 to i64*
  %77 = getelementptr i64, i64* %76, i32 1
  %78 = load i64, i64* %77
; # (car (shift E))
  %79 = inttoptr i64 %78 to i64*
  %80 = load i64, i64* %79
; # (eval (car (shift E)))
  %81 = and i64 %80, 6
  %82 = icmp ne i64 %81, 0
  br i1 %82, label %$33, label %$32
$33:
  br label %$31
$32:
  %83 = and i64 %80, 8
  %84 = icmp ne i64 %83, 0
  br i1 %84, label %$35, label %$34
$35:
  %85 = inttoptr i64 %80 to i64*
  %86 = load i64, i64* %85
  br label %$31
$34:
  %87 = call i64 @evList(i64 %80)
  br label %$31
$31:
  %88 = phi i64 [%80, %$33], [%86, %$35], [%87, %$34] ; # ->
; # (nil? (eval (car (shift E))))
  %89 = icmp eq i64 %88, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
; # (not (nil? (eval (car (shift E)))))
  %90 = icmp eq i1 %89, 0
  br i1 %90, label %$37, label %$36
$37:
  %91 = phi i64 [%74, %$31] ; # X
  %92 = phi i64 [%78, %$31] ; # E
; # (set $At @)
  %93 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  store i64 %88, i64* %93
; # (cdr E)
  %94 = inttoptr i64 %92 to i64*
  %95 = getelementptr i64, i64* %94, i32 1
  %96 = load i64, i64* %95
; # (run (cdr E))
  br label %$38
$38:
  %97 = phi i64 [%96, %$37], [%119, %$47] ; # Prg
  %98 = inttoptr i64 %97 to i64*
  %99 = load i64, i64* %98
  %100 = getelementptr i64, i64* %98, i32 1
  %101 = load i64, i64* %100
  %102 = and i64 %101, 15
  %103 = icmp ne i64 %102, 0
  br i1 %103, label %$41, label %$39
$41:
  %104 = phi i64 [%101, %$38] ; # Prg
  %105 = and i64 %99, 6
  %106 = icmp ne i64 %105, 0
  br i1 %106, label %$44, label %$43
$44:
  br label %$42
$43:
  %107 = and i64 %99, 8
  %108 = icmp ne i64 %107, 0
  br i1 %108, label %$46, label %$45
$46:
  %109 = inttoptr i64 %99 to i64*
  %110 = load i64, i64* %109
  br label %$42
$45:
  %111 = call i64 @evList(i64 %99)
  br label %$42
$42:
  %112 = phi i64 [%99, %$44], [%110, %$46], [%111, %$45] ; # ->
  br label %$40
$39:
  %113 = phi i64 [%101, %$38] ; # Prg
  %114 = and i64 %99, 15
  %115 = icmp eq i64 %114, 0
  br i1 %115, label %$48, label %$47
$48:
  %116 = phi i64 [%113, %$39] ; # Prg
  %117 = call i64 @evList(i64 %99)
  %118 = icmp ne i64 %117, 0
  br label %$47
$47:
  %119 = phi i64 [%113, %$39], [%116, %$48] ; # Prg
  %120 = phi i1 [0, %$39], [%118, %$48] ; # ->
  br label %$38
$40:
  %121 = phi i64 [%104, %$42] ; # Prg
  %122 = phi i64 [%112, %$42] ; # ->
  br label %$16
$36:
  %123 = phi i64 [%74, %$31] ; # X
  %124 = phi i64 [%78, %$31] ; # E
  br label %$5
$29:
  %125 = phi i64 [%69, %$8] ; # X
  %126 = phi i64 [%70, %$8] ; # E
; # (evList E)
  %127 = call i64 @evList(i64 %126)
  br label %$5
$5:
  %128 = phi i64 [%10, %$7], [%66, %$15], [%123, %$36], [%125, %$29] ; # X
  %129 = phi i64 [%11, %$7], [%67, %$15], [%124, %$36], [%126, %$29] ; # E
  %130 = phi i64 [%13, %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$15], [%88, %$36], [%127, %$29] ; # ->
  br label %$4
$4:
  %131 = phi i64 [%1, %$2], [%128, %$5] ; # X
  %132 = phi i64 [%3, %$2], [%130, %$5] ; # E
; # (? (atom (shift X)) (| E 1))
; # (shift X)
  %133 = inttoptr i64 %131 to i64*
  %134 = getelementptr i64, i64* %133, i32 1
  %135 = load i64, i64* %134
; # (atom (shift X))
  %136 = and i64 %135, 15
  %137 = icmp ne i64 %136, 0
  br i1 %137, label %$50, label %$49
$50:
  %138 = phi i64 [%135, %$4] ; # X
  %139 = phi i64 [%132, %$4] ; # E
; # (| E 1)
  %140 = or i64 %139, 1
  br label %$16
$49:
  %141 = phi i64 [%135, %$4] ; # X
  %142 = phi i64 [%132, %$4] ; # E
  br label %$2
$16:
  %143 = phi i64 [%35, %$20], [%91, %$40], [%138, %$50] ; # X
  %144 = phi i64 [%65, %$20], [%122, %$40], [%140, %$50] ; # ->
  ret i64 %144
}

define i64 @loop2(i64) align 8 {
$1:
; # (loop (let X Y (loop (let E (car X) (when (pair E) (cond ((nil? (...
  br label %$2
$2:
; # (let X Y (loop (let E (car X) (when (pair E) (cond ((nil? (car E)...
; # (loop (let E (car X) (when (pair E) (cond ((nil? (car E)) (when (...
  br label %$3
$3:
  %1 = phi i64 [%0, %$2], [%128, %$47] ; # X
; # (let E (car X) (when (pair E) (cond ((nil? (car E)) (when (nil? (...
; # (car X)
  %2 = inttoptr i64 %1 to i64*
  %3 = load i64, i64* %2
; # (when (pair E) (cond ((nil? (car E)) (when (nil? (eval (car (shif...
; # (pair E)
  %4 = and i64 %3, 15
  %5 = icmp eq i64 %4, 0
  br i1 %5, label %$4, label %$5
$4:
  %6 = phi i64 [%1, %$3] ; # X
  %7 = phi i64 [%3, %$3] ; # E
; # (cond ((nil? (car E)) (when (nil? (eval (car (shift E)))) (ret (r...
; # (car E)
  %8 = inttoptr i64 %7 to i64*
  %9 = load i64, i64* %8
; # (nil? (car E))
  %10 = icmp eq i64 %9, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %10, label %$8, label %$7
$8:
  %11 = phi i64 [%6, %$4] ; # X
  %12 = phi i64 [%7, %$4] ; # E
; # (when (nil? (eval (car (shift E)))) (ret (run (cdr E))))
; # (shift E)
  %13 = inttoptr i64 %12 to i64*
  %14 = getelementptr i64, i64* %13, i32 1
  %15 = load i64, i64* %14
; # (car (shift E))
  %16 = inttoptr i64 %15 to i64*
  %17 = load i64, i64* %16
; # (eval (car (shift E)))
  %18 = and i64 %17, 6
  %19 = icmp ne i64 %18, 0
  br i1 %19, label %$11, label %$10
$11:
  br label %$9
$10:
  %20 = and i64 %17, 8
  %21 = icmp ne i64 %20, 0
  br i1 %21, label %$13, label %$12
$13:
  %22 = inttoptr i64 %17 to i64*
  %23 = load i64, i64* %22
  br label %$9
$12:
  %24 = call i64 @evList(i64 %17)
  br label %$9
$9:
  %25 = phi i64 [%17, %$11], [%23, %$13], [%24, %$12] ; # ->
; # (nil? (eval (car (shift E))))
  %26 = icmp eq i64 %25, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %26, label %$14, label %$15
$14:
  %27 = phi i64 [%11, %$9] ; # X
  %28 = phi i64 [%15, %$9] ; # E
; # (cdr E)
  %29 = inttoptr i64 %28 to i64*
  %30 = getelementptr i64, i64* %29, i32 1
  %31 = load i64, i64* %30
; # (run (cdr E))
  br label %$16
$16:
  %32 = phi i64 [%31, %$14], [%54, %$25] ; # Prg
  %33 = inttoptr i64 %32 to i64*
  %34 = load i64, i64* %33
  %35 = getelementptr i64, i64* %33, i32 1
  %36 = load i64, i64* %35
  %37 = and i64 %36, 15
  %38 = icmp ne i64 %37, 0
  br i1 %38, label %$19, label %$17
$19:
  %39 = phi i64 [%36, %$16] ; # Prg
  %40 = and i64 %34, 6
  %41 = icmp ne i64 %40, 0
  br i1 %41, label %$22, label %$21
$22:
  br label %$20
$21:
  %42 = and i64 %34, 8
  %43 = icmp ne i64 %42, 0
  br i1 %43, label %$24, label %$23
$24:
  %44 = inttoptr i64 %34 to i64*
  %45 = load i64, i64* %44
  br label %$20
$23:
  %46 = call i64 @evList(i64 %34)
  br label %$20
$20:
  %47 = phi i64 [%34, %$22], [%45, %$24], [%46, %$23] ; # ->
  br label %$18
$17:
  %48 = phi i64 [%36, %$16] ; # Prg
  %49 = and i64 %34, 15
  %50 = icmp eq i64 %49, 0
  br i1 %50, label %$26, label %$25
$26:
  %51 = phi i64 [%48, %$17] ; # Prg
  %52 = call i64 @evList(i64 %34)
  %53 = icmp ne i64 %52, 0
  br label %$25
$25:
  %54 = phi i64 [%48, %$17], [%51, %$26] ; # Prg
  %55 = phi i1 [0, %$17], [%53, %$26] ; # ->
  br label %$16
$18:
  %56 = phi i64 [%39, %$20] ; # Prg
  %57 = phi i64 [%47, %$20] ; # ->
; # (ret (run (cdr E)))
  ret i64 %57
$15:
  %58 = phi i64 [%11, %$9] ; # X
  %59 = phi i64 [%15, %$9] ; # E
; # (set $At @)
  %60 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  store i64 %25, i64* %60
  br label %$6
$7:
  %61 = phi i64 [%6, %$4] ; # X
  %62 = phi i64 [%7, %$4] ; # E
; # (car E)
  %63 = inttoptr i64 %62 to i64*
  %64 = load i64, i64* %63
; # (t? (car E))
  %65 = icmp eq i64 %64, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %65, label %$28, label %$27
$28:
  %66 = phi i64 [%61, %$7] ; # X
  %67 = phi i64 [%62, %$7] ; # E
; # (unless (nil? (eval (car (shift E)))) (set $At @) (ret (run (cdr ...
; # (shift E)
  %68 = inttoptr i64 %67 to i64*
  %69 = getelementptr i64, i64* %68, i32 1
  %70 = load i64, i64* %69
; # (car (shift E))
  %71 = inttoptr i64 %70 to i64*
  %72 = load i64, i64* %71
; # (eval (car (shift E)))
  %73 = and i64 %72, 6
  %74 = icmp ne i64 %73, 0
  br i1 %74, label %$31, label %$30
$31:
  br label %$29
$30:
  %75 = and i64 %72, 8
  %76 = icmp ne i64 %75, 0
  br i1 %76, label %$33, label %$32
$33:
  %77 = inttoptr i64 %72 to i64*
  %78 = load i64, i64* %77
  br label %$29
$32:
  %79 = call i64 @evList(i64 %72)
  br label %$29
$29:
  %80 = phi i64 [%72, %$31], [%78, %$33], [%79, %$32] ; # ->
; # (nil? (eval (car (shift E))))
  %81 = icmp eq i64 %80, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %81, label %$35, label %$34
$34:
  %82 = phi i64 [%66, %$29] ; # X
  %83 = phi i64 [%70, %$29] ; # E
; # (set $At @)
  %84 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  store i64 %80, i64* %84
; # (cdr E)
  %85 = inttoptr i64 %83 to i64*
  %86 = getelementptr i64, i64* %85, i32 1
  %87 = load i64, i64* %86
; # (run (cdr E))
  br label %$36
$36:
  %88 = phi i64 [%87, %$34], [%110, %$45] ; # Prg
  %89 = inttoptr i64 %88 to i64*
  %90 = load i64, i64* %89
  %91 = getelementptr i64, i64* %89, i32 1
  %92 = load i64, i64* %91
  %93 = and i64 %92, 15
  %94 = icmp ne i64 %93, 0
  br i1 %94, label %$39, label %$37
$39:
  %95 = phi i64 [%92, %$36] ; # Prg
  %96 = and i64 %90, 6
  %97 = icmp ne i64 %96, 0
  br i1 %97, label %$42, label %$41
$42:
  br label %$40
$41:
  %98 = and i64 %90, 8
  %99 = icmp ne i64 %98, 0
  br i1 %99, label %$44, label %$43
$44:
  %100 = inttoptr i64 %90 to i64*
  %101 = load i64, i64* %100
  br label %$40
$43:
  %102 = call i64 @evList(i64 %90)
  br label %$40
$40:
  %103 = phi i64 [%90, %$42], [%101, %$44], [%102, %$43] ; # ->
  br label %$38
$37:
  %104 = phi i64 [%92, %$36] ; # Prg
  %105 = and i64 %90, 15
  %106 = icmp eq i64 %105, 0
  br i1 %106, label %$46, label %$45
$46:
  %107 = phi i64 [%104, %$37] ; # Prg
  %108 = call i64 @evList(i64 %90)
  %109 = icmp ne i64 %108, 0
  br label %$45
$45:
  %110 = phi i64 [%104, %$37], [%107, %$46] ; # Prg
  %111 = phi i1 [0, %$37], [%109, %$46] ; # ->
  br label %$36
$38:
  %112 = phi i64 [%95, %$40] ; # Prg
  %113 = phi i64 [%103, %$40] ; # ->
; # (ret (run (cdr E)))
  ret i64 %113
$35:
  %114 = phi i64 [%66, %$29] ; # X
  %115 = phi i64 [%70, %$29] ; # E
  br label %$6
$27:
  %116 = phi i64 [%61, %$7] ; # X
  %117 = phi i64 [%62, %$7] ; # E
; # (evList E)
  %118 = call i64 @evList(i64 %117)
  br label %$6
$6:
  %119 = phi i64 [%58, %$15], [%114, %$35], [%116, %$27] ; # X
  %120 = phi i64 [%59, %$15], [%115, %$35], [%117, %$27] ; # E
  br label %$5
$5:
  %121 = phi i64 [%1, %$3], [%119, %$6] ; # X
  %122 = phi i64 [%3, %$3], [%120, %$6] ; # E
; # (? (atom (shift X)))
; # (shift X)
  %123 = inttoptr i64 %121 to i64*
  %124 = getelementptr i64, i64* %123, i32 1
  %125 = load i64, i64* %124
; # (atom (shift X))
  %126 = and i64 %125, 15
  %127 = icmp ne i64 %126, 0
  br i1 %127, label %$48, label %$47
$47:
  %128 = phi i64 [%125, %$5] ; # X
  br label %$3
$48:
  %129 = phi i64 [%125, %$5] ; # X
  %130 = phi i64 [0, %$5] ; # ->
  br label %$2
}

define i64 @_Do(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (eval (++ X))) (cond ((nil? Y) Y) ((cnt? Y) (...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (cond ((nil? Y) Y) ((cnt? Y) (let N (int Y) (if (or (sign? Y) (=0...
; # (nil? Y)
  %16 = icmp eq i64 %15, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %16, label %$9, label %$8
$9:
  br label %$7
$8:
; # (cnt? Y)
  %17 = and i64 %15, 2
  %18 = icmp ne i64 %17, 0
  br i1 %18, label %$11, label %$10
$11:
; # (let N (int Y) (if (or (sign? Y) (=0 N)) $Nil (loop (let R (loop1...
; # (int Y)
  %19 = lshr i64 %15, 4
; # (if (or (sign? Y) (=0 N)) $Nil (loop (let R (loop1 X) (? (=0 (& R...
; # (or (sign? Y) (=0 N))
; # (sign? Y)
  %20 = and i64 %15, 8
  %21 = icmp ne i64 %20, 0
  br i1 %21, label %$12, label %$13
$13:
  %22 = phi i64 [%19, %$11] ; # N
; # (=0 N)
  %23 = icmp eq i64 %22, 0
  br label %$12
$12:
  %24 = phi i64 [%19, %$11], [%22, %$13] ; # N
  %25 = phi i1 [1, %$11], [%23, %$13] ; # ->
  br i1 %25, label %$14, label %$15
$14:
  %26 = phi i64 [%24, %$12] ; # N
  br label %$16
$15:
  %27 = phi i64 [%24, %$12] ; # N
; # (loop (let R (loop1 X) (? (=0 (& R 1)) R) (? (=0 (dec 'N)) (& R -...
  br label %$17
$17:
  %28 = phi i64 [%27, %$15], [%38, %$21] ; # N
; # (let R (loop1 X) (? (=0 (& R 1)) R) (? (=0 (dec 'N)) (& R -2)))
; # (loop1 X)
  %29 = call i64 @loop1(i64 %7)
; # (? (=0 (& R 1)) R)
; # (& R 1)
  %30 = and i64 %29, 1
; # (=0 (& R 1))
  %31 = icmp eq i64 %30, 0
  br i1 %31, label %$20, label %$18
$20:
  %32 = phi i64 [%28, %$17] ; # N
  br label %$19
$18:
  %33 = phi i64 [%28, %$17] ; # N
; # (? (=0 (dec 'N)) (& R -2))
; # (dec 'N)
  %34 = sub i64 %33, 1
; # (=0 (dec 'N))
  %35 = icmp eq i64 %34, 0
  br i1 %35, label %$22, label %$21
$22:
  %36 = phi i64 [%34, %$18] ; # N
; # (& R -2)
  %37 = and i64 %29, -2
  br label %$19
$21:
  %38 = phi i64 [%34, %$18] ; # N
  br label %$17
$19:
  %39 = phi i64 [%32, %$20], [%36, %$22] ; # N
  %40 = phi i64 [%29, %$20], [%37, %$22] ; # ->
  br label %$16
$16:
  %41 = phi i64 [%26, %$14], [%39, %$19] ; # N
  %42 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$14], [%40, %$19] ; # ->
  br label %$7
$10:
; # (loop2 X)
  %43 = call i64 @loop2(i64 %7)
  br label %$7
$7:
  %44 = phi i64 [%15, %$9], [%42, %$16], [%43, %$10] ; # ->
  ret i64 %44
}

define i64 @_Loop(i64) align 8 {
$1:
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (loop2 (cdr Exe))
  %4 = tail call i64 @loop2(i64 %3)
  ret i64 %4
}

define i64 @_For(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (++ X) R $Nil) (cond ((atom Y) (needChkVar Ex...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (cond ((atom Y) (needChkVar Exe Y) (let P (set $Bind (push NIL NI...
; # (atom Y)
  %8 = and i64 %5, 15
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  %10 = phi i64 [%7, %$1] ; # X
  %11 = phi i64 [%5, %$1] ; # Y
  %12 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$1] ; # R
; # (needChkVar Exe Y)
  %13 = and i64 %11, 6
  %14 = icmp ne i64 %13, 0
  br i1 %14, label %$5, label %$6
$5:
  call void @varErr(i64 %0, i64 %11)
  unreachable
$6:
  %15 = icmp uge i64 %11, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %15, label %$8, label %$7
$8:
  %16 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %11
  br label %$7
$7:
  %17 = phi i1 [0, %$6], [%16, %$8] ; # ->
  br i1 %17, label %$9, label %$10
$9:
  call void @protErr(i64 %0, i64 %11)
  unreachable
$10:
; # (let P (set $Bind (push NIL NIL (val $Bind))) (set P (val Y) 2 P ...
; # (set $Bind (push NIL NIL (val $Bind)))
; # (val $Bind)
  %18 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  %19 = load i64, i64* %18
; # (push NIL NIL (val $Bind))
  %20 = alloca i64, i64 3, align 16
  %21 = ptrtoint i64* %20 to i64
  %22 = add i64 %21, 16
  %23 = inttoptr i64 %22 to i64*
  store i64 %19, i64* %23
  %24 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %21, i64* %24
; # (set P (val Y) 2 P Y)
; # (val Y)
  %25 = inttoptr i64 %11 to i64*
  %26 = load i64, i64* %25
  %27 = inttoptr i64 %21 to i64*
  store i64 %26, i64* %27
  %28 = inttoptr i64 %21 to i64*
  %29 = getelementptr i64, i64* %28, i32 1
  store i64 %11, i64* %29
; # (let V (eval (++ X)) (if (num? V) (unless (sign? V) (set Y ZERO) ...
; # (++ X)
  %30 = inttoptr i64 %10 to i64*
  %31 = load i64, i64* %30
  %32 = getelementptr i64, i64* %30, i32 1
  %33 = load i64, i64* %32
; # (eval (++ X))
  %34 = and i64 %31, 6
  %35 = icmp ne i64 %34, 0
  br i1 %35, label %$13, label %$12
$13:
  br label %$11
$12:
  %36 = and i64 %31, 8
  %37 = icmp ne i64 %36, 0
  br i1 %37, label %$15, label %$14
$15:
  %38 = inttoptr i64 %31 to i64*
  %39 = load i64, i64* %38
  br label %$11
$14:
  %40 = call i64 @evList(i64 %31)
  br label %$11
$11:
  %41 = phi i64 [%31, %$13], [%39, %$15], [%40, %$14] ; # ->
; # (if (num? V) (unless (sign? V) (set Y ZERO) (loop (? (> (+ (val Y...
; # (num? V)
  %42 = and i64 %41, 6
  %43 = icmp ne i64 %42, 0
  br i1 %43, label %$16, label %$17
$16:
  %44 = phi i64 [%33, %$11] ; # X
  %45 = phi i64 [%11, %$11] ; # Y
  %46 = phi i64 [%12, %$11] ; # R
  %47 = phi i64 [%41, %$11] ; # V
; # (unless (sign? V) (set Y ZERO) (loop (? (> (+ (val Y) (hex "10"))...
; # (sign? V)
  %48 = and i64 %47, 8
  %49 = icmp ne i64 %48, 0
  br i1 %49, label %$20, label %$19
$19:
  %50 = phi i64 [%44, %$16] ; # X
  %51 = phi i64 [%45, %$16] ; # Y
  %52 = phi i64 [%46, %$16] ; # R
  %53 = phi i64 [%47, %$16] ; # V
; # (set Y ZERO)
  %54 = inttoptr i64 %51 to i64*
  store i64 2, i64* %54
; # (loop (? (> (+ (val Y) (hex "10")) V) (setq R (& R -2))) (set Y @...
  br label %$21
$21:
  %55 = phi i64 [%50, %$19], [%76, %$25] ; # X
  %56 = phi i64 [%51, %$19], [%77, %$25] ; # Y
  %57 = phi i64 [%52, %$19], [%78, %$25] ; # R
  %58 = phi i64 [%53, %$19], [%79, %$25] ; # V
; # (? (> (+ (val Y) (hex "10")) V) (setq R (& R -2)))
; # (val Y)
  %59 = inttoptr i64 %56 to i64*
  %60 = load i64, i64* %59
; # (+ (val Y) (hex "10"))
  %61 = add i64 %60, 16
; # (> (+ (val Y) (hex "10")) V)
  %62 = icmp ugt i64 %61, %58
  br i1 %62, label %$24, label %$22
$24:
  %63 = phi i64 [%55, %$21] ; # X
  %64 = phi i64 [%56, %$21] ; # Y
  %65 = phi i64 [%57, %$21] ; # R
  %66 = phi i64 [%58, %$21] ; # V
; # (& R -2)
  %67 = and i64 %65, -2
  br label %$23
$22:
  %68 = phi i64 [%55, %$21] ; # X
  %69 = phi i64 [%56, %$21] ; # Y
  %70 = phi i64 [%57, %$21] ; # R
  %71 = phi i64 [%58, %$21] ; # V
; # (set Y @)
  %72 = inttoptr i64 %69 to i64*
  store i64 %61, i64* %72
; # (? (=0 (& (setq R (loop1 X)) 1)))
; # (loop1 X)
  %73 = call i64 @loop1(i64 %68)
; # (& (setq R (loop1 X)) 1)
  %74 = and i64 %73, 1
; # (=0 (& (setq R (loop1 X)) 1))
  %75 = icmp eq i64 %74, 0
  br i1 %75, label %$23, label %$25
$25:
  %76 = phi i64 [%68, %$22] ; # X
  %77 = phi i64 [%69, %$22] ; # Y
  %78 = phi i64 [%73, %$22] ; # R
  %79 = phi i64 [%71, %$22] ; # V
  br label %$21
$23:
  %80 = phi i64 [%63, %$24], [%68, %$22] ; # X
  %81 = phi i64 [%64, %$24], [%69, %$22] ; # Y
  %82 = phi i64 [%67, %$24], [%73, %$22] ; # R
  %83 = phi i64 [%66, %$24], [%71, %$22] ; # V
  %84 = phi i64 [%67, %$24], [0, %$22] ; # ->
  br label %$20
$20:
  %85 = phi i64 [%44, %$16], [%80, %$23] ; # X
  %86 = phi i64 [%45, %$16], [%81, %$23] ; # Y
  %87 = phi i64 [%46, %$16], [%82, %$23] ; # R
  %88 = phi i64 [%47, %$16], [%83, %$23] ; # V
  br label %$18
$17:
  %89 = phi i64 [%33, %$11] ; # X
  %90 = phi i64 [%11, %$11] ; # Y
  %91 = phi i64 [%12, %$11] ; # R
  %92 = phi i64 [%41, %$11] ; # V
; # (save V (loop (? (atom V) (setq R (& R -2))) (set Y (car V)) (? (...
  %93 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %94 = load i64, i64* %93
  %95 = alloca i64, i64 2, align 16
  %96 = ptrtoint i64* %95 to i64
  %97 = inttoptr i64 %96 to i64*
  store i64 %92, i64* %97
  %98 = add i64 %96, 8
  %99 = inttoptr i64 %98 to i64*
  store i64 %94, i64* %99
  %100 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %96, i64* %100
; # (loop (? (atom V) (setq R (& R -2))) (set Y (car V)) (? (=0 (& (s...
  br label %$26
$26:
  %101 = phi i64 [%89, %$17], [%122, %$30] ; # X
  %102 = phi i64 [%90, %$17], [%123, %$30] ; # Y
  %103 = phi i64 [%91, %$17], [%124, %$30] ; # R
  %104 = phi i64 [%92, %$17], [%128, %$30] ; # V
; # (? (atom V) (setq R (& R -2)))
; # (atom V)
  %105 = and i64 %104, 15
  %106 = icmp ne i64 %105, 0
  br i1 %106, label %$29, label %$27
$29:
  %107 = phi i64 [%101, %$26] ; # X
  %108 = phi i64 [%102, %$26] ; # Y
  %109 = phi i64 [%103, %$26] ; # R
  %110 = phi i64 [%104, %$26] ; # V
; # (& R -2)
  %111 = and i64 %109, -2
  br label %$28
$27:
  %112 = phi i64 [%101, %$26] ; # X
  %113 = phi i64 [%102, %$26] ; # Y
  %114 = phi i64 [%103, %$26] ; # R
  %115 = phi i64 [%104, %$26] ; # V
; # (set Y (car V))
; # (car V)
  %116 = inttoptr i64 %115 to i64*
  %117 = load i64, i64* %116
  %118 = inttoptr i64 %113 to i64*
  store i64 %117, i64* %118
; # (? (=0 (& (setq R (loop1 X)) 1)))
; # (loop1 X)
  %119 = call i64 @loop1(i64 %112)
; # (& (setq R (loop1 X)) 1)
  %120 = and i64 %119, 1
; # (=0 (& (setq R (loop1 X)) 1))
  %121 = icmp eq i64 %120, 0
  br i1 %121, label %$28, label %$30
$30:
  %122 = phi i64 [%112, %$27] ; # X
  %123 = phi i64 [%113, %$27] ; # Y
  %124 = phi i64 [%119, %$27] ; # R
  %125 = phi i64 [%115, %$27] ; # V
; # (shift V)
  %126 = inttoptr i64 %125 to i64*
  %127 = getelementptr i64, i64* %126, i32 1
  %128 = load i64, i64* %127
  br label %$26
$28:
  %129 = phi i64 [%107, %$29], [%112, %$27] ; # X
  %130 = phi i64 [%108, %$29], [%113, %$27] ; # Y
  %131 = phi i64 [%111, %$29], [%119, %$27] ; # R
  %132 = phi i64 [%110, %$29], [%115, %$27] ; # V
  %133 = phi i64 [%111, %$29], [0, %$27] ; # ->
; # drop
  %134 = inttoptr i64 %96 to i64*
  %135 = getelementptr i64, i64* %134, i32 1
  %136 = load i64, i64* %135
  %137 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %136, i64* %137
  br label %$18
$18:
  %138 = phi i64 [%85, %$20], [%129, %$28] ; # X
  %139 = phi i64 [%86, %$20], [%130, %$28] ; # Y
  %140 = phi i64 [%87, %$20], [%131, %$28] ; # R
  %141 = phi i64 [%88, %$20], [%132, %$28] ; # V
; # (set Y (val P) $Bind (val 3 P))
; # (val P)
  %142 = inttoptr i64 %21 to i64*
  %143 = load i64, i64* %142
  %144 = inttoptr i64 %139 to i64*
  store i64 %143, i64* %144
; # (val 3 P)
  %145 = inttoptr i64 %21 to i64*
  %146 = getelementptr i64, i64* %145, i32 2
  %147 = load i64, i64* %146
  %148 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %147, i64* %148
  br label %$2
$3:
  %149 = phi i64 [%7, %$1] ; # X
  %150 = phi i64 [%5, %$1] ; # Y
  %151 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$1] ; # R
; # (cdr Y)
  %152 = inttoptr i64 %150 to i64*
  %153 = getelementptr i64, i64* %152, i32 1
  %154 = load i64, i64* %153
; # (atom (cdr Y))
  %155 = and i64 %154, 15
  %156 = icmp ne i64 %155, 0
  br i1 %156, label %$32, label %$31
$32:
  %157 = phi i64 [%149, %$3] ; # X
  %158 = phi i64 [%150, %$3] ; # Y
  %159 = phi i64 [%151, %$3] ; # R
; # (let Sym2 (needChkVar Exe @) (needChkVar Exe (setq Y (car Y))) (l...
; # (needChkVar Exe @)
  %160 = and i64 %154, 6
  %161 = icmp ne i64 %160, 0
  br i1 %161, label %$33, label %$34
$33:
  call void @varErr(i64 %0, i64 %154)
  unreachable
$34:
  %162 = icmp uge i64 %154, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %162, label %$36, label %$35
$36:
  %163 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %154
  br label %$35
$35:
  %164 = phi i1 [0, %$34], [%163, %$36] ; # ->
  br i1 %164, label %$37, label %$38
$37:
  call void @protErr(i64 %0, i64 %154)
  unreachable
$38:
; # (car Y)
  %165 = inttoptr i64 %158 to i64*
  %166 = load i64, i64* %165
; # (needChkVar Exe (setq Y (car Y)))
  %167 = and i64 %166, 6
  %168 = icmp ne i64 %167, 0
  br i1 %168, label %$39, label %$40
$39:
  call void @varErr(i64 %0, i64 %166)
  unreachable
$40:
  %169 = icmp uge i64 %166, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %169, label %$42, label %$41
$42:
  %170 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %166
  br label %$41
$41:
  %171 = phi i1 [0, %$40], [%170, %$42] ; # ->
  br i1 %171, label %$43, label %$44
$43:
  call void @protErr(i64 %0, i64 %166)
  unreachable
$44:
; # (let P (set $Bind (push NIL NIL (val $Bind))) (set P (val Y) 2 P ...
; # (set $Bind (push NIL NIL (val $Bind)))
; # (val $Bind)
  %172 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  %173 = load i64, i64* %172
; # (push NIL NIL (val $Bind))
  %174 = alloca i64, i64 3, align 16
  %175 = ptrtoint i64* %174 to i64
  %176 = add i64 %175, 16
  %177 = inttoptr i64 %176 to i64*
  store i64 %173, i64* %177
  %178 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %175, i64* %178
; # (set P (val Y) 2 P Y)
; # (val Y)
  %179 = inttoptr i64 %166 to i64*
  %180 = load i64, i64* %179
  %181 = inttoptr i64 %175 to i64*
  store i64 %180, i64* %181
  %182 = inttoptr i64 %175 to i64*
  %183 = getelementptr i64, i64* %182, i32 1
  store i64 %166, i64* %183
; # (let (Q (set $Bind (push (val Sym2) Sym2 (val $Bind))) V (save (e...
; # (set $Bind (push (val Sym2) Sym2 (val $Bind)))
; # (val Sym2)
  %184 = inttoptr i64 %154 to i64*
  %185 = load i64, i64* %184
; # (val $Bind)
  %186 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  %187 = load i64, i64* %186
; # (push (val Sym2) Sym2 (val $Bind))
  %188 = alloca i64, i64 3, align 16
  %189 = ptrtoint i64* %188 to i64
  %190 = inttoptr i64 %189 to i64*
  store i64 %185, i64* %190
  %191 = add i64 %189, 8
  %192 = inttoptr i64 %191 to i64*
  store i64 %154, i64* %192
  %193 = add i64 %189, 16
  %194 = inttoptr i64 %193 to i64*
  store i64 %187, i64* %194
  %195 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %189, i64* %195
; # (++ X)
  %196 = inttoptr i64 %157 to i64*
  %197 = load i64, i64* %196
  %198 = getelementptr i64, i64* %196, i32 1
  %199 = load i64, i64* %198
; # (eval (++ X))
  %200 = and i64 %197, 6
  %201 = icmp ne i64 %200, 0
  br i1 %201, label %$47, label %$46
$47:
  br label %$45
$46:
  %202 = and i64 %197, 8
  %203 = icmp ne i64 %202, 0
  br i1 %203, label %$49, label %$48
$49:
  %204 = inttoptr i64 %197 to i64*
  %205 = load i64, i64* %204
  br label %$45
$48:
  %206 = call i64 @evList(i64 %197)
  br label %$45
$45:
  %207 = phi i64 [%197, %$47], [%205, %$49], [%206, %$48] ; # ->
; # (save (eval (++ X)))
  %208 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %209 = load i64, i64* %208
  %210 = alloca i64, i64 2, align 16
  %211 = ptrtoint i64* %210 to i64
  %212 = inttoptr i64 %211 to i64*
  store i64 %207, i64* %212
  %213 = add i64 %211, 8
  %214 = inttoptr i64 %213 to i64*
  store i64 %209, i64* %214
  %215 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %211, i64* %215
; # (set Y ONE)
  %216 = inttoptr i64 %166 to i64*
  store i64 18, i64* %216
; # (loop (? (atom V) (setq R (& R -2))) (set Sym2 (car V)) (? (=0 (&...
  br label %$50
$50:
  %217 = phi i64 [%199, %$45], [%238, %$54] ; # X
  %218 = phi i64 [%166, %$45], [%239, %$54] ; # Y
  %219 = phi i64 [%159, %$45], [%240, %$54] ; # R
  %220 = phi i64 [%207, %$45], [%248, %$54] ; # V
; # (? (atom V) (setq R (& R -2)))
; # (atom V)
  %221 = and i64 %220, 15
  %222 = icmp ne i64 %221, 0
  br i1 %222, label %$53, label %$51
$53:
  %223 = phi i64 [%217, %$50] ; # X
  %224 = phi i64 [%218, %$50] ; # Y
  %225 = phi i64 [%219, %$50] ; # R
  %226 = phi i64 [%220, %$50] ; # V
; # (& R -2)
  %227 = and i64 %225, -2
  br label %$52
$51:
  %228 = phi i64 [%217, %$50] ; # X
  %229 = phi i64 [%218, %$50] ; # Y
  %230 = phi i64 [%219, %$50] ; # R
  %231 = phi i64 [%220, %$50] ; # V
; # (set Sym2 (car V))
; # (car V)
  %232 = inttoptr i64 %231 to i64*
  %233 = load i64, i64* %232
  %234 = inttoptr i64 %154 to i64*
  store i64 %233, i64* %234
; # (? (=0 (& (setq R (loop1 X)) 1)))
; # (loop1 X)
  %235 = call i64 @loop1(i64 %228)
; # (& (setq R (loop1 X)) 1)
  %236 = and i64 %235, 1
; # (=0 (& (setq R (loop1 X)) 1))
  %237 = icmp eq i64 %236, 0
  br i1 %237, label %$52, label %$54
$54:
  %238 = phi i64 [%228, %$51] ; # X
  %239 = phi i64 [%229, %$51] ; # Y
  %240 = phi i64 [%235, %$51] ; # R
  %241 = phi i64 [%231, %$51] ; # V
; # (set Y (+ (val Y) (hex "10")))
; # (val Y)
  %242 = inttoptr i64 %239 to i64*
  %243 = load i64, i64* %242
; # (+ (val Y) (hex "10"))
  %244 = add i64 %243, 16
  %245 = inttoptr i64 %239 to i64*
  store i64 %244, i64* %245
; # (shift V)
  %246 = inttoptr i64 %241 to i64*
  %247 = getelementptr i64, i64* %246, i32 1
  %248 = load i64, i64* %247
  br label %$50
$52:
  %249 = phi i64 [%223, %$53], [%228, %$51] ; # X
  %250 = phi i64 [%224, %$53], [%229, %$51] ; # Y
  %251 = phi i64 [%227, %$53], [%235, %$51] ; # R
  %252 = phi i64 [%226, %$53], [%231, %$51] ; # V
  %253 = phi i64 [%227, %$53], [0, %$51] ; # ->
; # (set Sym2 (val Q))
; # (val Q)
  %254 = inttoptr i64 %189 to i64*
  %255 = load i64, i64* %254
  %256 = inttoptr i64 %154 to i64*
  store i64 %255, i64* %256
; # (drop *Safe)
  %257 = inttoptr i64 %211 to i64*
  %258 = getelementptr i64, i64* %257, i32 1
  %259 = load i64, i64* %258
  %260 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %259, i64* %260
; # (set Y (val P) $Bind (val 3 P))
; # (val P)
  %261 = inttoptr i64 %175 to i64*
  %262 = load i64, i64* %261
  %263 = inttoptr i64 %250 to i64*
  store i64 %262, i64* %263
; # (val 3 P)
  %264 = inttoptr i64 %175 to i64*
  %265 = getelementptr i64, i64* %264, i32 2
  %266 = load i64, i64* %265
  %267 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %266, i64* %267
  br label %$2
$31:
  %268 = phi i64 [%149, %$3] ; # X
  %269 = phi i64 [%150, %$3] ; # Y
  %270 = phi i64 [%151, %$3] ; # R
; # (car Y)
  %271 = inttoptr i64 %269 to i64*
  %272 = load i64, i64* %271
; # (atom (car Y))
  %273 = and i64 %272, 15
  %274 = icmp ne i64 %273, 0
  br i1 %274, label %$56, label %$55
$56:
  %275 = phi i64 [%268, %$31] ; # X
  %276 = phi i64 [%269, %$31] ; # Y
  %277 = phi i64 [%270, %$31] ; # R
; # (let Z (cdr Y) (needChkVar Exe (setq Y @)) (let P (set $Bind (pus...
; # (cdr Y)
  %278 = inttoptr i64 %276 to i64*
  %279 = getelementptr i64, i64* %278, i32 1
  %280 = load i64, i64* %279
; # (needChkVar Exe (setq Y @))
  %281 = and i64 %272, 6
  %282 = icmp ne i64 %281, 0
  br i1 %282, label %$57, label %$58
$57:
  call void @varErr(i64 %0, i64 %272)
  unreachable
$58:
  %283 = icmp uge i64 %272, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %283, label %$60, label %$59
$60:
  %284 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %272
  br label %$59
$59:
  %285 = phi i1 [0, %$58], [%284, %$60] ; # ->
  br i1 %285, label %$61, label %$62
$61:
  call void @protErr(i64 %0, i64 %272)
  unreachable
$62:
; # (let P (set $Bind (push NIL NIL (val $Bind))) (set P (val Y) 2 P ...
; # (set $Bind (push NIL NIL (val $Bind)))
; # (val $Bind)
  %286 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  %287 = load i64, i64* %286
; # (push NIL NIL (val $Bind))
  %288 = alloca i64, i64 3, align 16
  %289 = ptrtoint i64* %288 to i64
  %290 = add i64 %289, 16
  %291 = inttoptr i64 %290 to i64*
  store i64 %287, i64* %291
  %292 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %289, i64* %292
; # (set P (val Y) 2 P Y Y (eval (++ Z)))
; # (val Y)
  %293 = inttoptr i64 %272 to i64*
  %294 = load i64, i64* %293
  %295 = inttoptr i64 %289 to i64*
  store i64 %294, i64* %295
  %296 = inttoptr i64 %289 to i64*
  %297 = getelementptr i64, i64* %296, i32 1
  store i64 %272, i64* %297
; # (++ Z)
  %298 = inttoptr i64 %280 to i64*
  %299 = load i64, i64* %298
  %300 = getelementptr i64, i64* %298, i32 1
  %301 = load i64, i64* %300
; # (eval (++ Z))
  %302 = and i64 %299, 6
  %303 = icmp ne i64 %302, 0
  br i1 %303, label %$65, label %$64
$65:
  br label %$63
$64:
  %304 = and i64 %299, 8
  %305 = icmp ne i64 %304, 0
  br i1 %305, label %$67, label %$66
$67:
  %306 = inttoptr i64 %299 to i64*
  %307 = load i64, i64* %306
  br label %$63
$66:
  %308 = call i64 @evList(i64 %299)
  br label %$63
$63:
  %309 = phi i64 [%299, %$65], [%307, %$67], [%308, %$66] ; # ->
  %310 = inttoptr i64 %272 to i64*
  store i64 %309, i64* %310
; # (save R (loop (? (nil? (eval (car Z)))) (set $At @) (? (=0 (& (se...
  %311 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %312 = load i64, i64* %311
  %313 = alloca i64, i64 2, align 16
  %314 = ptrtoint i64* %313 to i64
  %315 = inttoptr i64 %314 to i64*
  store i64 %277, i64* %315
  %316 = add i64 %314, 8
  %317 = inttoptr i64 %316 to i64*
  store i64 %312, i64* %317
  %318 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %314, i64* %318
; # (loop (? (nil? (eval (car Z)))) (set $At @) (? (=0 (& (setq R (lo...
  br label %$68
$68:
  %319 = phi i64 [%275, %$63], [%384, %$78] ; # X
  %320 = phi i64 [%272, %$63], [%385, %$78] ; # Y
  %321 = phi i64 [%277, %$63], [%386, %$78] ; # R
  %322 = phi i64 [%301, %$63], [%387, %$78] ; # Z
; # (? (nil? (eval (car Z))))
; # (car Z)
  %323 = inttoptr i64 %322 to i64*
  %324 = load i64, i64* %323
; # (eval (car Z))
  %325 = and i64 %324, 6
  %326 = icmp ne i64 %325, 0
  br i1 %326, label %$71, label %$70
$71:
  br label %$69
$70:
  %327 = and i64 %324, 8
  %328 = icmp ne i64 %327, 0
  br i1 %328, label %$73, label %$72
$73:
  %329 = inttoptr i64 %324 to i64*
  %330 = load i64, i64* %329
  br label %$69
$72:
  %331 = call i64 @evList(i64 %324)
  br label %$69
$69:
  %332 = phi i64 [%324, %$71], [%330, %$73], [%331, %$72] ; # ->
; # (nil? (eval (car Z)))
  %333 = icmp eq i64 %332, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %333, label %$75, label %$74
$74:
  %334 = phi i64 [%319, %$69] ; # X
  %335 = phi i64 [%320, %$69] ; # Y
  %336 = phi i64 [%321, %$69] ; # R
  %337 = phi i64 [%322, %$69] ; # Z
; # (set $At @)
  %338 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  store i64 %332, i64* %338
; # (? (=0 (& (setq R (loop1 X)) 1)))
; # (loop1 X)
  %339 = call i64 @loop1(i64 %334)
; # (& (setq R (loop1 X)) 1)
  %340 = and i64 %339, 1
; # (=0 (& (setq R (loop1 X)) 1))
  %341 = icmp eq i64 %340, 0
  br i1 %341, label %$75, label %$76
$76:
  %342 = phi i64 [%334, %$74] ; # X
  %343 = phi i64 [%335, %$74] ; # Y
  %344 = phi i64 [%339, %$74] ; # R
  %345 = phi i64 [%337, %$74] ; # Z
; # (& R -2)
  %346 = and i64 %344, -2
; # (safe (setq R (& R -2)))
  %347 = inttoptr i64 %314 to i64*
  store i64 %346, i64* %347
; # (when (pair (cdr Z)) (set Y (run @)))
; # (cdr Z)
  %348 = inttoptr i64 %345 to i64*
  %349 = getelementptr i64, i64* %348, i32 1
  %350 = load i64, i64* %349
; # (pair (cdr Z))
  %351 = and i64 %350, 15
  %352 = icmp eq i64 %351, 0
  br i1 %352, label %$77, label %$78
$77:
  %353 = phi i64 [%342, %$76] ; # X
  %354 = phi i64 [%343, %$76] ; # Y
  %355 = phi i64 [%346, %$76] ; # R
  %356 = phi i64 [%345, %$76] ; # Z
; # (set Y (run @))
; # (run @)
  br label %$79
$79:
  %357 = phi i64 [%350, %$77], [%379, %$88] ; # Prg
  %358 = inttoptr i64 %357 to i64*
  %359 = load i64, i64* %358
  %360 = getelementptr i64, i64* %358, i32 1
  %361 = load i64, i64* %360
  %362 = and i64 %361, 15
  %363 = icmp ne i64 %362, 0
  br i1 %363, label %$82, label %$80
$82:
  %364 = phi i64 [%361, %$79] ; # Prg
  %365 = and i64 %359, 6
  %366 = icmp ne i64 %365, 0
  br i1 %366, label %$85, label %$84
$85:
  br label %$83
$84:
  %367 = and i64 %359, 8
  %368 = icmp ne i64 %367, 0
  br i1 %368, label %$87, label %$86
$87:
  %369 = inttoptr i64 %359 to i64*
  %370 = load i64, i64* %369
  br label %$83
$86:
  %371 = call i64 @evList(i64 %359)
  br label %$83
$83:
  %372 = phi i64 [%359, %$85], [%370, %$87], [%371, %$86] ; # ->
  br label %$81
$80:
  %373 = phi i64 [%361, %$79] ; # Prg
  %374 = and i64 %359, 15
  %375 = icmp eq i64 %374, 0
  br i1 %375, label %$89, label %$88
$89:
  %376 = phi i64 [%373, %$80] ; # Prg
  %377 = call i64 @evList(i64 %359)
  %378 = icmp ne i64 %377, 0
  br label %$88
$88:
  %379 = phi i64 [%373, %$80], [%376, %$89] ; # Prg
  %380 = phi i1 [0, %$80], [%378, %$89] ; # ->
  br label %$79
$81:
  %381 = phi i64 [%364, %$83] ; # Prg
  %382 = phi i64 [%372, %$83] ; # ->
  %383 = inttoptr i64 %354 to i64*
  store i64 %382, i64* %383
  br label %$78
$78:
  %384 = phi i64 [%342, %$76], [%353, %$81] ; # X
  %385 = phi i64 [%343, %$76], [%354, %$81] ; # Y
  %386 = phi i64 [%346, %$76], [%355, %$81] ; # R
  %387 = phi i64 [%345, %$76], [%356, %$81] ; # Z
  br label %$68
$75:
  %388 = phi i64 [%319, %$69], [%334, %$74] ; # X
  %389 = phi i64 [%320, %$69], [%335, %$74] ; # Y
  %390 = phi i64 [%321, %$69], [%339, %$74] ; # R
  %391 = phi i64 [%322, %$69], [%337, %$74] ; # Z
  %392 = phi i64 [0, %$69], [0, %$74] ; # ->
; # drop
  %393 = inttoptr i64 %314 to i64*
  %394 = getelementptr i64, i64* %393, i32 1
  %395 = load i64, i64* %394
  %396 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %395, i64* %396
; # (set Y (val P) $Bind (val 3 P))
; # (val P)
  %397 = inttoptr i64 %289 to i64*
  %398 = load i64, i64* %397
  %399 = inttoptr i64 %389 to i64*
  store i64 %398, i64* %399
; # (val 3 P)
  %400 = inttoptr i64 %289 to i64*
  %401 = getelementptr i64, i64* %400, i32 2
  %402 = load i64, i64* %401
  %403 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %402, i64* %403
  br label %$2
$55:
  %404 = phi i64 [%268, %$31] ; # X
  %405 = phi i64 [%269, %$31] ; # Y
  %406 = phi i64 [%270, %$31] ; # R
; # (let (Sym2 (cdr @) Z (cdr Y)) (setq Y (car @)) (needChkVar Exe Y)...
; # (cdr @)
  %407 = inttoptr i64 %272 to i64*
  %408 = getelementptr i64, i64* %407, i32 1
  %409 = load i64, i64* %408
; # (cdr Y)
  %410 = inttoptr i64 %405 to i64*
  %411 = getelementptr i64, i64* %410, i32 1
  %412 = load i64, i64* %411
; # (car @)
  %413 = inttoptr i64 %272 to i64*
  %414 = load i64, i64* %413
; # (needChkVar Exe Y)
  %415 = and i64 %414, 6
  %416 = icmp ne i64 %415, 0
  br i1 %416, label %$90, label %$91
$90:
  call void @varErr(i64 %0, i64 %414)
  unreachable
$91:
  %417 = icmp uge i64 %414, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %417, label %$93, label %$92
$93:
  %418 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %414
  br label %$92
$92:
  %419 = phi i1 [0, %$91], [%418, %$93] ; # ->
  br i1 %419, label %$94, label %$95
$94:
  call void @protErr(i64 %0, i64 %414)
  unreachable
$95:
; # (needChkVar Exe Sym2)
  %420 = and i64 %409, 6
  %421 = icmp ne i64 %420, 0
  br i1 %421, label %$96, label %$97
$96:
  call void @varErr(i64 %0, i64 %409)
  unreachable
$97:
  %422 = icmp uge i64 %409, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %422, label %$99, label %$98
$99:
  %423 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %409
  br label %$98
$98:
  %424 = phi i1 [0, %$97], [%423, %$99] ; # ->
  br i1 %424, label %$100, label %$101
$100:
  call void @protErr(i64 %0, i64 %409)
  unreachable
$101:
; # (let P (set $Bind (push NIL NIL (val $Bind))) (set P (val Y) 2 P ...
; # (set $Bind (push NIL NIL (val $Bind)))
; # (val $Bind)
  %425 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  %426 = load i64, i64* %425
; # (push NIL NIL (val $Bind))
  %427 = alloca i64, i64 3, align 16
  %428 = ptrtoint i64* %427 to i64
  %429 = add i64 %428, 16
  %430 = inttoptr i64 %429 to i64*
  store i64 %426, i64* %430
  %431 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %428, i64* %431
; # (set P (val Y) 2 P Y)
; # (val Y)
  %432 = inttoptr i64 %414 to i64*
  %433 = load i64, i64* %432
  %434 = inttoptr i64 %428 to i64*
  store i64 %433, i64* %434
  %435 = inttoptr i64 %428 to i64*
  %436 = getelementptr i64, i64* %435, i32 1
  store i64 %414, i64* %436
; # (save R (let Q (set $Bind (push (val Sym2) Sym2 (val $Bind))) (se...
  %437 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %438 = load i64, i64* %437
  %439 = alloca i64, i64 2, align 16
  %440 = ptrtoint i64* %439 to i64
  %441 = inttoptr i64 %440 to i64*
  store i64 %406, i64* %441
  %442 = add i64 %440, 8
  %443 = inttoptr i64 %442 to i64*
  store i64 %438, i64* %443
  %444 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %440, i64* %444
; # (let Q (set $Bind (push (val Sym2) Sym2 (val $Bind))) (set Sym2 (...
; # (set $Bind (push (val Sym2) Sym2 (val $Bind)))
; # (val Sym2)
  %445 = inttoptr i64 %409 to i64*
  %446 = load i64, i64* %445
; # (val $Bind)
  %447 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  %448 = load i64, i64* %447
; # (push (val Sym2) Sym2 (val $Bind))
  %449 = alloca i64, i64 3, align 16
  %450 = ptrtoint i64* %449 to i64
  %451 = inttoptr i64 %450 to i64*
  store i64 %446, i64* %451
  %452 = add i64 %450, 8
  %453 = inttoptr i64 %452 to i64*
  store i64 %409, i64* %453
  %454 = add i64 %450, 16
  %455 = inttoptr i64 %454 to i64*
  store i64 %448, i64* %455
  %456 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %450, i64* %456
; # (set Sym2 (save (eval (++ Z))) Y ONE)
; # (++ Z)
  %457 = inttoptr i64 %412 to i64*
  %458 = load i64, i64* %457
  %459 = getelementptr i64, i64* %457, i32 1
  %460 = load i64, i64* %459
; # (eval (++ Z))
  %461 = and i64 %458, 6
  %462 = icmp ne i64 %461, 0
  br i1 %462, label %$104, label %$103
$104:
  br label %$102
$103:
  %463 = and i64 %458, 8
  %464 = icmp ne i64 %463, 0
  br i1 %464, label %$106, label %$105
$106:
  %465 = inttoptr i64 %458 to i64*
  %466 = load i64, i64* %465
  br label %$102
$105:
  %467 = call i64 @evList(i64 %458)
  br label %$102
$102:
  %468 = phi i64 [%458, %$104], [%466, %$106], [%467, %$105] ; # ->
; # (save (eval (++ Z)))
  %469 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %470 = load i64, i64* %469
  %471 = alloca i64, i64 2, align 16
  %472 = ptrtoint i64* %471 to i64
  %473 = inttoptr i64 %472 to i64*
  store i64 %468, i64* %473
  %474 = add i64 %472, 8
  %475 = inttoptr i64 %474 to i64*
  store i64 %470, i64* %475
  %476 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %472, i64* %476
  %477 = inttoptr i64 %409 to i64*
  store i64 %468, i64* %477
  %478 = inttoptr i64 %414 to i64*
  store i64 18, i64* %478
; # (loop (? (nil? (eval (car Z)))) (set $At @) (? (=0 (& (setq R (lo...
  br label %$107
$107:
  %479 = phi i64 [%404, %$102], [%544, %$117] ; # X
  %480 = phi i64 [%414, %$102], [%545, %$117] ; # Y
  %481 = phi i64 [%406, %$102], [%546, %$117] ; # R
  %482 = phi i64 [%460, %$102], [%547, %$117] ; # Z
; # (? (nil? (eval (car Z))))
; # (car Z)
  %483 = inttoptr i64 %482 to i64*
  %484 = load i64, i64* %483
; # (eval (car Z))
  %485 = and i64 %484, 6
  %486 = icmp ne i64 %485, 0
  br i1 %486, label %$110, label %$109
$110:
  br label %$108
$109:
  %487 = and i64 %484, 8
  %488 = icmp ne i64 %487, 0
  br i1 %488, label %$112, label %$111
$112:
  %489 = inttoptr i64 %484 to i64*
  %490 = load i64, i64* %489
  br label %$108
$111:
  %491 = call i64 @evList(i64 %484)
  br label %$108
$108:
  %492 = phi i64 [%484, %$110], [%490, %$112], [%491, %$111] ; # ->
; # (nil? (eval (car Z)))
  %493 = icmp eq i64 %492, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %493, label %$114, label %$113
$113:
  %494 = phi i64 [%479, %$108] ; # X
  %495 = phi i64 [%480, %$108] ; # Y
  %496 = phi i64 [%481, %$108] ; # R
  %497 = phi i64 [%482, %$108] ; # Z
; # (set $At @)
  %498 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  store i64 %492, i64* %498
; # (? (=0 (& (setq R (loop1 X)) 1)))
; # (loop1 X)
  %499 = call i64 @loop1(i64 %494)
; # (& (setq R (loop1 X)) 1)
  %500 = and i64 %499, 1
; # (=0 (& (setq R (loop1 X)) 1))
  %501 = icmp eq i64 %500, 0
  br i1 %501, label %$114, label %$115
$115:
  %502 = phi i64 [%494, %$113] ; # X
  %503 = phi i64 [%495, %$113] ; # Y
  %504 = phi i64 [%499, %$113] ; # R
  %505 = phi i64 [%497, %$113] ; # Z
; # (& R -2)
  %506 = and i64 %504, -2
; # (safe (setq R (& R -2)))
  %507 = inttoptr i64 %440 to i64*
  store i64 %506, i64* %507
; # (when (pair (cdr Z)) (set Sym2 (run @)))
; # (cdr Z)
  %508 = inttoptr i64 %505 to i64*
  %509 = getelementptr i64, i64* %508, i32 1
  %510 = load i64, i64* %509
; # (pair (cdr Z))
  %511 = and i64 %510, 15
  %512 = icmp eq i64 %511, 0
  br i1 %512, label %$116, label %$117
$116:
  %513 = phi i64 [%502, %$115] ; # X
  %514 = phi i64 [%503, %$115] ; # Y
  %515 = phi i64 [%506, %$115] ; # R
  %516 = phi i64 [%505, %$115] ; # Z
; # (set Sym2 (run @))
; # (run @)
  br label %$118
$118:
  %517 = phi i64 [%510, %$116], [%539, %$127] ; # Prg
  %518 = inttoptr i64 %517 to i64*
  %519 = load i64, i64* %518
  %520 = getelementptr i64, i64* %518, i32 1
  %521 = load i64, i64* %520
  %522 = and i64 %521, 15
  %523 = icmp ne i64 %522, 0
  br i1 %523, label %$121, label %$119
$121:
  %524 = phi i64 [%521, %$118] ; # Prg
  %525 = and i64 %519, 6
  %526 = icmp ne i64 %525, 0
  br i1 %526, label %$124, label %$123
$124:
  br label %$122
$123:
  %527 = and i64 %519, 8
  %528 = icmp ne i64 %527, 0
  br i1 %528, label %$126, label %$125
$126:
  %529 = inttoptr i64 %519 to i64*
  %530 = load i64, i64* %529
  br label %$122
$125:
  %531 = call i64 @evList(i64 %519)
  br label %$122
$122:
  %532 = phi i64 [%519, %$124], [%530, %$126], [%531, %$125] ; # ->
  br label %$120
$119:
  %533 = phi i64 [%521, %$118] ; # Prg
  %534 = and i64 %519, 15
  %535 = icmp eq i64 %534, 0
  br i1 %535, label %$128, label %$127
$128:
  %536 = phi i64 [%533, %$119] ; # Prg
  %537 = call i64 @evList(i64 %519)
  %538 = icmp ne i64 %537, 0
  br label %$127
$127:
  %539 = phi i64 [%533, %$119], [%536, %$128] ; # Prg
  %540 = phi i1 [0, %$119], [%538, %$128] ; # ->
  br label %$118
$120:
  %541 = phi i64 [%524, %$122] ; # Prg
  %542 = phi i64 [%532, %$122] ; # ->
  %543 = inttoptr i64 %409 to i64*
  store i64 %542, i64* %543
  br label %$117
$117:
  %544 = phi i64 [%502, %$115], [%513, %$120] ; # X
  %545 = phi i64 [%503, %$115], [%514, %$120] ; # Y
  %546 = phi i64 [%506, %$115], [%515, %$120] ; # R
  %547 = phi i64 [%505, %$115], [%516, %$120] ; # Z
; # (set Y (+ (val Y) (hex "10")))
; # (val Y)
  %548 = inttoptr i64 %545 to i64*
  %549 = load i64, i64* %548
; # (+ (val Y) (hex "10"))
  %550 = add i64 %549, 16
  %551 = inttoptr i64 %545 to i64*
  store i64 %550, i64* %551
  br label %$107
$114:
  %552 = phi i64 [%479, %$108], [%494, %$113] ; # X
  %553 = phi i64 [%480, %$108], [%495, %$113] ; # Y
  %554 = phi i64 [%481, %$108], [%499, %$113] ; # R
  %555 = phi i64 [%482, %$108], [%497, %$113] ; # Z
  %556 = phi i64 [0, %$108], [0, %$113] ; # ->
; # (set Sym2 (val Q))
; # (val Q)
  %557 = inttoptr i64 %450 to i64*
  %558 = load i64, i64* %557
  %559 = inttoptr i64 %409 to i64*
  store i64 %558, i64* %559
; # drop
  %560 = inttoptr i64 %440 to i64*
  %561 = getelementptr i64, i64* %560, i32 1
  %562 = load i64, i64* %561
  %563 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %562, i64* %563
; # (set Y (val P) $Bind (val 3 P))
; # (val P)
  %564 = inttoptr i64 %428 to i64*
  %565 = load i64, i64* %564
  %566 = inttoptr i64 %553 to i64*
  store i64 %565, i64* %566
; # (val 3 P)
  %567 = inttoptr i64 %428 to i64*
  %568 = getelementptr i64, i64* %567, i32 2
  %569 = load i64, i64* %568
  %570 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %569, i64* %570
  br label %$2
$2:
  %571 = phi i64 [%138, %$18], [%249, %$52], [%388, %$75], [%552, %$114] ; # X
  %572 = phi i64 [%139, %$18], [%250, %$52], [%389, %$75], [%553, %$114] ; # Y
  %573 = phi i64 [%140, %$18], [%251, %$52], [%390, %$75], [%554, %$114] ; # R
  %574 = phi i64 [%147, %$18], [%266, %$52], [%402, %$75], [%569, %$114] ; # ->
  ret i64 %573
}

define i64 @_With(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (needVar Exe (eval (++ X)))) (if (nil? Y) Y (...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (needVar Exe (eval (++ X)))
  %16 = and i64 %15, 6
  %17 = icmp ne i64 %16, 0
  br i1 %17, label %$7, label %$8
$7:
  call void @varErr(i64 %0, i64 %15)
  unreachable
$8:
; # (if (nil? Y) Y (let P (set $Bind (push (val $This) $This (val $Bi...
; # (nil? Y)
  %18 = icmp eq i64 %15, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %18, label %$9, label %$10
$9:
  br label %$11
$10:
; # (let P (set $Bind (push (val $This) $This (val $Bind))) (set $Thi...
; # (set $Bind (push (val $This) $This (val $Bind)))
; # (val $This)
  %19 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 488) to i64) to i64*
  %20 = load i64, i64* %19
; # (val $Bind)
  %21 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  %22 = load i64, i64* %21
; # (push (val $This) $This (val $Bind))
  %23 = alloca i64, i64 3, align 16
  %24 = ptrtoint i64* %23 to i64
  %25 = inttoptr i64 %24 to i64*
  store i64 %20, i64* %25
  %26 = add i64 %24, 8
  %27 = inttoptr i64 %26 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 488) to i64), i64* %27
  %28 = add i64 %24, 16
  %29 = inttoptr i64 %28 to i64*
  store i64 %22, i64* %29
  %30 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %24, i64* %30
; # (set $This Y)
  %31 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 488) to i64) to i64*
  store i64 %15, i64* %31
; # (prog1 (run X) (set $This (val P) $Bind (val 3 P)))
; # (run X)
  br label %$12
$12:
  %32 = phi i64 [%7, %$10], [%54, %$21] ; # Prg
  %33 = inttoptr i64 %32 to i64*
  %34 = load i64, i64* %33
  %35 = getelementptr i64, i64* %33, i32 1
  %36 = load i64, i64* %35
  %37 = and i64 %36, 15
  %38 = icmp ne i64 %37, 0
  br i1 %38, label %$15, label %$13
$15:
  %39 = phi i64 [%36, %$12] ; # Prg
  %40 = and i64 %34, 6
  %41 = icmp ne i64 %40, 0
  br i1 %41, label %$18, label %$17
$18:
  br label %$16
$17:
  %42 = and i64 %34, 8
  %43 = icmp ne i64 %42, 0
  br i1 %43, label %$20, label %$19
$20:
  %44 = inttoptr i64 %34 to i64*
  %45 = load i64, i64* %44
  br label %$16
$19:
  %46 = call i64 @evList(i64 %34)
  br label %$16
$16:
  %47 = phi i64 [%34, %$18], [%45, %$20], [%46, %$19] ; # ->
  br label %$14
$13:
  %48 = phi i64 [%36, %$12] ; # Prg
  %49 = and i64 %34, 15
  %50 = icmp eq i64 %49, 0
  br i1 %50, label %$22, label %$21
$22:
  %51 = phi i64 [%48, %$13] ; # Prg
  %52 = call i64 @evList(i64 %34)
  %53 = icmp ne i64 %52, 0
  br label %$21
$21:
  %54 = phi i64 [%48, %$13], [%51, %$22] ; # Prg
  %55 = phi i1 [0, %$13], [%53, %$22] ; # ->
  br label %$12
$14:
  %56 = phi i64 [%39, %$16] ; # Prg
  %57 = phi i64 [%47, %$16] ; # ->
; # (set $This (val P) $Bind (val 3 P))
; # (val P)
  %58 = inttoptr i64 %24 to i64*
  %59 = load i64, i64* %58
  %60 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 488) to i64) to i64*
  store i64 %59, i64* %60
; # (val 3 P)
  %61 = inttoptr i64 %24 to i64*
  %62 = getelementptr i64, i64* %61, i32 2
  %63 = load i64, i64* %62
  %64 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %63, i64* %64
  br label %$11
$11:
  %65 = phi i64 [%15, %$9], [%57, %$14] ; # ->
  ret i64 %65
}

define i64 @_Bind(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (eval (++ X))) (cond ((num? Y) (argErr Exe Y)...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (cond ((num? Y) (argErr Exe Y)) ((nil? Y) (run X)) ((sym? Y) (chk...
; # (num? Y)
  %16 = and i64 %15, 6
  %17 = icmp ne i64 %16, 0
  br i1 %17, label %$9, label %$8
$9:
  %18 = phi i64 [%15, %$2] ; # Y
; # (argErr Exe Y)
  call void @argErr(i64 %0, i64 %18)
  unreachable
$8:
  %19 = phi i64 [%15, %$2] ; # Y
; # (nil? Y)
  %20 = icmp eq i64 %19, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %20, label %$11, label %$10
$11:
  %21 = phi i64 [%19, %$8] ; # Y
; # (run X)
  br label %$12
$12:
  %22 = phi i64 [%7, %$11], [%44, %$21] ; # Prg
  %23 = inttoptr i64 %22 to i64*
  %24 = load i64, i64* %23
  %25 = getelementptr i64, i64* %23, i32 1
  %26 = load i64, i64* %25
  %27 = and i64 %26, 15
  %28 = icmp ne i64 %27, 0
  br i1 %28, label %$15, label %$13
$15:
  %29 = phi i64 [%26, %$12] ; # Prg
  %30 = and i64 %24, 6
  %31 = icmp ne i64 %30, 0
  br i1 %31, label %$18, label %$17
$18:
  br label %$16
$17:
  %32 = and i64 %24, 8
  %33 = icmp ne i64 %32, 0
  br i1 %33, label %$20, label %$19
$20:
  %34 = inttoptr i64 %24 to i64*
  %35 = load i64, i64* %34
  br label %$16
$19:
  %36 = call i64 @evList(i64 %24)
  br label %$16
$16:
  %37 = phi i64 [%24, %$18], [%35, %$20], [%36, %$19] ; # ->
  br label %$14
$13:
  %38 = phi i64 [%26, %$12] ; # Prg
  %39 = and i64 %24, 15
  %40 = icmp eq i64 %39, 0
  br i1 %40, label %$22, label %$21
$22:
  %41 = phi i64 [%38, %$13] ; # Prg
  %42 = call i64 @evList(i64 %24)
  %43 = icmp ne i64 %42, 0
  br label %$21
$21:
  %44 = phi i64 [%38, %$13], [%41, %$22] ; # Prg
  %45 = phi i1 [0, %$13], [%43, %$22] ; # ->
  br label %$12
$14:
  %46 = phi i64 [%29, %$16] ; # Prg
  %47 = phi i64 [%37, %$16] ; # ->
  br label %$7
$10:
  %48 = phi i64 [%19, %$8] ; # Y
; # (sym? Y)
  %49 = and i64 %48, 8
  %50 = icmp ne i64 %49, 0
  br i1 %50, label %$24, label %$23
$24:
  %51 = phi i64 [%48, %$10] ; # Y
; # (chkVar Exe Y)
  %52 = icmp uge i64 %51, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %52, label %$26, label %$25
$26:
  %53 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %51
  br label %$25
$25:
  %54 = phi i1 [0, %$24], [%53, %$26] ; # ->
  br i1 %54, label %$27, label %$28
$27:
  call void @protErr(i64 %0, i64 %51)
  unreachable
$28:
; # (let P (set $Bind (push (val Y) Y (val $Bind))) (prog1 (run X) (s...
; # (set $Bind (push (val Y) Y (val $Bind)))
; # (val Y)
  %55 = inttoptr i64 %51 to i64*
  %56 = load i64, i64* %55
; # (val $Bind)
  %57 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  %58 = load i64, i64* %57
; # (push (val Y) Y (val $Bind))
  %59 = alloca i64, i64 3, align 16
  %60 = ptrtoint i64* %59 to i64
  %61 = inttoptr i64 %60 to i64*
  store i64 %56, i64* %61
  %62 = add i64 %60, 8
  %63 = inttoptr i64 %62 to i64*
  store i64 %51, i64* %63
  %64 = add i64 %60, 16
  %65 = inttoptr i64 %64 to i64*
  store i64 %58, i64* %65
  %66 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %60, i64* %66
; # (prog1 (run X) (set Y (val P) $Bind (val 3 P)))
; # (run X)
  br label %$29
$29:
  %67 = phi i64 [%7, %$28], [%89, %$38] ; # Prg
  %68 = inttoptr i64 %67 to i64*
  %69 = load i64, i64* %68
  %70 = getelementptr i64, i64* %68, i32 1
  %71 = load i64, i64* %70
  %72 = and i64 %71, 15
  %73 = icmp ne i64 %72, 0
  br i1 %73, label %$32, label %$30
$32:
  %74 = phi i64 [%71, %$29] ; # Prg
  %75 = and i64 %69, 6
  %76 = icmp ne i64 %75, 0
  br i1 %76, label %$35, label %$34
$35:
  br label %$33
$34:
  %77 = and i64 %69, 8
  %78 = icmp ne i64 %77, 0
  br i1 %78, label %$37, label %$36
$37:
  %79 = inttoptr i64 %69 to i64*
  %80 = load i64, i64* %79
  br label %$33
$36:
  %81 = call i64 @evList(i64 %69)
  br label %$33
$33:
  %82 = phi i64 [%69, %$35], [%80, %$37], [%81, %$36] ; # ->
  br label %$31
$30:
  %83 = phi i64 [%71, %$29] ; # Prg
  %84 = and i64 %69, 15
  %85 = icmp eq i64 %84, 0
  br i1 %85, label %$39, label %$38
$39:
  %86 = phi i64 [%83, %$30] ; # Prg
  %87 = call i64 @evList(i64 %69)
  %88 = icmp ne i64 %87, 0
  br label %$38
$38:
  %89 = phi i64 [%83, %$30], [%86, %$39] ; # Prg
  %90 = phi i1 [0, %$30], [%88, %$39] ; # ->
  br label %$29
$31:
  %91 = phi i64 [%74, %$33] ; # Prg
  %92 = phi i64 [%82, %$33] ; # ->
; # (set Y (val P) $Bind (val 3 P))
; # (val P)
  %93 = inttoptr i64 %60 to i64*
  %94 = load i64, i64* %93
  %95 = inttoptr i64 %51 to i64*
  store i64 %94, i64* %95
; # (val 3 P)
  %96 = inttoptr i64 %60 to i64*
  %97 = getelementptr i64, i64* %96, i32 2
  %98 = load i64, i64* %97
  %99 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %98, i64* %99
  br label %$7
$23:
  %100 = phi i64 [%48, %$10] ; # Y
; # (let (P (val $Bind) Q P) (loop (let Z (++ Y) (when (num? Z) (argE...
; # (val $Bind)
  %101 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  %102 = load i64, i64* %101
; # (loop (let Z (++ Y) (when (num? Z) (argErr Exe Y)) (if (sym? Z) (...
  br label %$40
$40:
  %103 = phi i64 [%100, %$23], [%160, %$56] ; # Y
  %104 = phi i64 [%102, %$23], [%161, %$56] ; # P
; # (let Z (++ Y) (when (num? Z) (argErr Exe Y)) (if (sym? Z) (set $B...
; # (++ Y)
  %105 = inttoptr i64 %103 to i64*
  %106 = load i64, i64* %105
  %107 = getelementptr i64, i64* %105, i32 1
  %108 = load i64, i64* %107
; # (when (num? Z) (argErr Exe Y))
; # (num? Z)
  %109 = and i64 %106, 6
  %110 = icmp ne i64 %109, 0
  br i1 %110, label %$41, label %$42
$41:
  %111 = phi i64 [%108, %$40] ; # Y
  %112 = phi i64 [%104, %$40] ; # P
; # (argErr Exe Y)
  call void @argErr(i64 %0, i64 %111)
  unreachable
$42:
  %113 = phi i64 [%108, %$40] ; # Y
  %114 = phi i64 [%104, %$40] ; # P
; # (if (sym? Z) (set $Bind (setq P (push (val Z) (chkVar Exe Z) P)))...
; # (sym? Z)
  %115 = and i64 %106, 8
  %116 = icmp ne i64 %115, 0
  br i1 %116, label %$43, label %$44
$43:
  %117 = phi i64 [%113, %$42] ; # Y
  %118 = phi i64 [%114, %$42] ; # P
; # (set $Bind (setq P (push (val Z) (chkVar Exe Z) P)))
; # (val Z)
  %119 = inttoptr i64 %106 to i64*
  %120 = load i64, i64* %119
; # (chkVar Exe Z)
  %121 = icmp uge i64 %106, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %121, label %$47, label %$46
$47:
  %122 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %106
  br label %$46
$46:
  %123 = phi i1 [0, %$43], [%122, %$47] ; # ->
  br i1 %123, label %$48, label %$49
$48:
  call void @protErr(i64 %0, i64 %106)
  unreachable
$49:
; # (push (val Z) (chkVar Exe Z) P)
  %124 = alloca i64, i64 3, align 16
  %125 = ptrtoint i64* %124 to i64
  %126 = inttoptr i64 %125 to i64*
  store i64 %120, i64* %126
  %127 = add i64 %125, 8
  %128 = inttoptr i64 %127 to i64*
  store i64 %106, i64* %128
  %129 = add i64 %125, 16
  %130 = inttoptr i64 %129 to i64*
  store i64 %118, i64* %130
  %131 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %125, i64* %131
  br label %$45
$44:
  %132 = phi i64 [%113, %$42] ; # Y
  %133 = phi i64 [%114, %$42] ; # P
; # (let S (car Z) (needChkVar Exe S) (set $Bind (setq P (push (val S...
; # (car Z)
  %134 = inttoptr i64 %106 to i64*
  %135 = load i64, i64* %134
; # (needChkVar Exe S)
  %136 = and i64 %135, 6
  %137 = icmp ne i64 %136, 0
  br i1 %137, label %$50, label %$51
$50:
  call void @varErr(i64 %0, i64 %135)
  unreachable
$51:
  %138 = icmp uge i64 %135, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %138, label %$53, label %$52
$53:
  %139 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %135
  br label %$52
$52:
  %140 = phi i1 [0, %$51], [%139, %$53] ; # ->
  br i1 %140, label %$54, label %$55
$54:
  call void @protErr(i64 %0, i64 %135)
  unreachable
$55:
; # (set $Bind (setq P (push (val S) S P)) S (cdr Z))
; # (val S)
  %141 = inttoptr i64 %135 to i64*
  %142 = load i64, i64* %141
; # (push (val S) S P)
  %143 = alloca i64, i64 3, align 16
  %144 = ptrtoint i64* %143 to i64
  %145 = inttoptr i64 %144 to i64*
  store i64 %142, i64* %145
  %146 = add i64 %144, 8
  %147 = inttoptr i64 %146 to i64*
  store i64 %135, i64* %147
  %148 = add i64 %144, 16
  %149 = inttoptr i64 %148 to i64*
  store i64 %133, i64* %149
  %150 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %144, i64* %150
; # (cdr Z)
  %151 = inttoptr i64 %106 to i64*
  %152 = getelementptr i64, i64* %151, i32 1
  %153 = load i64, i64* %152
  %154 = inttoptr i64 %135 to i64*
  store i64 %153, i64* %154
  br label %$45
$45:
  %155 = phi i64 [%117, %$49], [%132, %$55] ; # Y
  %156 = phi i64 [%125, %$49], [%144, %$55] ; # P
  %157 = phi i64 [%125, %$49], [%153, %$55] ; # ->
; # (? (atom Y))
; # (atom Y)
  %158 = and i64 %155, 15
  %159 = icmp ne i64 %158, 0
  br i1 %159, label %$57, label %$56
$56:
  %160 = phi i64 [%155, %$45] ; # Y
  %161 = phi i64 [%156, %$45] ; # P
  br label %$40
$57:
  %162 = phi i64 [%155, %$45] ; # Y
  %163 = phi i64 [%156, %$45] ; # P
  %164 = phi i64 [0, %$45] ; # ->
; # (prog1 (run X) (loop (set (val 2 P) (val P)) (? (== Q (setq P (va...
; # (run X)
  br label %$58
$58:
  %165 = phi i64 [%7, %$57], [%187, %$67] ; # Prg
  %166 = inttoptr i64 %165 to i64*
  %167 = load i64, i64* %166
  %168 = getelementptr i64, i64* %166, i32 1
  %169 = load i64, i64* %168
  %170 = and i64 %169, 15
  %171 = icmp ne i64 %170, 0
  br i1 %171, label %$61, label %$59
$61:
  %172 = phi i64 [%169, %$58] ; # Prg
  %173 = and i64 %167, 6
  %174 = icmp ne i64 %173, 0
  br i1 %174, label %$64, label %$63
$64:
  br label %$62
$63:
  %175 = and i64 %167, 8
  %176 = icmp ne i64 %175, 0
  br i1 %176, label %$66, label %$65
$66:
  %177 = inttoptr i64 %167 to i64*
  %178 = load i64, i64* %177
  br label %$62
$65:
  %179 = call i64 @evList(i64 %167)
  br label %$62
$62:
  %180 = phi i64 [%167, %$64], [%178, %$66], [%179, %$65] ; # ->
  br label %$60
$59:
  %181 = phi i64 [%169, %$58] ; # Prg
  %182 = and i64 %167, 15
  %183 = icmp eq i64 %182, 0
  br i1 %183, label %$68, label %$67
$68:
  %184 = phi i64 [%181, %$59] ; # Prg
  %185 = call i64 @evList(i64 %167)
  %186 = icmp ne i64 %185, 0
  br label %$67
$67:
  %187 = phi i64 [%181, %$59], [%184, %$68] ; # Prg
  %188 = phi i1 [0, %$59], [%186, %$68] ; # ->
  br label %$58
$60:
  %189 = phi i64 [%172, %$62] ; # Prg
  %190 = phi i64 [%180, %$62] ; # ->
; # (loop (set (val 2 P) (val P)) (? (== Q (setq P (val 3 P)))))
  br label %$69
$69:
  %191 = phi i64 [%162, %$60], [%203, %$70] ; # Y
  %192 = phi i64 [%163, %$60], [%204, %$70] ; # P
; # (set (val 2 P) (val P))
; # (val 2 P)
  %193 = inttoptr i64 %192 to i64*
  %194 = getelementptr i64, i64* %193, i32 1
  %195 = load i64, i64* %194
; # (val P)
  %196 = inttoptr i64 %192 to i64*
  %197 = load i64, i64* %196
  %198 = inttoptr i64 %195 to i64*
  store i64 %197, i64* %198
; # (? (== Q (setq P (val 3 P))))
; # (val 3 P)
  %199 = inttoptr i64 %192 to i64*
  %200 = getelementptr i64, i64* %199, i32 2
  %201 = load i64, i64* %200
; # (== Q (setq P (val 3 P)))
  %202 = icmp eq i64 %102, %201
  br i1 %202, label %$71, label %$70
$70:
  %203 = phi i64 [%191, %$69] ; # Y
  %204 = phi i64 [%201, %$69] ; # P
  br label %$69
$71:
  %205 = phi i64 [%191, %$69] ; # Y
  %206 = phi i64 [%201, %$69] ; # P
  %207 = phi i64 [0, %$69] ; # ->
; # (set $Bind P)
  %208 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %206, i64* %208
  br label %$7
$7:
  %209 = phi i64 [%21, %$14], [%51, %$31], [%205, %$71] ; # Y
  %210 = phi i64 [%47, %$14], [%92, %$31], [%190, %$71] ; # ->
  ret i64 %210
}

define i64 @_Job(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (save (eval (++ X))) P (val $Bind) Q P) (whil...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (save (eval (++ X)))
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %17 = load i64, i64* %16
  %18 = alloca i64, i64 2, align 16
  %19 = ptrtoint i64* %18 to i64
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = add i64 %19, 8
  %22 = inttoptr i64 %21 to i64*
  store i64 %17, i64* %22
  %23 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %19, i64* %23
; # (val $Bind)
  %24 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  %25 = load i64, i64* %24
; # (while (pair Y) (let (Z (++ Y) S (car Z)) (needChkVar Exe S) (set...
  br label %$7
$7:
  %26 = phi i64 [%15, %$2], [%35, %$15] ; # Y
  %27 = phi i64 [%25, %$2], [%46, %$15] ; # P
; # (pair Y)
  %28 = and i64 %26, 15
  %29 = icmp eq i64 %28, 0
  br i1 %29, label %$8, label %$9
$8:
  %30 = phi i64 [%26, %$7] ; # Y
  %31 = phi i64 [%27, %$7] ; # P
; # (let (Z (++ Y) S (car Z)) (needChkVar Exe S) (set $Bind (setq P (...
; # (++ Y)
  %32 = inttoptr i64 %30 to i64*
  %33 = load i64, i64* %32
  %34 = getelementptr i64, i64* %32, i32 1
  %35 = load i64, i64* %34
; # (car Z)
  %36 = inttoptr i64 %33 to i64*
  %37 = load i64, i64* %36
; # (needChkVar Exe S)
  %38 = and i64 %37, 6
  %39 = icmp ne i64 %38, 0
  br i1 %39, label %$10, label %$11
$10:
  call void @varErr(i64 %0, i64 %37)
  unreachable
$11:
  %40 = icmp uge i64 %37, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %40, label %$13, label %$12
$13:
  %41 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %37
  br label %$12
$12:
  %42 = phi i1 [0, %$11], [%41, %$13] ; # ->
  br i1 %42, label %$14, label %$15
$14:
  call void @protErr(i64 %0, i64 %37)
  unreachable
$15:
; # (set $Bind (setq P (push (val S) S P Z)) S (cdr Z))
; # (val S)
  %43 = inttoptr i64 %37 to i64*
  %44 = load i64, i64* %43
; # (push (val S) S P Z)
  %45 = alloca i64, i64 4, align 16
  %46 = ptrtoint i64* %45 to i64
  %47 = inttoptr i64 %46 to i64*
  store i64 %44, i64* %47
  %48 = add i64 %46, 8
  %49 = inttoptr i64 %48 to i64*
  store i64 %37, i64* %49
  %50 = add i64 %46, 16
  %51 = inttoptr i64 %50 to i64*
  store i64 %31, i64* %51
  %52 = add i64 %46, 24
  %53 = inttoptr i64 %52 to i64*
  store i64 %33, i64* %53
  %54 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %46, i64* %54
; # (cdr Z)
  %55 = inttoptr i64 %33 to i64*
  %56 = getelementptr i64, i64* %55, i32 1
  %57 = load i64, i64* %56
  %58 = inttoptr i64 %37 to i64*
  store i64 %57, i64* %58
  br label %$7
$9:
  %59 = phi i64 [%26, %$7] ; # Y
  %60 = phi i64 [%27, %$7] ; # P
; # (prog1 (run X) (until (== Q P) (let S (val 2 P) (set 2 (val 4 P) ...
; # (run X)
  br label %$16
$16:
  %61 = phi i64 [%7, %$9], [%83, %$25] ; # Prg
  %62 = inttoptr i64 %61 to i64*
  %63 = load i64, i64* %62
  %64 = getelementptr i64, i64* %62, i32 1
  %65 = load i64, i64* %64
  %66 = and i64 %65, 15
  %67 = icmp ne i64 %66, 0
  br i1 %67, label %$19, label %$17
$19:
  %68 = phi i64 [%65, %$16] ; # Prg
  %69 = and i64 %63, 6
  %70 = icmp ne i64 %69, 0
  br i1 %70, label %$22, label %$21
$22:
  br label %$20
$21:
  %71 = and i64 %63, 8
  %72 = icmp ne i64 %71, 0
  br i1 %72, label %$24, label %$23
$24:
  %73 = inttoptr i64 %63 to i64*
  %74 = load i64, i64* %73
  br label %$20
$23:
  %75 = call i64 @evList(i64 %63)
  br label %$20
$20:
  %76 = phi i64 [%63, %$22], [%74, %$24], [%75, %$23] ; # ->
  br label %$18
$17:
  %77 = phi i64 [%65, %$16] ; # Prg
  %78 = and i64 %63, 15
  %79 = icmp eq i64 %78, 0
  br i1 %79, label %$26, label %$25
$26:
  %80 = phi i64 [%77, %$17] ; # Prg
  %81 = call i64 @evList(i64 %63)
  %82 = icmp ne i64 %81, 0
  br label %$25
$25:
  %83 = phi i64 [%77, %$17], [%80, %$26] ; # Prg
  %84 = phi i1 [0, %$17], [%82, %$26] ; # ->
  br label %$16
$18:
  %85 = phi i64 [%68, %$20] ; # Prg
  %86 = phi i64 [%76, %$20] ; # ->
; # (until (== Q P) (let S (val 2 P) (set 2 (val 4 P) (val S)) (set S...
  br label %$27
$27:
  %87 = phi i64 [%59, %$18], [%90, %$28] ; # Y
  %88 = phi i64 [%60, %$18], [%107, %$28] ; # P
; # (== Q P)
  %89 = icmp eq i64 %25, %88
  br i1 %89, label %$29, label %$28
$28:
  %90 = phi i64 [%87, %$27] ; # Y
  %91 = phi i64 [%88, %$27] ; # P
; # (let S (val 2 P) (set 2 (val 4 P) (val S)) (set S (val P)))
; # (val 2 P)
  %92 = inttoptr i64 %91 to i64*
  %93 = getelementptr i64, i64* %92, i32 1
  %94 = load i64, i64* %93
; # (set 2 (val 4 P) (val S))
; # (val 4 P)
  %95 = inttoptr i64 %91 to i64*
  %96 = getelementptr i64, i64* %95, i32 3
  %97 = load i64, i64* %96
; # (val S)
  %98 = inttoptr i64 %94 to i64*
  %99 = load i64, i64* %98
  %100 = inttoptr i64 %97 to i64*
  %101 = getelementptr i64, i64* %100, i32 1
  store i64 %99, i64* %101
; # (set S (val P))
; # (val P)
  %102 = inttoptr i64 %91 to i64*
  %103 = load i64, i64* %102
  %104 = inttoptr i64 %94 to i64*
  store i64 %103, i64* %104
; # (val 3 P)
  %105 = inttoptr i64 %91 to i64*
  %106 = getelementptr i64, i64* %105, i32 2
  %107 = load i64, i64* %106
  br label %$27
$29:
  %108 = phi i64 [%87, %$27] ; # Y
  %109 = phi i64 [%88, %$27] ; # P
; # (set $Bind P)
  %110 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %109, i64* %110
; # (drop *Safe)
  %111 = inttoptr i64 %19 to i64*
  %112 = getelementptr i64, i64* %111, i32 1
  %113 = load i64, i64* %112
  %114 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %113, i64* %114
  ret i64 %86
}

define void @setDestruct(i64, i64) align 8 {
$1:
; # (loop (when (atom Val) (setq Val $Nil)) (let (P (++ Pat) V (++ Va...
  br label %$2
$2:
  %2 = phi i64 [%0, %$1], [%42, %$10] ; # Pat
  %3 = phi i64 [%1, %$1], [%43, %$10] ; # Val
; # (when (atom Val) (setq Val $Nil))
; # (atom Val)
  %4 = and i64 %3, 15
  %5 = icmp ne i64 %4, 0
  br i1 %5, label %$3, label %$4
$3:
  %6 = phi i64 [%2, %$2] ; # Pat
  %7 = phi i64 [%3, %$2] ; # Val
  br label %$4
$4:
  %8 = phi i64 [%2, %$2], [%6, %$3] ; # Pat
  %9 = phi i64 [%3, %$2], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$3] ; # Val
; # (let (P (++ Pat) V (++ Val)) (if (atom P) (unless (nil? P) (set P...
; # (++ Pat)
  %10 = inttoptr i64 %8 to i64*
  %11 = load i64, i64* %10
  %12 = getelementptr i64, i64* %10, i32 1
  %13 = load i64, i64* %12
; # (++ Val)
  %14 = inttoptr i64 %9 to i64*
  %15 = load i64, i64* %14
  %16 = getelementptr i64, i64* %14, i32 1
  %17 = load i64, i64* %16
; # (if (atom P) (unless (nil? P) (set P V)) (setDestruct P V))
; # (atom P)
  %18 = and i64 %11, 15
  %19 = icmp ne i64 %18, 0
  br i1 %19, label %$5, label %$6
$5:
  %20 = phi i64 [%13, %$4] ; # Pat
  %21 = phi i64 [%17, %$4] ; # Val
; # (unless (nil? P) (set P V))
; # (nil? P)
  %22 = icmp eq i64 %11, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %22, label %$9, label %$8
$8:
  %23 = phi i64 [%20, %$5] ; # Pat
  %24 = phi i64 [%21, %$5] ; # Val
; # (set P V)
  %25 = inttoptr i64 %11 to i64*
  store i64 %15, i64* %25
  br label %$9
$9:
  %26 = phi i64 [%20, %$5], [%23, %$8] ; # Pat
  %27 = phi i64 [%21, %$5], [%24, %$8] ; # Val
  br label %$7
$6:
  %28 = phi i64 [%13, %$4] ; # Pat
  %29 = phi i64 [%17, %$4] ; # Val
; # (setDestruct P V)
  call void @setDestruct(i64 %11, i64 %15)
  br label %$7
$7:
  %30 = phi i64 [%26, %$9], [%28, %$6] ; # Pat
  %31 = phi i64 [%27, %$9], [%29, %$6] ; # Val
; # (? (atom Pat) (unless (nil? Pat) (set Pat Val)))
; # (atom Pat)
  %32 = and i64 %30, 15
  %33 = icmp ne i64 %32, 0
  br i1 %33, label %$12, label %$10
$12:
  %34 = phi i64 [%30, %$7] ; # Pat
  %35 = phi i64 [%31, %$7] ; # Val
; # (unless (nil? Pat) (set Pat Val))
; # (nil? Pat)
  %36 = icmp eq i64 %34, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %36, label %$14, label %$13
$13:
  %37 = phi i64 [%34, %$12] ; # Pat
  %38 = phi i64 [%35, %$12] ; # Val
; # (set Pat Val)
  %39 = inttoptr i64 %37 to i64*
  store i64 %38, i64* %39
  br label %$14
$14:
  %40 = phi i64 [%34, %$12], [%37, %$13] ; # Pat
  %41 = phi i64 [%35, %$12], [%38, %$13] ; # Val
  br label %$11
$10:
  %42 = phi i64 [%30, %$7] ; # Pat
  %43 = phi i64 [%31, %$7] ; # Val
  br label %$2
$11:
  %44 = phi i64 [%40, %$14] ; # Pat
  %45 = phi i64 [%41, %$14] ; # Val
  ret void
}

define i64 @_Let(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (++ X)) (if (atom Y) (let P (set $Bind (push ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (if (atom Y) (let P (set $Bind (push (val (needChkVar Exe Y)) Y (...
; # (atom Y)
  %8 = and i64 %5, 15
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$2, label %$3
$2:
  %10 = phi i64 [%7, %$1] ; # X
  %11 = phi i64 [%5, %$1] ; # Y
; # (let P (set $Bind (push (val (needChkVar Exe Y)) Y (val $Bind))) ...
; # (set $Bind (push (val (needChkVar Exe Y)) Y (val $Bind)))
; # (needChkVar Exe Y)
  %12 = and i64 %11, 6
  %13 = icmp ne i64 %12, 0
  br i1 %13, label %$5, label %$6
$5:
  call void @varErr(i64 %0, i64 %11)
  unreachable
$6:
  %14 = icmp uge i64 %11, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %14, label %$8, label %$7
$8:
  %15 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %11
  br label %$7
$7:
  %16 = phi i1 [0, %$6], [%15, %$8] ; # ->
  br i1 %16, label %$9, label %$10
$9:
  call void @protErr(i64 %0, i64 %11)
  unreachable
$10:
; # (val (needChkVar Exe Y))
  %17 = inttoptr i64 %11 to i64*
  %18 = load i64, i64* %17
; # (val $Bind)
  %19 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  %20 = load i64, i64* %19
; # (push (val (needChkVar Exe Y)) Y (val $Bind))
  %21 = alloca i64, i64 3, align 16
  %22 = ptrtoint i64* %21 to i64
  %23 = inttoptr i64 %22 to i64*
  store i64 %18, i64* %23
  %24 = add i64 %22, 8
  %25 = inttoptr i64 %24 to i64*
  store i64 %11, i64* %25
  %26 = add i64 %22, 16
  %27 = inttoptr i64 %26 to i64*
  store i64 %20, i64* %27
  %28 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %22, i64* %28
; # (set Y (eval (++ X)))
; # (++ X)
  %29 = inttoptr i64 %10 to i64*
  %30 = load i64, i64* %29
  %31 = getelementptr i64, i64* %29, i32 1
  %32 = load i64, i64* %31
; # (eval (++ X))
  %33 = and i64 %30, 6
  %34 = icmp ne i64 %33, 0
  br i1 %34, label %$13, label %$12
$13:
  br label %$11
$12:
  %35 = and i64 %30, 8
  %36 = icmp ne i64 %35, 0
  br i1 %36, label %$15, label %$14
$15:
  %37 = inttoptr i64 %30 to i64*
  %38 = load i64, i64* %37
  br label %$11
$14:
  %39 = call i64 @evList(i64 %30)
  br label %$11
$11:
  %40 = phi i64 [%30, %$13], [%38, %$15], [%39, %$14] ; # ->
  %41 = inttoptr i64 %11 to i64*
  store i64 %40, i64* %41
; # (prog1 (run X) (set Y (val P) $Bind (val 3 P)))
; # (run X)
  br label %$16
$16:
  %42 = phi i64 [%32, %$11], [%64, %$25] ; # Prg
  %43 = inttoptr i64 %42 to i64*
  %44 = load i64, i64* %43
  %45 = getelementptr i64, i64* %43, i32 1
  %46 = load i64, i64* %45
  %47 = and i64 %46, 15
  %48 = icmp ne i64 %47, 0
  br i1 %48, label %$19, label %$17
$19:
  %49 = phi i64 [%46, %$16] ; # Prg
  %50 = and i64 %44, 6
  %51 = icmp ne i64 %50, 0
  br i1 %51, label %$22, label %$21
$22:
  br label %$20
$21:
  %52 = and i64 %44, 8
  %53 = icmp ne i64 %52, 0
  br i1 %53, label %$24, label %$23
$24:
  %54 = inttoptr i64 %44 to i64*
  %55 = load i64, i64* %54
  br label %$20
$23:
  %56 = call i64 @evList(i64 %44)
  br label %$20
$20:
  %57 = phi i64 [%44, %$22], [%55, %$24], [%56, %$23] ; # ->
  br label %$18
$17:
  %58 = phi i64 [%46, %$16] ; # Prg
  %59 = and i64 %44, 15
  %60 = icmp eq i64 %59, 0
  br i1 %60, label %$26, label %$25
$26:
  %61 = phi i64 [%58, %$17] ; # Prg
  %62 = call i64 @evList(i64 %44)
  %63 = icmp ne i64 %62, 0
  br label %$25
$25:
  %64 = phi i64 [%58, %$17], [%61, %$26] ; # Prg
  %65 = phi i1 [0, %$17], [%63, %$26] ; # ->
  br label %$16
$18:
  %66 = phi i64 [%49, %$20] ; # Prg
  %67 = phi i64 [%57, %$20] ; # ->
; # (set Y (val P) $Bind (val 3 P))
; # (val P)
  %68 = inttoptr i64 %22 to i64*
  %69 = load i64, i64* %68
  %70 = inttoptr i64 %11 to i64*
  store i64 %69, i64* %70
; # (val 3 P)
  %71 = inttoptr i64 %22 to i64*
  %72 = getelementptr i64, i64* %71, i32 2
  %73 = load i64, i64* %72
  %74 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %73, i64* %74
  br label %$4
$3:
  %75 = phi i64 [%7, %$1] ; # X
  %76 = phi i64 [%5, %$1] ; # Y
; # (let (P (val $Bind) Q P) (loop (let Z (++ Y) (if (atom Z) (set $B...
; # (val $Bind)
  %77 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  %78 = load i64, i64* %77
; # (loop (let Z (++ Y) (if (atom Z) (set $Bind (setq P (push (val (n...
  br label %$27
$27:
  %79 = phi i64 [%75, %$3], [%296, %$78] ; # X
  %80 = phi i64 [%76, %$3], [%297, %$78] ; # Y
  %81 = phi i64 [%78, %$3], [%298, %$78] ; # P
; # (let Z (++ Y) (if (atom Z) (set $Bind (setq P (push (val (needChk...
; # (++ Y)
  %82 = inttoptr i64 %80 to i64*
  %83 = load i64, i64* %82
  %84 = getelementptr i64, i64* %82, i32 1
  %85 = load i64, i64* %84
; # (if (atom Z) (set $Bind (setq P (push (val (needChkVar Exe Z)) Z ...
; # (atom Z)
  %86 = and i64 %83, 15
  %87 = icmp ne i64 %86, 0
  br i1 %87, label %$28, label %$29
$28:
  %88 = phi i64 [%79, %$27] ; # X
  %89 = phi i64 [%85, %$27] ; # Y
  %90 = phi i64 [%81, %$27] ; # P
  %91 = phi i64 [%83, %$27] ; # Z
; # (set $Bind (setq P (push (val (needChkVar Exe Z)) Z P)) Z (eval (...
; # (needChkVar Exe Z)
  %92 = and i64 %91, 6
  %93 = icmp ne i64 %92, 0
  br i1 %93, label %$31, label %$32
$31:
  call void @varErr(i64 %0, i64 %91)
  unreachable
$32:
  %94 = icmp uge i64 %91, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %94, label %$34, label %$33
$34:
  %95 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %91
  br label %$33
$33:
  %96 = phi i1 [0, %$32], [%95, %$34] ; # ->
  br i1 %96, label %$35, label %$36
$35:
  call void @protErr(i64 %0, i64 %91)
  unreachable
$36:
; # (val (needChkVar Exe Z))
  %97 = inttoptr i64 %91 to i64*
  %98 = load i64, i64* %97
; # (push (val (needChkVar Exe Z)) Z P)
  %99 = alloca i64, i64 3, align 16
  %100 = ptrtoint i64* %99 to i64
  %101 = inttoptr i64 %100 to i64*
  store i64 %98, i64* %101
  %102 = add i64 %100, 8
  %103 = inttoptr i64 %102 to i64*
  store i64 %91, i64* %103
  %104 = add i64 %100, 16
  %105 = inttoptr i64 %104 to i64*
  store i64 %90, i64* %105
  %106 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %100, i64* %106
; # (car Y)
  %107 = inttoptr i64 %89 to i64*
  %108 = load i64, i64* %107
; # (eval (car Y))
  %109 = and i64 %108, 6
  %110 = icmp ne i64 %109, 0
  br i1 %110, label %$39, label %$38
$39:
  br label %$37
$38:
  %111 = and i64 %108, 8
  %112 = icmp ne i64 %111, 0
  br i1 %112, label %$41, label %$40
$41:
  %113 = inttoptr i64 %108 to i64*
  %114 = load i64, i64* %113
  br label %$37
$40:
  %115 = call i64 @evList(i64 %108)
  br label %$37
$37:
  %116 = phi i64 [%108, %$39], [%114, %$41], [%115, %$40] ; # ->
  %117 = inttoptr i64 %91 to i64*
  store i64 %116, i64* %117
  br label %$30
$29:
  %118 = phi i64 [%79, %$27] ; # X
  %119 = phi i64 [%85, %$27] ; # Y
  %120 = phi i64 [%81, %$27] ; # P
  %121 = phi i64 [%83, %$27] ; # Z
; # (let Tos 0 (loop (until (atom (car Z)) (let U Z (setq Z @) (set U...
; # (loop (until (atom (car Z)) (let U Z (setq Z @) (set U Tos) (setq...
  br label %$42
$42:
  %122 = phi i64 [%118, %$29], [%267, %$56] ; # X
  %123 = phi i64 [%119, %$29], [%268, %$56] ; # Y
  %124 = phi i64 [%120, %$29], [%269, %$56] ; # P
  %125 = phi i64 [%121, %$29], [%270, %$56] ; # Z
  %126 = phi i64 [0, %$29], [%271, %$56] ; # Tos
; # (until (atom (car Z)) (let U Z (setq Z @) (set U Tos) (setq Tos U...
  br label %$43
$43:
  %127 = phi i64 [%122, %$42], [%136, %$44] ; # X
  %128 = phi i64 [%123, %$42], [%137, %$44] ; # Y
  %129 = phi i64 [%124, %$42], [%138, %$44] ; # P
  %130 = phi i64 [%125, %$42], [%133, %$44] ; # Z
  %131 = phi i64 [%126, %$42], [%139, %$44] ; # Tos
; # (car Z)
  %132 = inttoptr i64 %130 to i64*
  %133 = load i64, i64* %132
; # (atom (car Z))
  %134 = and i64 %133, 15
  %135 = icmp ne i64 %134, 0
  br i1 %135, label %$45, label %$44
$44:
  %136 = phi i64 [%127, %$43] ; # X
  %137 = phi i64 [%128, %$43] ; # Y
  %138 = phi i64 [%129, %$43] ; # P
  %139 = phi i64 [%130, %$43] ; # Z
  %140 = phi i64 [%131, %$43] ; # Tos
; # (let U Z (setq Z @) (set U Tos) (setq Tos U))
; # (set U Tos)
  %141 = inttoptr i64 %139 to i64*
  store i64 %140, i64* %141
  br label %$43
$45:
  %142 = phi i64 [%127, %$43] ; # X
  %143 = phi i64 [%128, %$43] ; # Y
  %144 = phi i64 [%129, %$43] ; # P
  %145 = phi i64 [%130, %$43] ; # Z
  %146 = phi i64 [%131, %$43] ; # Tos
; # (unless (nil? (car Z)) (let S (needChkVar Exe @) (set $Bind (setq...
; # (car Z)
  %147 = inttoptr i64 %145 to i64*
  %148 = load i64, i64* %147
; # (nil? (car Z))
  %149 = icmp eq i64 %148, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %149, label %$47, label %$46
$46:
  %150 = phi i64 [%142, %$45] ; # X
  %151 = phi i64 [%143, %$45] ; # Y
  %152 = phi i64 [%144, %$45] ; # P
  %153 = phi i64 [%145, %$45] ; # Z
  %154 = phi i64 [%146, %$45] ; # Tos
; # (let S (needChkVar Exe @) (set $Bind (setq P (push (val S) S P)))...
; # (needChkVar Exe @)
  %155 = and i64 %148, 6
  %156 = icmp ne i64 %155, 0
  br i1 %156, label %$48, label %$49
$48:
  call void @varErr(i64 %0, i64 %148)
  unreachable
$49:
  %157 = icmp uge i64 %148, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %157, label %$51, label %$50
$51:
  %158 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %148
  br label %$50
$50:
  %159 = phi i1 [0, %$49], [%158, %$51] ; # ->
  br i1 %159, label %$52, label %$53
$52:
  call void @protErr(i64 %0, i64 %148)
  unreachable
$53:
; # (set $Bind (setq P (push (val S) S P)))
; # (val S)
  %160 = inttoptr i64 %148 to i64*
  %161 = load i64, i64* %160
; # (push (val S) S P)
  %162 = alloca i64, i64 3, align 16
  %163 = ptrtoint i64* %162 to i64
  %164 = inttoptr i64 %163 to i64*
  store i64 %161, i64* %164
  %165 = add i64 %163, 8
  %166 = inttoptr i64 %165 to i64*
  store i64 %148, i64* %166
  %167 = add i64 %163, 16
  %168 = inttoptr i64 %167 to i64*
  store i64 %152, i64* %168
  %169 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %163, i64* %169
  br label %$47
$47:
  %170 = phi i64 [%142, %$45], [%150, %$53] ; # X
  %171 = phi i64 [%143, %$45], [%151, %$53] ; # Y
  %172 = phi i64 [%144, %$45], [%163, %$53] ; # P
  %173 = phi i64 [%145, %$45], [%153, %$53] ; # Z
  %174 = phi i64 [%146, %$45], [%154, %$53] ; # Tos
; # (loop (? (pair (cdr Z)) (let U Z (setq Z @) (set 2 U Tos) (setq T...
  br label %$54
$54:
  %175 = phi i64 [%170, %$47], [%261, %$70] ; # X
  %176 = phi i64 [%171, %$47], [%262, %$70] ; # Y
  %177 = phi i64 [%172, %$47], [%263, %$70] ; # P
  %178 = phi i64 [%173, %$47], [%264, %$70] ; # Z
  %179 = phi i64 [%174, %$47], [%265, %$70] ; # Tos
; # (? (pair (cdr Z)) (let U Z (setq Z @) (set 2 U Tos) (setq Tos (| ...
; # (cdr Z)
  %180 = inttoptr i64 %178 to i64*
  %181 = getelementptr i64, i64* %180, i32 1
  %182 = load i64, i64* %181
; # (pair (cdr Z))
  %183 = and i64 %182, 15
  %184 = icmp eq i64 %183, 0
  br i1 %184, label %$57, label %$55
$57:
  %185 = phi i64 [%175, %$54] ; # X
  %186 = phi i64 [%176, %$54] ; # Y
  %187 = phi i64 [%177, %$54] ; # P
  %188 = phi i64 [%178, %$54] ; # Z
  %189 = phi i64 [%179, %$54] ; # Tos
; # (let U Z (setq Z @) (set 2 U Tos) (setq Tos (| U 8)))
; # (set 2 U Tos)
  %190 = inttoptr i64 %188 to i64*
  %191 = getelementptr i64, i64* %190, i32 1
  store i64 %189, i64* %191
; # (| U 8)
  %192 = or i64 %188, 8
  br label %$56
$55:
  %193 = phi i64 [%175, %$54] ; # X
  %194 = phi i64 [%176, %$54] ; # Y
  %195 = phi i64 [%177, %$54] ; # P
  %196 = phi i64 [%178, %$54] ; # Z
  %197 = phi i64 [%179, %$54] ; # Tos
; # (unless (nil? @) (let S (needChkVar Exe @) (set $Bind (setq P (pu...
; # (nil? @)
  %198 = icmp eq i64 %182, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %198, label %$59, label %$58
$58:
  %199 = phi i64 [%193, %$55] ; # X
  %200 = phi i64 [%194, %$55] ; # Y
  %201 = phi i64 [%195, %$55] ; # P
  %202 = phi i64 [%196, %$55] ; # Z
  %203 = phi i64 [%197, %$55] ; # Tos
; # (let S (needChkVar Exe @) (set $Bind (setq P (push (val S) S P)))...
; # (needChkVar Exe @)
  %204 = and i64 %182, 6
  %205 = icmp ne i64 %204, 0
  br i1 %205, label %$60, label %$61
$60:
  call void @varErr(i64 %0, i64 %182)
  unreachable
$61:
  %206 = icmp uge i64 %182, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %206, label %$63, label %$62
$63:
  %207 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %182
  br label %$62
$62:
  %208 = phi i1 [0, %$61], [%207, %$63] ; # ->
  br i1 %208, label %$64, label %$65
$64:
  call void @protErr(i64 %0, i64 %182)
  unreachable
$65:
; # (set $Bind (setq P (push (val S) S P)))
; # (val S)
  %209 = inttoptr i64 %182 to i64*
  %210 = load i64, i64* %209
; # (push (val S) S P)
  %211 = alloca i64, i64 3, align 16
  %212 = ptrtoint i64* %211 to i64
  %213 = inttoptr i64 %212 to i64*
  store i64 %210, i64* %213
  %214 = add i64 %212, 8
  %215 = inttoptr i64 %214 to i64*
  store i64 %182, i64* %215
  %216 = add i64 %212, 16
  %217 = inttoptr i64 %216 to i64*
  store i64 %201, i64* %217
  %218 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %212, i64* %218
  br label %$59
$59:
  %219 = phi i64 [%193, %$55], [%199, %$65] ; # X
  %220 = phi i64 [%194, %$55], [%200, %$65] ; # Y
  %221 = phi i64 [%195, %$55], [%212, %$65] ; # P
  %222 = phi i64 [%196, %$55], [%202, %$65] ; # Z
  %223 = phi i64 [%197, %$55], [%203, %$65] ; # Tos
; # (loop (unless Tos (goto 1)) (? (=0 (& Tos 8)) (let U Tos (setq To...
  br label %$66
$66:
  %224 = phi i64 [%219, %$59], [%250, %$69] ; # X
  %225 = phi i64 [%220, %$59], [%251, %$69] ; # Y
  %226 = phi i64 [%221, %$59], [%252, %$69] ; # P
  %227 = phi i64 [%222, %$59], [%255, %$69] ; # Z
  %228 = phi i64 [%223, %$59], [%258, %$69] ; # Tos
; # (unless Tos (goto 1))
  %229 = icmp ne i64 %228, 0
  br i1 %229, label %$68, label %$67
$67:
  %230 = phi i64 [%224, %$66] ; # X
  %231 = phi i64 [%225, %$66] ; # Y
  %232 = phi i64 [%226, %$66] ; # P
  %233 = phi i64 [%227, %$66] ; # Z
  %234 = phi i64 [%228, %$66] ; # Tos
; # (goto 1)
  br label %$-1
$68:
  %235 = phi i64 [%224, %$66] ; # X
  %236 = phi i64 [%225, %$66] ; # Y
  %237 = phi i64 [%226, %$66] ; # P
  %238 = phi i64 [%227, %$66] ; # Z
  %239 = phi i64 [%228, %$66] ; # Tos
; # (? (=0 (& Tos 8)) (let U Tos (setq Tos (car U)) (set U Z) (setq Z...
; # (& Tos 8)
  %240 = and i64 %239, 8
; # (=0 (& Tos 8))
  %241 = icmp eq i64 %240, 0
  br i1 %241, label %$71, label %$69
$71:
  %242 = phi i64 [%235, %$68] ; # X
  %243 = phi i64 [%236, %$68] ; # Y
  %244 = phi i64 [%237, %$68] ; # P
  %245 = phi i64 [%238, %$68] ; # Z
  %246 = phi i64 [%239, %$68] ; # Tos
; # (let U Tos (setq Tos (car U)) (set U Z) (setq Z U))
; # (car U)
  %247 = inttoptr i64 %246 to i64*
  %248 = load i64, i64* %247
; # (set U Z)
  %249 = inttoptr i64 %246 to i64*
  store i64 %245, i64* %249
  br label %$70
$69:
  %250 = phi i64 [%235, %$68] ; # X
  %251 = phi i64 [%236, %$68] ; # Y
  %252 = phi i64 [%237, %$68] ; # P
  %253 = phi i64 [%238, %$68] ; # Z
  %254 = phi i64 [%239, %$68] ; # Tos
; # (let U (& Tos -9) (setq Tos (cdr U)) (set 2 U Z) (setq Z U))
; # (& Tos -9)
  %255 = and i64 %254, -9
; # (cdr U)
  %256 = inttoptr i64 %255 to i64*
  %257 = getelementptr i64, i64* %256, i32 1
  %258 = load i64, i64* %257
; # (set 2 U Z)
  %259 = inttoptr i64 %255 to i64*
  %260 = getelementptr i64, i64* %259, i32 1
  store i64 %253, i64* %260
  br label %$66
$70:
  %261 = phi i64 [%242, %$71] ; # X
  %262 = phi i64 [%243, %$71] ; # Y
  %263 = phi i64 [%244, %$71] ; # P
  %264 = phi i64 [%246, %$71] ; # Z
  %265 = phi i64 [%248, %$71] ; # Tos
  %266 = phi i64 [%246, %$71] ; # ->
  br label %$54
$56:
  %267 = phi i64 [%185, %$57] ; # X
  %268 = phi i64 [%186, %$57] ; # Y
  %269 = phi i64 [%187, %$57] ; # P
  %270 = phi i64 [%182, %$57] ; # Z
  %271 = phi i64 [%192, %$57] ; # Tos
  %272 = phi i64 [%192, %$57] ; # ->
  br label %$42
$72:
; # (: 1 (setDestruct Z (eval (car Y))))
  br label %$-1
$-1:
  %273 = phi i64 [%230, %$67], [%267, %$72] ; # X
  %274 = phi i64 [%231, %$67], [%268, %$72] ; # Y
  %275 = phi i64 [%232, %$67], [%269, %$72] ; # P
  %276 = phi i64 [%233, %$67], [%270, %$72] ; # Z
; # (car Y)
  %277 = inttoptr i64 %274 to i64*
  %278 = load i64, i64* %277
; # (eval (car Y))
  %279 = and i64 %278, 6
  %280 = icmp ne i64 %279, 0
  br i1 %280, label %$75, label %$74
$75:
  br label %$73
$74:
  %281 = and i64 %278, 8
  %282 = icmp ne i64 %281, 0
  br i1 %282, label %$77, label %$76
$77:
  %283 = inttoptr i64 %278 to i64*
  %284 = load i64, i64* %283
  br label %$73
$76:
  %285 = call i64 @evList(i64 %278)
  br label %$73
$73:
  %286 = phi i64 [%278, %$75], [%284, %$77], [%285, %$76] ; # ->
; # (setDestruct Z (eval (car Y)))
  call void @setDestruct(i64 %276, i64 %286)
  br label %$30
$30:
  %287 = phi i64 [%88, %$37], [%273, %$73] ; # X
  %288 = phi i64 [%89, %$37], [%274, %$73] ; # Y
  %289 = phi i64 [%100, %$37], [%275, %$73] ; # P
  %290 = phi i64 [%91, %$37], [%276, %$73] ; # Z
; # (? (atom (shift Y)))
; # (shift Y)
  %291 = inttoptr i64 %288 to i64*
  %292 = getelementptr i64, i64* %291, i32 1
  %293 = load i64, i64* %292
; # (atom (shift Y))
  %294 = and i64 %293, 15
  %295 = icmp ne i64 %294, 0
  br i1 %295, label %$79, label %$78
$78:
  %296 = phi i64 [%287, %$30] ; # X
  %297 = phi i64 [%293, %$30] ; # Y
  %298 = phi i64 [%289, %$30] ; # P
  br label %$27
$79:
  %299 = phi i64 [%287, %$30] ; # X
  %300 = phi i64 [%293, %$30] ; # Y
  %301 = phi i64 [%289, %$30] ; # P
  %302 = phi i64 [0, %$30] ; # ->
; # (prog1 (run X) (loop (set (val 2 P) (val P)) (? (== Q (setq P (va...
; # (run X)
  br label %$80
$80:
  %303 = phi i64 [%299, %$79], [%325, %$89] ; # Prg
  %304 = inttoptr i64 %303 to i64*
  %305 = load i64, i64* %304
  %306 = getelementptr i64, i64* %304, i32 1
  %307 = load i64, i64* %306
  %308 = and i64 %307, 15
  %309 = icmp ne i64 %308, 0
  br i1 %309, label %$83, label %$81
$83:
  %310 = phi i64 [%307, %$80] ; # Prg
  %311 = and i64 %305, 6
  %312 = icmp ne i64 %311, 0
  br i1 %312, label %$86, label %$85
$86:
  br label %$84
$85:
  %313 = and i64 %305, 8
  %314 = icmp ne i64 %313, 0
  br i1 %314, label %$88, label %$87
$88:
  %315 = inttoptr i64 %305 to i64*
  %316 = load i64, i64* %315
  br label %$84
$87:
  %317 = call i64 @evList(i64 %305)
  br label %$84
$84:
  %318 = phi i64 [%305, %$86], [%316, %$88], [%317, %$87] ; # ->
  br label %$82
$81:
  %319 = phi i64 [%307, %$80] ; # Prg
  %320 = and i64 %305, 15
  %321 = icmp eq i64 %320, 0
  br i1 %321, label %$90, label %$89
$90:
  %322 = phi i64 [%319, %$81] ; # Prg
  %323 = call i64 @evList(i64 %305)
  %324 = icmp ne i64 %323, 0
  br label %$89
$89:
  %325 = phi i64 [%319, %$81], [%322, %$90] ; # Prg
  %326 = phi i1 [0, %$81], [%324, %$90] ; # ->
  br label %$80
$82:
  %327 = phi i64 [%310, %$84] ; # Prg
  %328 = phi i64 [%318, %$84] ; # ->
; # (loop (set (val 2 P) (val P)) (? (== Q (setq P (val 3 P)))))
  br label %$91
$91:
  %329 = phi i64 [%299, %$82], [%342, %$92] ; # X
  %330 = phi i64 [%300, %$82], [%343, %$92] ; # Y
  %331 = phi i64 [%301, %$82], [%344, %$92] ; # P
; # (set (val 2 P) (val P))
; # (val 2 P)
  %332 = inttoptr i64 %331 to i64*
  %333 = getelementptr i64, i64* %332, i32 1
  %334 = load i64, i64* %333
; # (val P)
  %335 = inttoptr i64 %331 to i64*
  %336 = load i64, i64* %335
  %337 = inttoptr i64 %334 to i64*
  store i64 %336, i64* %337
; # (? (== Q (setq P (val 3 P))))
; # (val 3 P)
  %338 = inttoptr i64 %331 to i64*
  %339 = getelementptr i64, i64* %338, i32 2
  %340 = load i64, i64* %339
; # (== Q (setq P (val 3 P)))
  %341 = icmp eq i64 %78, %340
  br i1 %341, label %$93, label %$92
$92:
  %342 = phi i64 [%329, %$91] ; # X
  %343 = phi i64 [%330, %$91] ; # Y
  %344 = phi i64 [%340, %$91] ; # P
  br label %$91
$93:
  %345 = phi i64 [%329, %$91] ; # X
  %346 = phi i64 [%330, %$91] ; # Y
  %347 = phi i64 [%340, %$91] ; # P
  %348 = phi i64 [0, %$91] ; # ->
; # (set $Bind P)
  %349 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %347, i64* %349
  br label %$4
$4:
  %350 = phi i64 [%32, %$18], [%345, %$93] ; # X
  %351 = phi i64 [%11, %$18], [%346, %$93] ; # Y
  %352 = phi i64 [%67, %$18], [%328, %$93] ; # ->
  ret i64 %352
}

define i64 @_LetQ(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (needChkVar Exe (++ X))) (if (nil? (eval (car...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (needChkVar Exe (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$2, label %$3
$2:
  call void @varErr(i64 %0, i64 %5)
  unreachable
$3:
  %10 = icmp uge i64 %5, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %10, label %$5, label %$4
$5:
  %11 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %5
  br label %$4
$4:
  %12 = phi i1 [0, %$3], [%11, %$5] ; # ->
  br i1 %12, label %$6, label %$7
$6:
  call void @protErr(i64 %0, i64 %5)
  unreachable
$7:
; # (if (nil? (eval (car X))) @ (let P (set $Bind (push (val Y) Y (va...
; # (car X)
  %13 = inttoptr i64 %7 to i64*
  %14 = load i64, i64* %13
; # (eval (car X))
  %15 = and i64 %14, 6
  %16 = icmp ne i64 %15, 0
  br i1 %16, label %$10, label %$9
$10:
  br label %$8
$9:
  %17 = and i64 %14, 8
  %18 = icmp ne i64 %17, 0
  br i1 %18, label %$12, label %$11
$12:
  %19 = inttoptr i64 %14 to i64*
  %20 = load i64, i64* %19
  br label %$8
$11:
  %21 = call i64 @evList(i64 %14)
  br label %$8
$8:
  %22 = phi i64 [%14, %$10], [%20, %$12], [%21, %$11] ; # ->
; # (nil? (eval (car X)))
  %23 = icmp eq i64 %22, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %23, label %$13, label %$14
$13:
  br label %$15
$14:
; # (let P (set $Bind (push (val Y) Y (val $Bind))) (set Y @) (prog1 ...
; # (set $Bind (push (val Y) Y (val $Bind)))
; # (val Y)
  %24 = inttoptr i64 %5 to i64*
  %25 = load i64, i64* %24
; # (val $Bind)
  %26 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  %27 = load i64, i64* %26
; # (push (val Y) Y (val $Bind))
  %28 = alloca i64, i64 3, align 16
  %29 = ptrtoint i64* %28 to i64
  %30 = inttoptr i64 %29 to i64*
  store i64 %25, i64* %30
  %31 = add i64 %29, 8
  %32 = inttoptr i64 %31 to i64*
  store i64 %5, i64* %32
  %33 = add i64 %29, 16
  %34 = inttoptr i64 %33 to i64*
  store i64 %27, i64* %34
  %35 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %29, i64* %35
; # (set Y @)
  %36 = inttoptr i64 %5 to i64*
  store i64 %22, i64* %36
; # (prog1 (run (cdr X)) (set Y (val P) $Bind (val 3 P)))
; # (cdr X)
  %37 = inttoptr i64 %7 to i64*
  %38 = getelementptr i64, i64* %37, i32 1
  %39 = load i64, i64* %38
; # (run (cdr X))
  br label %$16
$16:
  %40 = phi i64 [%39, %$14], [%62, %$25] ; # Prg
  %41 = inttoptr i64 %40 to i64*
  %42 = load i64, i64* %41
  %43 = getelementptr i64, i64* %41, i32 1
  %44 = load i64, i64* %43
  %45 = and i64 %44, 15
  %46 = icmp ne i64 %45, 0
  br i1 %46, label %$19, label %$17
$19:
  %47 = phi i64 [%44, %$16] ; # Prg
  %48 = and i64 %42, 6
  %49 = icmp ne i64 %48, 0
  br i1 %49, label %$22, label %$21
$22:
  br label %$20
$21:
  %50 = and i64 %42, 8
  %51 = icmp ne i64 %50, 0
  br i1 %51, label %$24, label %$23
$24:
  %52 = inttoptr i64 %42 to i64*
  %53 = load i64, i64* %52
  br label %$20
$23:
  %54 = call i64 @evList(i64 %42)
  br label %$20
$20:
  %55 = phi i64 [%42, %$22], [%53, %$24], [%54, %$23] ; # ->
  br label %$18
$17:
  %56 = phi i64 [%44, %$16] ; # Prg
  %57 = and i64 %42, 15
  %58 = icmp eq i64 %57, 0
  br i1 %58, label %$26, label %$25
$26:
  %59 = phi i64 [%56, %$17] ; # Prg
  %60 = call i64 @evList(i64 %42)
  %61 = icmp ne i64 %60, 0
  br label %$25
$25:
  %62 = phi i64 [%56, %$17], [%59, %$26] ; # Prg
  %63 = phi i1 [0, %$17], [%61, %$26] ; # ->
  br label %$16
$18:
  %64 = phi i64 [%47, %$20] ; # Prg
  %65 = phi i64 [%55, %$20] ; # ->
; # (set Y (val P) $Bind (val 3 P))
; # (val P)
  %66 = inttoptr i64 %29 to i64*
  %67 = load i64, i64* %66
  %68 = inttoptr i64 %5 to i64*
  store i64 %67, i64* %68
; # (val 3 P)
  %69 = inttoptr i64 %29 to i64*
  %70 = getelementptr i64, i64* %69, i32 2
  %71 = load i64, i64* %70
  %72 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %71, i64* %72
  br label %$15
$15:
  %73 = phi i64 [%22, %$13], [%65, %$18] ; # ->
  ret i64 %73
}

define i64 @_Use(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (++ X)) (if (atom Y) (let P (set $Bind (push ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (if (atom Y) (let P (set $Bind (push (val Y) Y (val $Bind))) (pro...
; # (atom Y)
  %8 = and i64 %5, 15
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$2, label %$3
$2:
  %10 = phi i64 [%5, %$1] ; # Y
; # (let P (set $Bind (push (val Y) Y (val $Bind))) (prog1 (run X) (s...
; # (set $Bind (push (val Y) Y (val $Bind)))
; # (val Y)
  %11 = inttoptr i64 %10 to i64*
  %12 = load i64, i64* %11
; # (val $Bind)
  %13 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  %14 = load i64, i64* %13
; # (push (val Y) Y (val $Bind))
  %15 = alloca i64, i64 3, align 16
  %16 = ptrtoint i64* %15 to i64
  %17 = inttoptr i64 %16 to i64*
  store i64 %12, i64* %17
  %18 = add i64 %16, 8
  %19 = inttoptr i64 %18 to i64*
  store i64 %10, i64* %19
  %20 = add i64 %16, 16
  %21 = inttoptr i64 %20 to i64*
  store i64 %14, i64* %21
  %22 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %16, i64* %22
; # (prog1 (run X) (set Y (val P) $Bind (val 3 P)))
; # (run X)
  br label %$5
$5:
  %23 = phi i64 [%7, %$2], [%45, %$14] ; # Prg
  %24 = inttoptr i64 %23 to i64*
  %25 = load i64, i64* %24
  %26 = getelementptr i64, i64* %24, i32 1
  %27 = load i64, i64* %26
  %28 = and i64 %27, 15
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %$8, label %$6
$8:
  %30 = phi i64 [%27, %$5] ; # Prg
  %31 = and i64 %25, 6
  %32 = icmp ne i64 %31, 0
  br i1 %32, label %$11, label %$10
$11:
  br label %$9
$10:
  %33 = and i64 %25, 8
  %34 = icmp ne i64 %33, 0
  br i1 %34, label %$13, label %$12
$13:
  %35 = inttoptr i64 %25 to i64*
  %36 = load i64, i64* %35
  br label %$9
$12:
  %37 = call i64 @evList(i64 %25)
  br label %$9
$9:
  %38 = phi i64 [%25, %$11], [%36, %$13], [%37, %$12] ; # ->
  br label %$7
$6:
  %39 = phi i64 [%27, %$5] ; # Prg
  %40 = and i64 %25, 15
  %41 = icmp eq i64 %40, 0
  br i1 %41, label %$15, label %$14
$15:
  %42 = phi i64 [%39, %$6] ; # Prg
  %43 = call i64 @evList(i64 %25)
  %44 = icmp ne i64 %43, 0
  br label %$14
$14:
  %45 = phi i64 [%39, %$6], [%42, %$15] ; # Prg
  %46 = phi i1 [0, %$6], [%44, %$15] ; # ->
  br label %$5
$7:
  %47 = phi i64 [%30, %$9] ; # Prg
  %48 = phi i64 [%38, %$9] ; # ->
; # (set Y (val P) $Bind (val 3 P))
; # (val P)
  %49 = inttoptr i64 %16 to i64*
  %50 = load i64, i64* %49
  %51 = inttoptr i64 %10 to i64*
  store i64 %50, i64* %51
; # (val 3 P)
  %52 = inttoptr i64 %16 to i64*
  %53 = getelementptr i64, i64* %52, i32 2
  %54 = load i64, i64* %53
  %55 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %54, i64* %55
  br label %$4
$3:
  %56 = phi i64 [%5, %$1] ; # Y
; # (let (P (val $Bind) Q P) (loop (let Z (car Y) (set $Bind (setq P ...
; # (val $Bind)
  %57 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  %58 = load i64, i64* %57
; # (loop (let Z (car Y) (set $Bind (setq P (push (val Z) Z P)))) (? ...
  br label %$16
$16:
  %59 = phi i64 [%56, %$3], [%78, %$17] ; # Y
  %60 = phi i64 [%58, %$3], [%79, %$17] ; # P
; # (let Z (car Y) (set $Bind (setq P (push (val Z) Z P))))
; # (car Y)
  %61 = inttoptr i64 %59 to i64*
  %62 = load i64, i64* %61
; # (set $Bind (setq P (push (val Z) Z P)))
; # (val Z)
  %63 = inttoptr i64 %62 to i64*
  %64 = load i64, i64* %63
; # (push (val Z) Z P)
  %65 = alloca i64, i64 3, align 16
  %66 = ptrtoint i64* %65 to i64
  %67 = inttoptr i64 %66 to i64*
  store i64 %64, i64* %67
  %68 = add i64 %66, 8
  %69 = inttoptr i64 %68 to i64*
  store i64 %62, i64* %69
  %70 = add i64 %66, 16
  %71 = inttoptr i64 %70 to i64*
  store i64 %60, i64* %71
  %72 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %66, i64* %72
; # (? (atom (shift Y)))
; # (shift Y)
  %73 = inttoptr i64 %59 to i64*
  %74 = getelementptr i64, i64* %73, i32 1
  %75 = load i64, i64* %74
; # (atom (shift Y))
  %76 = and i64 %75, 15
  %77 = icmp ne i64 %76, 0
  br i1 %77, label %$18, label %$17
$17:
  %78 = phi i64 [%75, %$16] ; # Y
  %79 = phi i64 [%66, %$16] ; # P
  br label %$16
$18:
  %80 = phi i64 [%75, %$16] ; # Y
  %81 = phi i64 [%66, %$16] ; # P
  %82 = phi i64 [0, %$16] ; # ->
; # (prog1 (run X) (loop (set (val 2 P) (val P)) (? (== Q (setq P (va...
; # (run X)
  br label %$19
$19:
  %83 = phi i64 [%7, %$18], [%105, %$28] ; # Prg
  %84 = inttoptr i64 %83 to i64*
  %85 = load i64, i64* %84
  %86 = getelementptr i64, i64* %84, i32 1
  %87 = load i64, i64* %86
  %88 = and i64 %87, 15
  %89 = icmp ne i64 %88, 0
  br i1 %89, label %$22, label %$20
$22:
  %90 = phi i64 [%87, %$19] ; # Prg
  %91 = and i64 %85, 6
  %92 = icmp ne i64 %91, 0
  br i1 %92, label %$25, label %$24
$25:
  br label %$23
$24:
  %93 = and i64 %85, 8
  %94 = icmp ne i64 %93, 0
  br i1 %94, label %$27, label %$26
$27:
  %95 = inttoptr i64 %85 to i64*
  %96 = load i64, i64* %95
  br label %$23
$26:
  %97 = call i64 @evList(i64 %85)
  br label %$23
$23:
  %98 = phi i64 [%85, %$25], [%96, %$27], [%97, %$26] ; # ->
  br label %$21
$20:
  %99 = phi i64 [%87, %$19] ; # Prg
  %100 = and i64 %85, 15
  %101 = icmp eq i64 %100, 0
  br i1 %101, label %$29, label %$28
$29:
  %102 = phi i64 [%99, %$20] ; # Prg
  %103 = call i64 @evList(i64 %85)
  %104 = icmp ne i64 %103, 0
  br label %$28
$28:
  %105 = phi i64 [%99, %$20], [%102, %$29] ; # Prg
  %106 = phi i1 [0, %$20], [%104, %$29] ; # ->
  br label %$19
$21:
  %107 = phi i64 [%90, %$23] ; # Prg
  %108 = phi i64 [%98, %$23] ; # ->
; # (loop (set (val 2 P) (val P)) (? (== Q (setq P (val 3 P)))))
  br label %$30
$30:
  %109 = phi i64 [%80, %$21], [%121, %$31] ; # Y
  %110 = phi i64 [%81, %$21], [%122, %$31] ; # P
; # (set (val 2 P) (val P))
; # (val 2 P)
  %111 = inttoptr i64 %110 to i64*
  %112 = getelementptr i64, i64* %111, i32 1
  %113 = load i64, i64* %112
; # (val P)
  %114 = inttoptr i64 %110 to i64*
  %115 = load i64, i64* %114
  %116 = inttoptr i64 %113 to i64*
  store i64 %115, i64* %116
; # (? (== Q (setq P (val 3 P))))
; # (val 3 P)
  %117 = inttoptr i64 %110 to i64*
  %118 = getelementptr i64, i64* %117, i32 2
  %119 = load i64, i64* %118
; # (== Q (setq P (val 3 P)))
  %120 = icmp eq i64 %58, %119
  br i1 %120, label %$32, label %$31
$31:
  %121 = phi i64 [%109, %$30] ; # Y
  %122 = phi i64 [%119, %$30] ; # P
  br label %$30
$32:
  %123 = phi i64 [%109, %$30] ; # Y
  %124 = phi i64 [%119, %$30] ; # P
  %125 = phi i64 [0, %$30] ; # ->
; # (set $Bind P)
  %126 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %124, i64* %126
  br label %$4
$4:
  %127 = phi i64 [%10, %$7], [%123, %$32] ; # Y
  %128 = phi i64 [%48, %$7], [%108, %$32] ; # ->
  ret i64 %128
}

define i64 @_Buf(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (needChkVar Exe (++ X)) Z (needCnt Exe (eval ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (needChkVar Exe (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$2, label %$3
$2:
  call void @varErr(i64 %0, i64 %5)
  unreachable
$3:
  %10 = icmp uge i64 %5, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %10, label %$5, label %$4
$5:
  %11 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %5
  br label %$4
$4:
  %12 = phi i1 [0, %$3], [%11, %$5] ; # ->
  br i1 %12, label %$6, label %$7
$6:
  call void @protErr(i64 %0, i64 %5)
  unreachable
$7:
; # (++ X)
  %13 = inttoptr i64 %7 to i64*
  %14 = load i64, i64* %13
  %15 = getelementptr i64, i64* %13, i32 1
  %16 = load i64, i64* %15
; # (eval (++ X))
  %17 = and i64 %14, 6
  %18 = icmp ne i64 %17, 0
  br i1 %18, label %$10, label %$9
$10:
  br label %$8
$9:
  %19 = and i64 %14, 8
  %20 = icmp ne i64 %19, 0
  br i1 %20, label %$12, label %$11
$12:
  %21 = inttoptr i64 %14 to i64*
  %22 = load i64, i64* %21
  br label %$8
$11:
  %23 = call i64 @evList(i64 %14)
  br label %$8
$8:
  %24 = phi i64 [%14, %$10], [%22, %$12], [%23, %$11] ; # ->
; # (needCnt Exe (eval (++ X)))
  %25 = and i64 %24, 2
  %26 = icmp ne i64 %25, 0
  br i1 %26, label %$14, label %$13
$13:
  call void @cntErr(i64 %0, i64 %24)
  unreachable
$14:
; # (set $Bind (push (val Y) Y (val $Bind)))
; # (val Y)
  %27 = inttoptr i64 %5 to i64*
  %28 = load i64, i64* %27
; # (val $Bind)
  %29 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  %30 = load i64, i64* %29
; # (push (val Y) Y (val $Bind))
  %31 = alloca i64, i64 3, align 16
  %32 = ptrtoint i64* %31 to i64
  %33 = inttoptr i64 %32 to i64*
  store i64 %28, i64* %33
  %34 = add i64 %32, 8
  %35 = inttoptr i64 %34 to i64*
  store i64 %5, i64* %35
  %36 = add i64 %32, 16
  %37 = inttoptr i64 %36 to i64*
  store i64 %30, i64* %37
  %38 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %32, i64* %38
; # (set Y (box64 (i64 (b8+ (int Z)))))
; # (int Z)
  %39 = lshr i64 %24, 4
; # (b8+ (int Z))
  %40 = alloca i8, i64 %39, align 8
; # (i64 (b8+ (int Z)))
  %41 = ptrtoint i8* %40 to i64
; # (box64 (i64 (b8+ (int Z))))
  %42 = and i64 %41, 17293822569102704640
  %43 = icmp ne i64 %42, 0
  br i1 %43, label %$15, label %$16
$15:
  %44 = call i64 @boxNum(i64 %41)
  br label %$17
$16:
  %45 = shl i64 %41, 4
  %46 = or i64 %45, 2
  br label %$17
$17:
  %47 = phi i64 [%44, %$15], [%46, %$16] ; # ->
  %48 = inttoptr i64 %5 to i64*
  store i64 %47, i64* %48
; # (stkChk Exe)
  %49 = load i8*, i8** @$StkLimit
  %50 = call i8* @llvm.stacksave()
  %51 = icmp ugt i8* %49, %50
  br i1 %51, label %$18, label %$19
$18:
  call void @stkErr(i64 %0)
  unreachable
$19:
; # (prog1 (run X) (set Y (val P) $Bind (val 3 P)))
; # (run X)
  br label %$20
$20:
  %52 = phi i64 [%16, %$19], [%74, %$29] ; # Prg
  %53 = inttoptr i64 %52 to i64*
  %54 = load i64, i64* %53
  %55 = getelementptr i64, i64* %53, i32 1
  %56 = load i64, i64* %55
  %57 = and i64 %56, 15
  %58 = icmp ne i64 %57, 0
  br i1 %58, label %$23, label %$21
$23:
  %59 = phi i64 [%56, %$20] ; # Prg
  %60 = and i64 %54, 6
  %61 = icmp ne i64 %60, 0
  br i1 %61, label %$26, label %$25
$26:
  br label %$24
$25:
  %62 = and i64 %54, 8
  %63 = icmp ne i64 %62, 0
  br i1 %63, label %$28, label %$27
$28:
  %64 = inttoptr i64 %54 to i64*
  %65 = load i64, i64* %64
  br label %$24
$27:
  %66 = call i64 @evList(i64 %54)
  br label %$24
$24:
  %67 = phi i64 [%54, %$26], [%65, %$28], [%66, %$27] ; # ->
  br label %$22
$21:
  %68 = phi i64 [%56, %$20] ; # Prg
  %69 = and i64 %54, 15
  %70 = icmp eq i64 %69, 0
  br i1 %70, label %$30, label %$29
$30:
  %71 = phi i64 [%68, %$21] ; # Prg
  %72 = call i64 @evList(i64 %54)
  %73 = icmp ne i64 %72, 0
  br label %$29
$29:
  %74 = phi i64 [%68, %$21], [%71, %$30] ; # Prg
  %75 = phi i1 [0, %$21], [%73, %$30] ; # ->
  br label %$20
$22:
  %76 = phi i64 [%59, %$24] ; # Prg
  %77 = phi i64 [%67, %$24] ; # ->
; # (set Y (val P) $Bind (val 3 P))
; # (val P)
  %78 = inttoptr i64 %32 to i64*
  %79 = load i64, i64* %78
  %80 = inttoptr i64 %5 to i64*
  store i64 %79, i64* %80
; # (val 3 P)
  %81 = inttoptr i64 %32 to i64*
  %82 = getelementptr i64, i64* %81, i32 2
  %83 = load i64, i64* %82
  %84 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %83, i64* %84
  ret i64 %77
}

define i64 @_Tco(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (car X) Z (val $Link) Par (val $TcoPar) Lnk (...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (car X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (val $Link)
  %6 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %7 = load i64, i64* %6
; # (val $TcoPar)
  %8 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 112) to i64) to i64*
  %9 = load i64, i64* %8
; # (val $TcoLnk)
  %10 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 120) to i64) to i64*
  %11 = load i64, i64* %10
; # (set $TcoPar Y)
  %12 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 112) to i64) to i64*
  store i64 %5, i64* %12
; # (while (pair Y) (set $Link (push $Nil (val $Link))) (shift Y))
  br label %$2
$2:
  %13 = phi i64 [%5, %$1], [%27, %$3] ; # Y
; # (pair Y)
  %14 = and i64 %13, 15
  %15 = icmp eq i64 %14, 0
  br i1 %15, label %$3, label %$4
$3:
  %16 = phi i64 [%13, %$2] ; # Y
; # (set $Link (push $Nil (val $Link)))
; # (val $Link)
  %17 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %18 = load i64, i64* %17
; # (push $Nil (val $Link))
  %19 = alloca i64, i64 2, align 16
  %20 = ptrtoint i64* %19 to i64
  %21 = inttoptr i64 %20 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %21
  %22 = add i64 %20, 8
  %23 = inttoptr i64 %22 to i64*
  store i64 %18, i64* %23
  %24 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %20, i64* %24
; # (shift Y)
  %25 = inttoptr i64 %16 to i64*
  %26 = getelementptr i64, i64* %25, i32 1
  %27 = load i64, i64* %26
  br label %$2
$4:
  %28 = phi i64 [%13, %$2] ; # Y
; # (set $TcoLnk (val $Link))
; # (val $Link)
  %29 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %30 = load i64, i64* %29
  %31 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 120) to i64) to i64*
  store i64 %30, i64* %31
; # (loop (setq Y (car X)) (let V (run (cdr X)) (? (not (prog1 (val $...
  br label %$5
$5:
  %32 = phi i64 [%28, %$4], [%88, %$22] ; # Y
; # (car X)
  %33 = inttoptr i64 %3 to i64*
  %34 = load i64, i64* %33
; # (let V (run (cdr X)) (? (not (prog1 (val $Tc) (set $Tc NO))) (set...
; # (cdr X)
  %35 = inttoptr i64 %3 to i64*
  %36 = getelementptr i64, i64* %35, i32 1
  %37 = load i64, i64* %36
; # (run (cdr X))
  br label %$6
$6:
  %38 = phi i64 [%37, %$5], [%60, %$15] ; # Prg
  %39 = inttoptr i64 %38 to i64*
  %40 = load i64, i64* %39
  %41 = getelementptr i64, i64* %39, i32 1
  %42 = load i64, i64* %41
  %43 = and i64 %42, 15
  %44 = icmp ne i64 %43, 0
  br i1 %44, label %$9, label %$7
$9:
  %45 = phi i64 [%42, %$6] ; # Prg
  %46 = and i64 %40, 6
  %47 = icmp ne i64 %46, 0
  br i1 %47, label %$12, label %$11
$12:
  br label %$10
$11:
  %48 = and i64 %40, 8
  %49 = icmp ne i64 %48, 0
  br i1 %49, label %$14, label %$13
$14:
  %50 = inttoptr i64 %40 to i64*
  %51 = load i64, i64* %50
  br label %$10
$13:
  %52 = call i64 @evList(i64 %40)
  br label %$10
$10:
  %53 = phi i64 [%40, %$12], [%51, %$14], [%52, %$13] ; # ->
  br label %$8
$7:
  %54 = phi i64 [%42, %$6] ; # Prg
  %55 = and i64 %40, 15
  %56 = icmp eq i64 %55, 0
  br i1 %56, label %$16, label %$15
$16:
  %57 = phi i64 [%54, %$7] ; # Prg
  %58 = call i64 @evList(i64 %40)
  %59 = icmp ne i64 %58, 0
  br label %$15
$15:
  %60 = phi i64 [%54, %$7], [%57, %$16] ; # Prg
  %61 = phi i1 [0, %$7], [%59, %$16] ; # ->
  br label %$6
$8:
  %62 = phi i64 [%45, %$10] ; # Prg
  %63 = phi i64 [%53, %$10] ; # ->
; # (? (not (prog1 (val $Tc) (set $Tc NO))) (set $TcoLnk Lnk $TcoPar ...
; # (prog1 (val $Tc) (set $Tc NO))
; # (val $Tc)
  %64 = load i1, i1* @$Tc
; # (set $Tc NO)
  store i1 0, i1* @$Tc
; # (not (prog1 (val $Tc) (set $Tc NO)))
  %65 = icmp eq i1 %64, 0
  br i1 %65, label %$19, label %$17
$19:
  %66 = phi i64 [%34, %$8] ; # Y
; # (set $TcoLnk Lnk $TcoPar Par $Link Z)
  %67 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 120) to i64) to i64*
  store i64 %11, i64* %67
  %68 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 112) to i64) to i64*
  store i64 %9, i64* %68
  %69 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %7, i64* %69
  br label %$18
$17:
  %70 = phi i64 [%34, %$8] ; # Y
; # (let L (val $Link) (while (pair Y) (set (++ Y) (++ L))))
; # (val $Link)
  %71 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %72 = load i64, i64* %71
; # (while (pair Y) (set (++ Y) (++ L)))
  br label %$20
$20:
  %73 = phi i64 [%70, %$17], [%82, %$21] ; # Y
  %74 = phi i64 [%72, %$17], [%86, %$21] ; # L
; # (pair Y)
  %75 = and i64 %73, 15
  %76 = icmp eq i64 %75, 0
  br i1 %76, label %$21, label %$22
$21:
  %77 = phi i64 [%73, %$20] ; # Y
  %78 = phi i64 [%74, %$20] ; # L
; # (set (++ Y) (++ L))
; # (++ Y)
  %79 = inttoptr i64 %77 to i64*
  %80 = load i64, i64* %79
  %81 = getelementptr i64, i64* %79, i32 1
  %82 = load i64, i64* %81
; # (++ L)
  %83 = inttoptr i64 %78 to i64*
  %84 = load i64, i64* %83
  %85 = getelementptr i64, i64* %83, i32 1
  %86 = load i64, i64* %85
  %87 = inttoptr i64 %80 to i64*
  store i64 %84, i64* %87
  br label %$20
$22:
  %88 = phi i64 [%73, %$20] ; # Y
  %89 = phi i64 [%74, %$20] ; # L
  br label %$5
$18:
  %90 = phi i64 [%66, %$19] ; # Y
  %91 = phi i64 [%63, %$19] ; # ->
  ret i64 %91
}

define i64 @_Tc(i64) align 8 {
$1:
; # (let (X Exe P (val $TcoPar) L (val $TcoLnk)) (set $Tc YES) (while...
; # (val $TcoPar)
  %1 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 112) to i64) to i64*
  %2 = load i64, i64* %1
; # (val $TcoLnk)
  %3 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 120) to i64) to i64*
  %4 = load i64, i64* %3
; # (set $Tc YES)
  store i1 1, i1* @$Tc
; # (while (pair P) (set L (eval (car (shift X)))) (shift L) (shift P...
  br label %$2
$2:
  %5 = phi i64 [%0, %$1], [%15, %$5] ; # X
  %6 = phi i64 [%2, %$1], [%32, %$5] ; # P
  %7 = phi i64 [%4, %$1], [%29, %$5] ; # L
; # (pair P)
  %8 = and i64 %6, 15
  %9 = icmp eq i64 %8, 0
  br i1 %9, label %$3, label %$4
$3:
  %10 = phi i64 [%5, %$2] ; # X
  %11 = phi i64 [%6, %$2] ; # P
  %12 = phi i64 [%7, %$2] ; # L
; # (set L (eval (car (shift X))))
; # (shift X)
  %13 = inttoptr i64 %10 to i64*
  %14 = getelementptr i64, i64* %13, i32 1
  %15 = load i64, i64* %14
; # (car (shift X))
  %16 = inttoptr i64 %15 to i64*
  %17 = load i64, i64* %16
; # (eval (car (shift X)))
  %18 = and i64 %17, 6
  %19 = icmp ne i64 %18, 0
  br i1 %19, label %$7, label %$6
$7:
  br label %$5
$6:
  %20 = and i64 %17, 8
  %21 = icmp ne i64 %20, 0
  br i1 %21, label %$9, label %$8
$9:
  %22 = inttoptr i64 %17 to i64*
  %23 = load i64, i64* %22
  br label %$5
$8:
  %24 = call i64 @evList(i64 %17)
  br label %$5
$5:
  %25 = phi i64 [%17, %$7], [%23, %$9], [%24, %$8] ; # ->
  %26 = inttoptr i64 %12 to i64*
  store i64 %25, i64* %26
; # (shift L)
  %27 = inttoptr i64 %12 to i64*
  %28 = getelementptr i64, i64* %27, i32 1
  %29 = load i64, i64* %28
; # (shift P)
  %30 = inttoptr i64 %11 to i64*
  %31 = getelementptr i64, i64* %30, i32 1
  %32 = load i64, i64* %31
  br label %$2
$4:
  %33 = phi i64 [%5, %$2] ; # X
  %34 = phi i64 [%6, %$2] ; # P
  %35 = phi i64 [%7, %$2] ; # L
  ret i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
}

define i64 @_Catch(i64) align 8 {
$1:
; # (let (X (cdr Exe) Ca: (caFrame (b8+ (+ (val JmpBufSize) (caFrame ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (val JmpBufSize)
  %4 = load i64, i64* @JmpBufSize
; # (+ (val JmpBufSize) (caFrame T))
  %5 = add i64 %4, 272
; # (b8+ (+ (val JmpBufSize) (caFrame T)))
  %6 = alloca i8, i64 %5, align 8
; # (stkChk Exe)
  %7 = load i8*, i8** @$StkLimit
  %8 = call i8* @llvm.stacksave()
  %9 = icmp ugt i8* %7, %8
  br i1 %9, label %$2, label %$3
$2:
  call void @stkErr(i64 %0)
  unreachable
$3:
; # (Ca: tag (eval (++ X)))
  %10 = getelementptr i8, i8* %6, i32 8
  %11 = ptrtoint i8* %10 to i64
  %12 = inttoptr i64 %3 to i64*
  %13 = load i64, i64* %12
  %14 = getelementptr i64, i64* %12, i32 1
  %15 = load i64, i64* %14
  %16 = and i64 %13, 6
  %17 = icmp ne i64 %16, 0
  br i1 %17, label %$6, label %$5
$6:
  br label %$4
$5:
  %18 = and i64 %13, 8
  %19 = icmp ne i64 %18, 0
  br i1 %19, label %$8, label %$7
$8:
  %20 = inttoptr i64 %13 to i64*
  %21 = load i64, i64* %20
  br label %$4
$7:
  %22 = call i64 @evList(i64 %13)
  br label %$4
$4:
  %23 = phi i64 [%13, %$6], [%21, %$8], [%22, %$7] ; # ->
  %24 = inttoptr i64 %11 to i64*
  store i64 %23, i64* %24
; # (Ca: link (val $Catch))
  %25 = bitcast i8* %6 to i8**
  %26 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 32) to i8**)
  store i8* %26, i8** %25
; # (set $Catch (Ca:))
; # (Ca:)
  store i8* %6, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 32) to i8**)
; # (Ca: fin ZERO)
  %27 = getelementptr i8, i8* %6, i32 16
  %28 = ptrtoint i8* %27 to i64
  %29 = inttoptr i64 %28 to i64*
  store i64 2, i64* %29
; # (Ca: co (val $Current))
  %30 = getelementptr i8, i8* %6, i32 24
  %31 = bitcast i8* %30 to i8**
  %32 = load i8*, i8** @$Current
  store i8* %32, i8** %31
; # (Ca:)
; # (putCaEnv (Ca:))
  %33 = getelementptr i8, i8* %6, i32 72
  %34 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i8*
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %33, i8* %34, i64 200, i1 0)
  %35 = getelementptr i8, i8* %6, i32 32
  %36 = ptrtoint i8* %35 to i64
  %37 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 0) to i64) to i64*
  %38 = load i64, i64* %37
  %39 = inttoptr i64 %36 to i64*
  store i64 %38, i64* %39
  %40 = getelementptr i8, i8* %6, i32 40
  %41 = ptrtoint i8* %40 to i64
  %42 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 8) to i64) to i64*
  %43 = load i64, i64* %42
  %44 = inttoptr i64 %41 to i64*
  store i64 %43, i64* %44
  %45 = getelementptr i8, i8* %6, i32 48
  %46 = ptrtoint i8* %45 to i64
  %47 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 8) to i64) to i64*
  %48 = getelementptr i64, i64* %47, i32 1
  %49 = load i64, i64* %48
  %50 = inttoptr i64 %46 to i64*
  store i64 %49, i64* %50
  %51 = getelementptr i8, i8* %6, i32 56
  %52 = ptrtoint i8* %51 to i64
  %53 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 112) to i64) to i64*
  %54 = load i64, i64* %53
  %55 = inttoptr i64 %52 to i64*
  store i64 %54, i64* %55
  %56 = getelementptr i8, i8* %6, i32 64
  %57 = ptrtoint i8* %56 to i64
  %58 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 112) to i64) to i64*
  %59 = getelementptr i64, i64* %58, i32 1
  %60 = load i64, i64* %59
  %61 = inttoptr i64 %57 to i64*
  store i64 %60, i64* %61
; # (prog1 (ifn (setjmp (Ca: (rst))) (prog1 (run X) (set $At2 $Nil)) ...
; # (ifn (setjmp (Ca: (rst))) (prog1 (run X) (set $At2 $Nil)) (set $A...
; # (Ca: (rst))
  %62 = getelementptr i8, i8* %6, i32 272
; # (setjmp (Ca: (rst)))
  %63 = call i32 @setjmp(i8* %62)
  %64 = icmp ne i32 %63, 0
  br i1 %64, label %$10, label %$9
$9:
  %65 = phi i64 [%15, %$4] ; # X
; # (prog1 (run X) (set $At2 $Nil))
; # (run X)
  br label %$12
$12:
  %66 = phi i64 [%65, %$9], [%88, %$21] ; # Prg
  %67 = inttoptr i64 %66 to i64*
  %68 = load i64, i64* %67
  %69 = getelementptr i64, i64* %67, i32 1
  %70 = load i64, i64* %69
  %71 = and i64 %70, 15
  %72 = icmp ne i64 %71, 0
  br i1 %72, label %$15, label %$13
$15:
  %73 = phi i64 [%70, %$12] ; # Prg
  %74 = and i64 %68, 6
  %75 = icmp ne i64 %74, 0
  br i1 %75, label %$18, label %$17
$18:
  br label %$16
$17:
  %76 = and i64 %68, 8
  %77 = icmp ne i64 %76, 0
  br i1 %77, label %$20, label %$19
$20:
  %78 = inttoptr i64 %68 to i64*
  %79 = load i64, i64* %78
  br label %$16
$19:
  %80 = call i64 @evList(i64 %68)
  br label %$16
$16:
  %81 = phi i64 [%68, %$18], [%79, %$20], [%80, %$19] ; # ->
  br label %$14
$13:
  %82 = phi i64 [%70, %$12] ; # Prg
  %83 = and i64 %68, 15
  %84 = icmp eq i64 %83, 0
  br i1 %84, label %$22, label %$21
$22:
  %85 = phi i64 [%82, %$13] ; # Prg
  %86 = call i64 @evList(i64 %68)
  %87 = icmp ne i64 %86, 0
  br label %$21
$21:
  %88 = phi i64 [%82, %$13], [%85, %$22] ; # Prg
  %89 = phi i1 [0, %$13], [%87, %$22] ; # ->
  br label %$12
$14:
  %90 = phi i64 [%73, %$16] ; # Prg
  %91 = phi i64 [%81, %$16] ; # ->
; # (set $At2 $Nil)
  %92 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 456) to i64) to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %92
  br label %$11
$10:
  %93 = phi i64 [%15, %$4] ; # X
; # (set $At2 $T)
  %94 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 456) to i64) to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), i64* %94
; # (val $Ret)
  %95 = load i64, i64* @$Ret
  br label %$11
$11:
  %96 = phi i64 [%65, %$14], [%93, %$10] ; # X
  %97 = phi i64 [%91, %$14], [%95, %$10] ; # ->
; # (set $Catch (Ca: link))
; # (Ca: link)
  %98 = bitcast i8* %6 to i8**
  %99 = load i8*, i8** %98
  store i8* %99, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 32) to i8**)
  ret i64 %97
}

define i64 @_Throw(i64) align 8 {
$1:
; # (let (X (cdr Exe) Tag (save (eval (++ X))) R (save (eval (car X))...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (save (eval (++ X)))
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %17 = load i64, i64* %16
  %18 = alloca i64, i64 2, align 16
  %19 = ptrtoint i64* %18 to i64
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = add i64 %19, 8
  %22 = inttoptr i64 %21 to i64*
  store i64 %17, i64* %22
  %23 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %19, i64* %23
; # (car X)
  %24 = inttoptr i64 %7 to i64*
  %25 = load i64, i64* %24
; # (eval (car X))
  %26 = and i64 %25, 6
  %27 = icmp ne i64 %26, 0
  br i1 %27, label %$9, label %$8
$9:
  br label %$7
$8:
  %28 = and i64 %25, 8
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %$11, label %$10
$11:
  %30 = inttoptr i64 %25 to i64*
  %31 = load i64, i64* %30
  br label %$7
$10:
  %32 = call i64 @evList(i64 %25)
  br label %$7
$7:
  %33 = phi i64 [%25, %$9], [%31, %$11], [%32, %$10] ; # ->
; # (save (eval (car X)))
  %34 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %35 = load i64, i64* %34
  %36 = alloca i64, i64 2, align 16
  %37 = ptrtoint i64* %36 to i64
  %38 = inttoptr i64 %37 to i64*
  store i64 %33, i64* %38
  %39 = add i64 %37, 8
  %40 = inttoptr i64 %39 to i64*
  store i64 %35, i64* %40
  %41 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %37, i64* %41
; # (let Ca (val $Catch) (while Ca (let Ca: (caFrame Ca) (when (or (t...
; # (val $Catch)
  %42 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 32) to i8**)
; # (while Ca (let Ca: (caFrame Ca) (when (or (t? (Ca: tag)) (== Tag ...
  br label %$12
$12:
  %43 = phi i8* [%42, %$7], [%63, %$18] ; # Ca
  %44 = icmp ne i8* %43, null
  br i1 %44, label %$13, label %$14
$13:
  %45 = phi i8* [%43, %$12] ; # Ca
; # (let Ca: (caFrame Ca) (when (or (t? (Ca: tag)) (== Tag (Ca: tag))...
; # (when (or (t? (Ca: tag)) (== Tag (Ca: tag))) (unwind Ca) (set $Re...
; # (or (t? (Ca: tag)) (== Tag (Ca: tag)))
; # (Ca: tag)
  %46 = getelementptr i8, i8* %45, i32 8
  %47 = ptrtoint i8* %46 to i64
  %48 = inttoptr i64 %47 to i64*
  %49 = load i64, i64* %48
; # (t? (Ca: tag))
  %50 = icmp eq i64 %49, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %50, label %$15, label %$16
$16:
  %51 = phi i8* [%45, %$13] ; # Ca
; # (Ca: tag)
  %52 = getelementptr i8, i8* %45, i32 8
  %53 = ptrtoint i8* %52 to i64
  %54 = inttoptr i64 %53 to i64*
  %55 = load i64, i64* %54
; # (== Tag (Ca: tag))
  %56 = icmp eq i64 %15, %55
  br label %$15
$15:
  %57 = phi i8* [%45, %$13], [%51, %$16] ; # Ca
  %58 = phi i1 [1, %$13], [%56, %$16] ; # ->
  br i1 %58, label %$17, label %$18
$17:
  %59 = phi i8* [%57, %$15] ; # Ca
; # (unwind Ca)
  call void @unwind(i8* %59)
; # (set $Ret R)
  store i64 %33, i64* @$Ret
; # (Ca: (rst))
  %60 = getelementptr i8, i8* %45, i32 272
; # (longjmp (Ca: (rst)) 1)
  call void @longjmp(i8* %60, i32 1)
  unreachable
$18:
  %61 = phi i8* [%57, %$15] ; # Ca
; # (Ca: link)
  %62 = bitcast i8* %45 to i8**
  %63 = load i8*, i8** %62
  br label %$12
$14:
  %64 = phi i8* [%43, %$12] ; # Ca
; # (err Exe Tag ($ "Tag not found") null)
  call void @err(i64 %0, i64 %15, i8* bitcast ([14 x i8]* @$76 to i8*), i8* null)
  unreachable
}

define i64 @_Finally(i64) align 8 {
$1:
; # (let (X (cdr Exe) Ca: (caFrame (b8+ (+ (val JmpBufSize) (caFrame ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (val JmpBufSize)
  %4 = load i64, i64* @JmpBufSize
; # (+ (val JmpBufSize) (caFrame T))
  %5 = add i64 %4, 272
; # (b8+ (+ (val JmpBufSize) (caFrame T)))
  %6 = alloca i8, i64 %5, align 8
; # (stkChk Exe)
  %7 = load i8*, i8** @$StkLimit
  %8 = call i8* @llvm.stacksave()
  %9 = icmp ugt i8* %7, %8
  br i1 %9, label %$2, label %$3
$2:
  call void @stkErr(i64 %0)
  unreachable
$3:
; # (Ca: tag 0)
  %10 = getelementptr i8, i8* %6, i32 8
  %11 = ptrtoint i8* %10 to i64
  %12 = inttoptr i64 %11 to i64*
  store i64 0, i64* %12
; # (Ca: link (val $Catch))
  %13 = bitcast i8* %6 to i8**
  %14 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 32) to i8**)
  store i8* %14, i8** %13
; # (set $Catch (Ca:))
; # (Ca:)
  store i8* %6, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 32) to i8**)
; # (Ca: fin (++ X))
  %15 = getelementptr i8, i8* %6, i32 16
  %16 = ptrtoint i8* %15 to i64
  %17 = inttoptr i64 %3 to i64*
  %18 = load i64, i64* %17
  %19 = getelementptr i64, i64* %17, i32 1
  %20 = load i64, i64* %19
  %21 = inttoptr i64 %16 to i64*
  store i64 %18, i64* %21
; # (Ca: co (val $Current))
  %22 = getelementptr i8, i8* %6, i32 24
  %23 = bitcast i8* %22 to i8**
  %24 = load i8*, i8** @$Current
  store i8* %24, i8** %23
; # (Ca:)
; # (putCaEnv (Ca:))
  %25 = getelementptr i8, i8* %6, i32 72
  %26 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i8*
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %25, i8* %26, i64 200, i1 0)
  %27 = getelementptr i8, i8* %6, i32 32
  %28 = ptrtoint i8* %27 to i64
  %29 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 0) to i64) to i64*
  %30 = load i64, i64* %29
  %31 = inttoptr i64 %28 to i64*
  store i64 %30, i64* %31
  %32 = getelementptr i8, i8* %6, i32 40
  %33 = ptrtoint i8* %32 to i64
  %34 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 8) to i64) to i64*
  %35 = load i64, i64* %34
  %36 = inttoptr i64 %33 to i64*
  store i64 %35, i64* %36
  %37 = getelementptr i8, i8* %6, i32 48
  %38 = ptrtoint i8* %37 to i64
  %39 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 8) to i64) to i64*
  %40 = getelementptr i64, i64* %39, i32 1
  %41 = load i64, i64* %40
  %42 = inttoptr i64 %38 to i64*
  store i64 %41, i64* %42
  %43 = getelementptr i8, i8* %6, i32 56
  %44 = ptrtoint i8* %43 to i64
  %45 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 112) to i64) to i64*
  %46 = load i64, i64* %45
  %47 = inttoptr i64 %44 to i64*
  store i64 %46, i64* %47
  %48 = getelementptr i8, i8* %6, i32 64
  %49 = ptrtoint i8* %48 to i64
  %50 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 112) to i64) to i64*
  %51 = getelementptr i64, i64* %50, i32 1
  %52 = load i64, i64* %51
  %53 = inttoptr i64 %49 to i64*
  store i64 %52, i64* %53
; # (prog1 (save (run X)) (eval (Ca: fin)) (set $Catch (Ca: link)))
; # (run X)
  br label %$4
$4:
  %54 = phi i64 [%20, %$3], [%76, %$13] ; # Prg
  %55 = inttoptr i64 %54 to i64*
  %56 = load i64, i64* %55
  %57 = getelementptr i64, i64* %55, i32 1
  %58 = load i64, i64* %57
  %59 = and i64 %58, 15
  %60 = icmp ne i64 %59, 0
  br i1 %60, label %$7, label %$5
$7:
  %61 = phi i64 [%58, %$4] ; # Prg
  %62 = and i64 %56, 6
  %63 = icmp ne i64 %62, 0
  br i1 %63, label %$10, label %$9
$10:
  br label %$8
$9:
  %64 = and i64 %56, 8
  %65 = icmp ne i64 %64, 0
  br i1 %65, label %$12, label %$11
$12:
  %66 = inttoptr i64 %56 to i64*
  %67 = load i64, i64* %66
  br label %$8
$11:
  %68 = call i64 @evList(i64 %56)
  br label %$8
$8:
  %69 = phi i64 [%56, %$10], [%67, %$12], [%68, %$11] ; # ->
  br label %$6
$5:
  %70 = phi i64 [%58, %$4] ; # Prg
  %71 = and i64 %56, 15
  %72 = icmp eq i64 %71, 0
  br i1 %72, label %$14, label %$13
$14:
  %73 = phi i64 [%70, %$5] ; # Prg
  %74 = call i64 @evList(i64 %56)
  %75 = icmp ne i64 %74, 0
  br label %$13
$13:
  %76 = phi i64 [%70, %$5], [%73, %$14] ; # Prg
  %77 = phi i1 [0, %$5], [%75, %$14] ; # ->
  br label %$4
$6:
  %78 = phi i64 [%61, %$8] ; # Prg
  %79 = phi i64 [%69, %$8] ; # ->
; # (save (run X))
  %80 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %81 = load i64, i64* %80
  %82 = alloca i64, i64 2, align 16
  %83 = ptrtoint i64* %82 to i64
  %84 = inttoptr i64 %83 to i64*
  store i64 %79, i64* %84
  %85 = add i64 %83, 8
  %86 = inttoptr i64 %85 to i64*
  store i64 %81, i64* %86
  %87 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %83, i64* %87
; # (Ca: fin)
  %88 = getelementptr i8, i8* %6, i32 16
  %89 = ptrtoint i8* %88 to i64
  %90 = inttoptr i64 %89 to i64*
  %91 = load i64, i64* %90
; # (eval (Ca: fin))
  %92 = and i64 %91, 6
  %93 = icmp ne i64 %92, 0
  br i1 %93, label %$17, label %$16
$17:
  br label %$15
$16:
  %94 = and i64 %91, 8
  %95 = icmp ne i64 %94, 0
  br i1 %95, label %$19, label %$18
$19:
  %96 = inttoptr i64 %91 to i64*
  %97 = load i64, i64* %96
  br label %$15
$18:
  %98 = call i64 @evList(i64 %91)
  br label %$15
$15:
  %99 = phi i64 [%91, %$17], [%97, %$19], [%98, %$18] ; # ->
; # (set $Catch (Ca: link))
; # (Ca: link)
  %100 = bitcast i8* %6 to i8**
  %101 = load i8*, i8** %100
  store i8* %101, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 32) to i8**)
; # (drop *Safe)
  %102 = inttoptr i64 %83 to i64*
  %103 = getelementptr i64, i64* %102, i32 1
  %104 = load i64, i64* %103
  %105 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %104, i64* %105
  ret i64 %79
}

define void @coErr(i64, i64) align 8 {
$1:
; # (err Exe Tag ($ "Coroutine not found") null)
  call void @err(i64 %0, i64 %1, i8* bitcast ([20 x i8]* @$77 to i8*), i8* null)
  unreachable
}

define void @reentErr(i64, i64) align 8 {
$1:
; # (err Exe Tag ($ "Reentrant coroutine") null)
  call void @err(i64 %0, i64 %1, i8* bitcast ([20 x i8]* @$78 to i8*), i8* null)
  unreachable
}

define void @tagErr(i64) align 8 {
$1:
; # (err Exe 0 ($ "Tag expected") null)
  call void @err(i64 %0, i64 0, i8* bitcast ([13 x i8]* @$79 to i8*), i8* null)
  unreachable
}

define void @stkOverErr(i64) align 8 {
$1:
; # (set $StkLimit null)
  store i8* null, i8** @$StkLimit
; # (err 0 Tag ($ "Stack overwritten") null)
  call void @err(i64 0, i64 %0, i8* bitcast ([18 x i8]* @$80 to i8*), i8* null)
  unreachable
}

define void @saveCoIO() align 8 {
$1:
; # (val $OutFrames)
  %0 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 48) to i8**)
; # ((ioFrame (val $OutFrames)) fun (val (i8** $Put)))
  %1 = getelementptr i8, i8* %0, i32 16
  %2 = bitcast i8* %1 to i8**
  %3 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**) to i8**
  %4 = load i8*, i8** %3
  store i8* %4, i8** %2
; # (let Io: (ioFrame (val $InFrames)) (Io: fun (val (i8** $Get))) (i...
; # (val $InFrames)
  %5 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 40) to i8**)
; # (Io: fun (val (i8** $Get)))
  %6 = getelementptr i8, i8* %5, i32 16
  %7 = bitcast i8* %6 to i8**
  %8 = bitcast i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**) to i8**
  %9 = load i8*, i8** %8
  store i8* %9, i8** %7
; # (if (Io: file) ((inFile @) chr (val $Chr)) ((ioxFrame (Io:)) chr ...
; # (Io: file)
  %10 = getelementptr i8, i8* %5, i32 8
  %11 = bitcast i8* %10 to i8**
  %12 = load i8*, i8** %11
  %13 = icmp ne i8* %12, null
  br i1 %13, label %$2, label %$3
$2:
; # ((inFile @) chr (val $Chr))
  %14 = getelementptr i8, i8* %12, i32 12
  %15 = bitcast i8* %14 to i32*
  %16 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
  store i32 %16, i32* %15
  br label %$4
$3:
; # (Io:)
; # ((ioxFrame (Io:)) chr (val $Chr))
  %17 = getelementptr i8, i8* %5, i32 32
  %18 = bitcast i8* %17 to i32*
  %19 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
  store i32 %19, i32* %18
  br label %$4
$4:
  %20 = phi i32 [%16, %$2], [%19, %$3] ; # ->
  ret void
}

define void @saveCoEnv(i8*) align 8 {
$1:
; # (let Crt: (coroutine Crt) (unless (== (hex "0707070707070707") (v...
; # (unless (== (hex "0707070707070707") (val (i64* (Crt: lim)))) (st...
; # (Crt: lim)
  %1 = getelementptr i8, i8* %0, i32 40
  %2 = bitcast i8* %1 to i8**
  %3 = load i8*, i8** %2
; # (i64* (Crt: lim))
  %4 = bitcast i8* %3 to i64*
; # (val (i64* (Crt: lim)))
  %5 = load i64, i64* %4
; # (== (hex "0707070707070707") (val (i64* (Crt: lim))))
  %6 = icmp eq i64 506381209866536711, %5
  br i1 %6, label %$3, label %$2
$2:
; # (Crt: tag)
  %7 = ptrtoint i8* %0 to i64
  %8 = inttoptr i64 %7 to i64*
  %9 = load i64, i64* %8
; # (stkOverErr (Crt: tag))
  call void @stkOverErr(i64 %9)
  unreachable
$3:
; # (Crt: at (val $At))
  %10 = getelementptr i8, i8* %0, i32 48
  %11 = ptrtoint i8* %10 to i64
  %12 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  %13 = load i64, i64* %12
  %14 = inttoptr i64 %11 to i64*
  store i64 %13, i64* %14
; # (Crt:)
; # (putCrtEnv (Crt:))
  %15 = getelementptr i8, i8* %0, i32 152
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i8*
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %15, i8* %16, i64 200, i1 0)
  %17 = getelementptr i8, i8* %0, i32 112
  %18 = ptrtoint i8* %17 to i64
  %19 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 0) to i64) to i64*
  %20 = load i64, i64* %19
  %21 = inttoptr i64 %18 to i64*
  store i64 %20, i64* %21
  %22 = getelementptr i8, i8* %0, i32 120
  %23 = ptrtoint i8* %22 to i64
  %24 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 8) to i64) to i64*
  %25 = load i64, i64* %24
  %26 = inttoptr i64 %23 to i64*
  store i64 %25, i64* %26
  %27 = getelementptr i8, i8* %0, i32 128
  %28 = ptrtoint i8* %27 to i64
  %29 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 8) to i64) to i64*
  %30 = getelementptr i64, i64* %29, i32 1
  %31 = load i64, i64* %30
  %32 = inttoptr i64 %28 to i64*
  store i64 %31, i64* %32
  %33 = getelementptr i8, i8* %0, i32 136
  %34 = ptrtoint i8* %33 to i64
  %35 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 112) to i64) to i64*
  %36 = load i64, i64* %35
  %37 = inttoptr i64 %34 to i64*
  store i64 %36, i64* %37
  %38 = getelementptr i8, i8* %0, i32 144
  %39 = ptrtoint i8* %38 to i64
  %40 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 112) to i64) to i64*
  %41 = getelementptr i64, i64* %40, i32 1
  %42 = load i64, i64* %41
  %43 = inttoptr i64 %39 to i64*
  store i64 %42, i64* %43
  ret void
}

define i64 @loadCoEnv(i8*) align 8 {
$1:
; # (let Crt: (coroutine (set $Current Crt)) (memcpy (env) (Crt: (env...
; # (set $Current Crt)
  store i8* %0, i8** @$Current
; # (i8* $Link)
  %1 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i8*
; # (Crt: (env))
  %2 = getelementptr i8, i8* %0, i32 152
; # (memcpy (env) (Crt: (env)) (env T) T)
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %1, i8* %2, i64 200, i1 0)
; # (set $StkLimit (+ (Crt: lim) 1024))
; # (Crt: lim)
  %3 = getelementptr i8, i8* %0, i32 40
  %4 = bitcast i8* %3 to i8**
  %5 = load i8*, i8** %4
; # (+ (Crt: lim) 1024)
  %6 = getelementptr i8, i8* %5, i32 1024
  store i8* %6, i8** @$StkLimit
; # (Crt:)
; # (getCrtEnv (Crt:))
  %7 = getelementptr i8, i8* %0, i32 112
  %8 = ptrtoint i8* %7 to i64
  %9 = inttoptr i64 %8 to i64*
  %10 = load i64, i64* %9
  %11 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 0) to i64) to i64*
  store i64 %10, i64* %11
  %12 = getelementptr i8, i8* %0, i32 120
  %13 = ptrtoint i8* %12 to i64
  %14 = inttoptr i64 %13 to i64*
  %15 = load i64, i64* %14
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 8) to i64) to i64*
  store i64 %15, i64* %16
  %17 = getelementptr i8, i8* %0, i32 128
  %18 = ptrtoint i8* %17 to i64
  %19 = inttoptr i64 %18 to i64*
  %20 = load i64, i64* %19
  %21 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 8) to i64) to i64*
  %22 = getelementptr i64, i64* %21, i32 1
  store i64 %20, i64* %22
  %23 = getelementptr i8, i8* %0, i32 136
  %24 = ptrtoint i8* %23 to i64
  %25 = inttoptr i64 %24 to i64*
  %26 = load i64, i64* %25
  %27 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 112) to i64) to i64*
  store i64 %26, i64* %27
  %28 = getelementptr i8, i8* %0, i32 144
  %29 = ptrtoint i8* %28 to i64
  %30 = inttoptr i64 %29 to i64*
  %31 = load i64, i64* %30
  %32 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 112) to i64) to i64*
  %33 = getelementptr i64, i64* %32, i32 1
  store i64 %31, i64* %33
; # (set $At (Crt: at))
; # (Crt: at)
  %34 = getelementptr i8, i8* %0, i32 48
  %35 = ptrtoint i8* %34 to i64
  %36 = inttoptr i64 %35 to i64*
  %37 = load i64, i64* %36
  %38 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  store i64 %37, i64* %38
; # (Crt: at 0)
  %39 = getelementptr i8, i8* %0, i32 48
  %40 = ptrtoint i8* %39 to i64
  %41 = inttoptr i64 %40 to i64*
  store i64 0, i64* %41
; # (val $Ret)
  %42 = load i64, i64* @$Ret
  ret i64 %42
}

define void @runCo(i64, i64, i8*, i8*, i64) align 8 {
$1:
; # (let (Src: (coroutine Src) Dst: (coroutine Dst)) (Dst: tag Tag) (...
; # (Dst: tag Tag)
  %5 = ptrtoint i8* %3 to i64
  %6 = inttoptr i64 %5 to i64*
  store i64 %1, i64* %6
; # (Dst: org (Src:))
  %7 = getelementptr i8, i8* %3, i32 16
  %8 = bitcast i8* %7 to i8**
  store i8* %2, i8** %8
; # (Dst: otg (Src: tag))
  %9 = getelementptr i8, i8* %3, i32 24
  %10 = ptrtoint i8* %9 to i64
  %11 = ptrtoint i8* %2 to i64
  %12 = inttoptr i64 %11 to i64*
  %13 = load i64, i64* %12
  %14 = inttoptr i64 %10 to i64*
  store i64 %13, i64* %14
; # (Dst: prg X)
  %15 = getelementptr i8, i8* %3, i32 32
  %16 = ptrtoint i8* %15 to i64
  %17 = inttoptr i64 %16 to i64*
  store i64 %4, i64* %17
; # (let (Siz (val $StkSize) Stk (stack)) (memset (Dst: lim (stack (o...
; # (val $StkSize)
  %18 = load i64, i64* @$StkSize
; # (stack)
  %19 = call i8* @llvm.stacksave()
; # (Dst: lim (stack (ofs Dst (- Siz))))
  %20 = getelementptr i8, i8* %3, i32 40
  %21 = bitcast i8* %20 to i8**
  %22 = sub i64 0, %18
  %23 = getelementptr i8, i8* %3, i64 %22
  call void @llvm.stackrestore(i8* %23)
  store i8* %23, i8** %21
; # (- Siz 256)
  %24 = sub i64 %18, 256
; # (memset (Dst: lim (stack (ofs Dst (- Siz)))) 7 (- Siz 256) T)
  call void @llvm.memset.p0i8.i64(i8* align 8 %23, i8 7, i64 %24, i1 0)
; # (stack Stk)
  call void @llvm.stackrestore(i8* %19)
; # (Dst: at 0)
  %25 = getelementptr i8, i8* %3, i32 48
  %26 = ptrtoint i8* %25 to i64
  %27 = inttoptr i64 %26 to i64*
  store i64 0, i64* %27
; # (Dst: lnk (val $Link))
  %28 = getelementptr i8, i8* %3, i32 56
  %29 = ptrtoint i8* %28 to i64
  %30 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %31 = load i64, i64* %30
  %32 = inttoptr i64 %29 to i64*
  store i64 %31, i64* %32
; # (set $Bind (push (val $This) $This (Dst: bnd (push ZERO $At (val ...
; # (val $This)
  %33 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 488) to i64) to i64*
  %34 = load i64, i64* %33
; # (Dst: bnd (push ZERO $At (val $Bind) Exe))
  %35 = getelementptr i8, i8* %3, i32 64
  %36 = ptrtoint i8* %35 to i64
  %37 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  %38 = load i64, i64* %37
  %39 = alloca i64, i64 4, align 16
  %40 = ptrtoint i64* %39 to i64
  %41 = inttoptr i64 %40 to i64*
  store i64 2, i64* %41
  %42 = add i64 %40, 8
  %43 = inttoptr i64 %42 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64), i64* %43
  %44 = add i64 %40, 16
  %45 = inttoptr i64 %44 to i64*
  store i64 %38, i64* %45
  %46 = add i64 %40, 24
  %47 = inttoptr i64 %46 to i64*
  store i64 %0, i64* %47
  %48 = inttoptr i64 %36 to i64*
  store i64 %40, i64* %48
; # (push (val $This) $This (Dst: bnd (push ZERO $At (val $Bind) Exe)...
  %49 = alloca i64, i64 3, align 16
  %50 = ptrtoint i64* %49 to i64
  %51 = inttoptr i64 %50 to i64*
  store i64 %34, i64* %51
  %52 = add i64 %50, 8
  %53 = inttoptr i64 %52 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 488) to i64), i64* %53
  %54 = add i64 %50, 16
  %55 = inttoptr i64 %54 to i64*
  store i64 %40, i64* %55
  %56 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %50, i64* %56
; # (Dst: ca (val $Catch))
  %57 = getelementptr i8, i8* %3, i32 72
  %58 = bitcast i8* %57 to i8**
  %59 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 32) to i8**)
  store i8* %59, i8** %58
; # (Dst: in (val $InFrames))
  %60 = getelementptr i8, i8* %3, i32 80
  %61 = bitcast i8* %60 to i8**
  %62 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 40) to i8**)
  store i8* %62, i8** %61
; # (Dst: out (val $OutFrames))
  %63 = getelementptr i8, i8* %3, i32 88
  %64 = bitcast i8* %63 to i8**
  %65 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 48) to i8**)
  store i8* %65, i8** %64
; # (Dst: err (val $ErrFrames))
  %66 = getelementptr i8, i8* %3, i32 96
  %67 = bitcast i8* %66 to i8**
  %68 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 56) to i8**)
  store i8* %68, i8** %67
; # (Dst: ctl (val $CtlFrames))
  %69 = getelementptr i8, i8* %3, i32 104
  %70 = bitcast i8* %69 to i8**
  %71 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 64) to i8**)
  store i8* %71, i8** %70
; # (Dst:)
; # (putCrtEnv (Dst:))
  %72 = getelementptr i8, i8* %3, i32 152
  %73 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i8*
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %72, i8* %73, i64 200, i1 0)
  %74 = getelementptr i8, i8* %3, i32 112
  %75 = ptrtoint i8* %74 to i64
  %76 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 0) to i64) to i64*
  %77 = load i64, i64* %76
  %78 = inttoptr i64 %75 to i64*
  store i64 %77, i64* %78
  %79 = getelementptr i8, i8* %3, i32 120
  %80 = ptrtoint i8* %79 to i64
  %81 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 8) to i64) to i64*
  %82 = load i64, i64* %81
  %83 = inttoptr i64 %80 to i64*
  store i64 %82, i64* %83
  %84 = getelementptr i8, i8* %3, i32 128
  %85 = ptrtoint i8* %84 to i64
  %86 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 8) to i64) to i64*
  %87 = getelementptr i64, i64* %86, i32 1
  %88 = load i64, i64* %87
  %89 = inttoptr i64 %85 to i64*
  store i64 %88, i64* %89
  %90 = getelementptr i8, i8* %3, i32 136
  %91 = ptrtoint i8* %90 to i64
  %92 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 112) to i64) to i64*
  %93 = load i64, i64* %92
  %94 = inttoptr i64 %91 to i64*
  store i64 %93, i64* %94
  %95 = getelementptr i8, i8* %3, i32 144
  %96 = ptrtoint i8* %95 to i64
  %97 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 112) to i64) to i64*
  %98 = getelementptr i64, i64* %97, i32 1
  %99 = load i64, i64* %98
  %100 = inttoptr i64 %96 to i64*
  store i64 %99, i64* %100
; # (set $Next $Nil $Make 0 $Yoke 0 $Current (Dst:) $StkLimit (+ (Dst...
  %101 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 128) to i64) to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %101
  %102 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 152) to i64) to i64*
  store i64 0, i64* %102
  %103 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 160) to i64) to i64*
  store i64 0, i64* %103
; # (Dst:)
  store i8* %3, i8** @$Current
; # (Dst: lim)
  %104 = getelementptr i8, i8* %3, i32 40
  %105 = bitcast i8* %104 to i8**
  %106 = load i8*, i8** %105
; # (+ (Dst: lim) 1024)
  %107 = getelementptr i8, i8* %106, i32 1024
  store i8* %107, i8** @$StkLimit
; # (when (symb? Tag) (put Tag ZERO (| (i64 (Dst:)) 2)))
; # (symb? Tag)
  %108 = xor i64 %1, 8
  %109 = and i64 %108, 14
  %110 = icmp eq i64 %109, 0
  br i1 %110, label %$2, label %$3
$2:
; # (Dst:)
; # (i64 (Dst:))
  %111 = ptrtoint i8* %3 to i64
; # (| (i64 (Dst:)) 2)
  %112 = or i64 %111, 2
; # (put Tag ZERO (| (i64 (Dst:)) 2))
  call void @put(i64 %1, i64 2, i64 %112)
  br label %$3
$3:
; # (set $Ret (run X))
; # (run X)
  br label %$4
$4:
  %113 = phi i64 [%4, %$3], [%135, %$13] ; # Prg
  %114 = inttoptr i64 %113 to i64*
  %115 = load i64, i64* %114
  %116 = getelementptr i64, i64* %114, i32 1
  %117 = load i64, i64* %116
  %118 = and i64 %117, 15
  %119 = icmp ne i64 %118, 0
  br i1 %119, label %$7, label %$5
$7:
  %120 = phi i64 [%117, %$4] ; # Prg
  %121 = and i64 %115, 6
  %122 = icmp ne i64 %121, 0
  br i1 %122, label %$10, label %$9
$10:
  br label %$8
$9:
  %123 = and i64 %115, 8
  %124 = icmp ne i64 %123, 0
  br i1 %124, label %$12, label %$11
$12:
  %125 = inttoptr i64 %115 to i64*
  %126 = load i64, i64* %125
  br label %$8
$11:
  %127 = call i64 @evList(i64 %115)
  br label %$8
$8:
  %128 = phi i64 [%115, %$10], [%126, %$12], [%127, %$11] ; # ->
  br label %$6
$5:
  %129 = phi i64 [%117, %$4] ; # Prg
  %130 = and i64 %115, 15
  %131 = icmp eq i64 %130, 0
  br i1 %131, label %$14, label %$13
$14:
  %132 = phi i64 [%129, %$5] ; # Prg
  %133 = call i64 @evList(i64 %115)
  %134 = icmp ne i64 %133, 0
  br label %$13
$13:
  %135 = phi i64 [%129, %$5], [%132, %$14] ; # Prg
  %136 = phi i1 [0, %$5], [%134, %$14] ; # ->
  br label %$4
$6:
  %137 = phi i64 [%120, %$8] ; # Prg
  %138 = phi i64 [%128, %$8] ; # ->
  store i64 %138, i64* @$Ret
; # (unless (== (hex "0707070707070707") (val (i64* (Dst: lim)))) (st...
; # (Dst: lim)
  %139 = getelementptr i8, i8* %3, i32 40
  %140 = bitcast i8* %139 to i8**
  %141 = load i8*, i8** %140
; # (i64* (Dst: lim))
  %142 = bitcast i8* %141 to i64*
; # (val (i64* (Dst: lim)))
  %143 = load i64, i64* %142
; # (== (hex "0707070707070707") (val (i64* (Dst: lim))))
  %144 = icmp eq i64 506381209866536711, %143
  br i1 %144, label %$16, label %$15
$15:
; # (Dst: tag)
  %145 = ptrtoint i8* %3 to i64
  %146 = inttoptr i64 %145 to i64*
  %147 = load i64, i64* %146
; # (stkOverErr (Dst: tag))
  call void @stkOverErr(i64 %147)
  unreachable
$16:
; # (set $This (val -3 (Dst: bnd)))
; # (Dst: bnd)
  %148 = getelementptr i8, i8* %3, i32 64
  %149 = ptrtoint i8* %148 to i64
  %150 = inttoptr i64 %149 to i64*
  %151 = load i64, i64* %150
; # (val -3 (Dst: bnd))
  %152 = inttoptr i64 %151 to i64*
  %153 = getelementptr i64, i64* %152, i32 -4
  %154 = load i64, i64* %153
  %155 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 488) to i64) to i64*
  store i64 %154, i64* %155
; # (Dst:)
; # (stop (Dst:))
  call void @stop(i8* %3)
; # (let Org: (coroutine (Dst: org)) (unless (and (Org:) (== (Org: ta...
; # (Dst: org)
  %156 = getelementptr i8, i8* %3, i32 16
  %157 = bitcast i8* %156 to i8**
  %158 = load i8*, i8** %157
; # (unless (and (Org:) (== (Org: tag) (Dst: otg))) (coErr Exe (Dst: ...
; # (and (Org:) (== (Org: tag) (Dst: otg)))
; # (Org:)
  %159 = icmp ne i8* %158, null
  br i1 %159, label %$18, label %$17
$18:
; # (Org: tag)
  %160 = ptrtoint i8* %158 to i64
  %161 = inttoptr i64 %160 to i64*
  %162 = load i64, i64* %161
; # (Dst: otg)
  %163 = getelementptr i8, i8* %3, i32 24
  %164 = ptrtoint i8* %163 to i64
  %165 = inttoptr i64 %164 to i64*
  %166 = load i64, i64* %165
; # (== (Org: tag) (Dst: otg))
  %167 = icmp eq i64 %162, %166
  br label %$17
$17:
  %168 = phi i1 [0, %$16], [%167, %$18] ; # ->
  br i1 %168, label %$20, label %$19
$19:
; # (Dst: otg)
  %169 = getelementptr i8, i8* %3, i32 24
  %170 = ptrtoint i8* %169 to i64
  %171 = inttoptr i64 %170 to i64*
  %172 = load i64, i64* %171
; # (coErr Exe (Dst: otg))
  call void @coErr(i64 %0, i64 %172)
  unreachable
$20:
; # (Org: (rst))
  %173 = getelementptr i8, i8* %158, i32 352
; # (longjmp (Org: (rst)) 1)
  call void @longjmp(i8* %173, i32 1)
  unreachable
}

define i64 @_Co(i64) align 8 {
$1:
; # (let X (cdr Exe) (if (atom X) (if (val $Current) ((coroutine @) t...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (if (atom X) (if (val $Current) ((coroutine @) tag) $Nil) (let Ta...
; # (atom X)
  %4 = and i64 %3, 15
  %5 = icmp ne i64 %4, 0
  br i1 %5, label %$2, label %$3
$2:
  %6 = phi i64 [%3, %$1] ; # X
; # (if (val $Current) ((coroutine @) tag) $Nil)
; # (val $Current)
  %7 = load i8*, i8** @$Current
  %8 = icmp ne i8* %7, null
  br i1 %8, label %$5, label %$6
$5:
  %9 = phi i64 [%6, %$2] ; # X
; # ((coroutine @) tag)
  %10 = ptrtoint i8* %7 to i64
  %11 = inttoptr i64 %10 to i64*
  %12 = load i64, i64* %11
  br label %$7
$6:
  %13 = phi i64 [%6, %$2] ; # X
  br label %$7
$7:
  %14 = phi i64 [%9, %$5], [%13, %$6] ; # X
  %15 = phi i64 [%12, %$5], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$6] ; # ->
  br label %$4
$3:
  %16 = phi i64 [%3, %$1] ; # X
; # (let Tag (eval (++ X)) (let Crt (val $Current) (loop (? (=0 Crt))...
; # (++ X)
  %17 = inttoptr i64 %16 to i64*
  %18 = load i64, i64* %17
  %19 = getelementptr i64, i64* %17, i32 1
  %20 = load i64, i64* %19
; # (eval (++ X))
  %21 = and i64 %18, 6
  %22 = icmp ne i64 %21, 0
  br i1 %22, label %$10, label %$9
$10:
  br label %$8
$9:
  %23 = and i64 %18, 8
  %24 = icmp ne i64 %23, 0
  br i1 %24, label %$12, label %$11
$12:
  %25 = inttoptr i64 %18 to i64*
  %26 = load i64, i64* %25
  br label %$8
$11:
  %27 = call i64 @evList(i64 %18)
  br label %$8
$8:
  %28 = phi i64 [%18, %$10], [%26, %$12], [%27, %$11] ; # ->
; # (let Crt (val $Current) (loop (? (=0 Crt)) (when (== Tag ((corout...
; # (val $Current)
  %29 = load i8*, i8** @$Current
; # (loop (? (=0 Crt)) (when (== Tag ((coroutine Crt) tag)) (reentErr...
  br label %$13
$13:
  %30 = phi i64 [%20, %$8], [%41, %$17] ; # X
  %31 = phi i8* [%29, %$8], [%45, %$17] ; # Crt
; # (? (=0 Crt))
; # (=0 Crt)
  %32 = icmp eq i8* %31, null
  br i1 %32, label %$15, label %$14
$14:
  %33 = phi i64 [%30, %$13] ; # X
  %34 = phi i8* [%31, %$13] ; # Crt
; # (when (== Tag ((coroutine Crt) tag)) (reentErr Exe Tag))
; # ((coroutine Crt) tag)
  %35 = ptrtoint i8* %34 to i64
  %36 = inttoptr i64 %35 to i64*
  %37 = load i64, i64* %36
; # (== Tag ((coroutine Crt) tag))
  %38 = icmp eq i64 %28, %37
  br i1 %38, label %$16, label %$17
$16:
  %39 = phi i64 [%33, %$14] ; # X
  %40 = phi i8* [%34, %$14] ; # Crt
; # (reentErr Exe Tag)
  call void @reentErr(i64 %0, i64 %28)
  unreachable
$17:
  %41 = phi i64 [%33, %$14] ; # X
  %42 = phi i8* [%34, %$14] ; # Crt
; # ((coroutine Crt) org)
  %43 = getelementptr i8, i8* %42, i32 16
  %44 = bitcast i8* %43 to i8**
  %45 = load i8*, i8** %44
  br label %$13
$15:
  %46 = phi i64 [%30, %$13] ; # X
  %47 = phi i8* [%31, %$13] ; # Crt
  %48 = phi i64 [0, %$13] ; # ->
; # (cond ((nil? Tag) (tagErr Exe)) ((t? Tag) (reentErr Exe Tag)) ((p...
; # (nil? Tag)
  %49 = icmp eq i64 %28, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %49, label %$20, label %$19
$20:
  %50 = phi i64 [%46, %$15] ; # X
; # (tagErr Exe)
  call void @tagErr(i64 %0)
  unreachable
$19:
  %51 = phi i64 [%46, %$15] ; # X
; # (t? Tag)
  %52 = icmp eq i64 %28, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %52, label %$22, label %$21
$22:
  %53 = phi i64 [%51, %$19] ; # X
; # (reentErr Exe Tag)
  call void @reentErr(i64 %0, i64 %28)
  unreachable
$21:
  %54 = phi i64 [%51, %$19] ; # X
; # (pair X)
  %55 = and i64 %54, 15
  %56 = icmp eq i64 %55, 0
  br i1 %56, label %$24, label %$23
$24:
  %57 = phi i64 [%54, %$21] ; # X
; # (unless (val $Coroutines) (let Main: (coroutine (alloc null (+ (v...
; # (val $Coroutines)
  %58 = load i8*, i8** @$Coroutines
  %59 = icmp ne i8* %58, null
  br i1 %59, label %$26, label %$25
$25:
  %60 = phi i64 [%57, %$24] ; # X
; # (let Main: (coroutine (alloc null (+ (val JmpBufSize) (coroutine ...
; # (val JmpBufSize)
  %61 = load i64, i64* @JmpBufSize
; # (+ (val JmpBufSize) (coroutine T))
  %62 = add i64 %61, 352
; # (alloc null (+ (val JmpBufSize) (coroutine T)))
  %63 = call i8* @alloc(i8* null, i64 %62)
; # (Main: tag $T)
  %64 = ptrtoint i8* %63 to i64
  %65 = inttoptr i64 %64 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), i64* %65
; # (Main: nxt null)
  %66 = getelementptr i8, i8* %63, i32 8
  %67 = bitcast i8* %66 to i8**
  store i8* null, i8** %67
; # (Main: org null)
  %68 = getelementptr i8, i8* %63, i32 16
  %69 = bitcast i8* %68 to i8**
  store i8* null, i8** %69
; # (Main: otg $Nil)
  %70 = getelementptr i8, i8* %63, i32 24
  %71 = ptrtoint i8* %70 to i64
  %72 = inttoptr i64 %71 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %72
; # (Main: prg $Nil)
  %73 = getelementptr i8, i8* %63, i32 32
  %74 = ptrtoint i8* %73 to i64
  %75 = inttoptr i64 %74 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %75
; # (let (Siz (val $StkSizeT) Stk (stack)) (memset (Main: lim (stack ...
; # (val $StkSizeT)
  %76 = load i64, i64* @$StkSizeT
; # (stack)
  %77 = call i8* @llvm.stacksave()
; # (Main: lim (stack (ofs Stk (- Siz))))
  %78 = getelementptr i8, i8* %63, i32 40
  %79 = bitcast i8* %78 to i8**
  %80 = sub i64 0, %76
  %81 = getelementptr i8, i8* %77, i64 %80
  call void @llvm.stackrestore(i8* %81)
  store i8* %81, i8** %79
; # (- Siz 256)
  %82 = sub i64 %76, 256
; # (memset (Main: lim (stack (ofs Stk (- Siz)))) 7 (- Siz 256) T)
  call void @llvm.memset.p0i8.i64(i8* align 8 %81, i8 7, i64 %82, i1 0)
; # (stack Stk)
  call void @llvm.stackrestore(i8* %77)
; # (Main: at 0)
  %83 = getelementptr i8, i8* %63, i32 48
  %84 = ptrtoint i8* %83 to i64
  %85 = inttoptr i64 %84 to i64*
  store i64 0, i64* %85
; # (set $Coroutines (set $Current (set $CrtLast (Main:))))
; # (set $Current (set $CrtLast (Main:)))
; # (set $CrtLast (Main:))
; # (Main:)
  store i8* %63, i8** @$CrtLast
  store i8* %63, i8** @$Current
  store i8* %63, i8** @$Coroutines
  br label %$26
$26:
  %86 = phi i64 [%57, %$24], [%60, %$25] ; # X
; # (let (Src: (coroutine (val $Current)) Crt (val $Coroutines)) (sav...
; # (val $Current)
  %87 = load i8*, i8** @$Current
; # (val $Coroutines)
  %88 = load i8*, i8** @$Coroutines
; # (saveCoIO)
  call void @saveCoIO()
; # (Src:)
; # (saveCoEnv (Src:))
  call void @saveCoEnv(i8* %87)
; # (cond ((not (symb? Tag)) (loop (let Crt: (coroutine Crt) (when (=...
; # (symb? Tag)
  %89 = xor i64 %28, 8
  %90 = and i64 %89, 14
  %91 = icmp eq i64 %90, 0
; # (not (symb? Tag))
  %92 = icmp eq i1 %91, 0
  br i1 %92, label %$29, label %$28
$29:
  %93 = phi i64 [%86, %$26] ; # X
  %94 = phi i8* [%88, %$26] ; # Crt
; # (loop (let Crt: (coroutine Crt) (when (== Tag (Crt: tag)) (when (...
  br label %$30
$30:
  %95 = phi i64 [%93, %$29], [%126, %$35] ; # X
  %96 = phi i8* [%94, %$29], [%124, %$35] ; # Crt
; # (let Crt: (coroutine Crt) (when (== Tag (Crt: tag)) (when (setjmp...
; # (when (== Tag (Crt: tag)) (when (setjmp (Src: (rst))) (ret (loadC...
; # (Crt: tag)
  %97 = ptrtoint i8* %96 to i64
  %98 = inttoptr i64 %97 to i64*
  %99 = load i64, i64* %98
; # (== Tag (Crt: tag))
  %100 = icmp eq i64 %28, %99
  br i1 %100, label %$31, label %$32
$31:
  %101 = phi i64 [%95, %$30] ; # X
  %102 = phi i8* [%96, %$30] ; # Crt
; # (when (setjmp (Src: (rst))) (ret (loadCoEnv (Src:))))
; # (Src: (rst))
  %103 = getelementptr i8, i8* %87, i32 352
; # (setjmp (Src: (rst)))
  %104 = call i32 @setjmp(i8* %103)
  %105 = icmp ne i32 %104, 0
  br i1 %105, label %$33, label %$34
$33:
  %106 = phi i64 [%101, %$31] ; # X
  %107 = phi i8* [%102, %$31] ; # Crt
; # (Src:)
; # (loadCoEnv (Src:))
  %108 = call i64 @loadCoEnv(i8* %87)
; # (ret (loadCoEnv (Src:)))
  ret i64 %108
$34:
  %109 = phi i64 [%101, %$31] ; # X
  %110 = phi i8* [%102, %$31] ; # Crt
; # (set $Ret $Nil)
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* @$Ret
; # (Crt: org (Src:))
  %111 = getelementptr i8, i8* %96, i32 16
  %112 = bitcast i8* %111 to i8**
  store i8* %87, i8** %112
; # (Crt: otg (Src: tag))
  %113 = getelementptr i8, i8* %96, i32 24
  %114 = ptrtoint i8* %113 to i64
  %115 = ptrtoint i8* %87 to i64
  %116 = inttoptr i64 %115 to i64*
  %117 = load i64, i64* %116
  %118 = inttoptr i64 %114 to i64*
  store i64 %117, i64* %118
; # (Crt: (rst))
  %119 = getelementptr i8, i8* %96, i32 352
; # (longjmp (Crt: (rst)) 1)
  call void @longjmp(i8* %119, i32 1)
  unreachable
$32:
  %120 = phi i64 [%95, %$30] ; # X
  %121 = phi i8* [%96, %$30] ; # Crt
; # (? (=0 (Crt: nxt)))
; # (Crt: nxt)
  %122 = getelementptr i8, i8* %96, i32 8
  %123 = bitcast i8* %122 to i8**
  %124 = load i8*, i8** %123
; # (=0 (Crt: nxt))
  %125 = icmp eq i8* %124, null
  br i1 %125, label %$36, label %$35
$35:
  %126 = phi i64 [%120, %$32] ; # X
  %127 = phi i8* [%121, %$32] ; # Crt
  br label %$30
$36:
  %128 = phi i64 [%120, %$32] ; # X
  %129 = phi i8* [%121, %$32] ; # Crt
  %130 = phi i64 [0, %$32] ; # ->
  br label %$27
$28:
  %131 = phi i64 [%86, %$26] ; # X
  %132 = phi i8* [%88, %$26] ; # Crt
; # (get Tag ZERO)
  %133 = call i64 @get(i64 %28, i64 2)
; # (cnt? (get Tag ZERO))
  %134 = and i64 %133, 2
  %135 = icmp ne i64 %134, 0
  br i1 %135, label %$38, label %$37
$38:
  %136 = phi i64 [%131, %$28] ; # X
  %137 = phi i8* [%132, %$28] ; # Crt
; # (let Crt: (coroutine (i8* (& @ -3))) (unless (== Tag (Crt: tag)) ...
; # (& @ -3)
  %138 = and i64 %133, -3
; # (i8* (& @ -3))
  %139 = inttoptr i64 %138 to i8*
; # (unless (== Tag (Crt: tag)) (coErr Exe Tag))
; # (Crt: tag)
  %140 = ptrtoint i8* %139 to i64
  %141 = inttoptr i64 %140 to i64*
  %142 = load i64, i64* %141
; # (== Tag (Crt: tag))
  %143 = icmp eq i64 %28, %142
  br i1 %143, label %$40, label %$39
$39:
  %144 = phi i64 [%136, %$38] ; # X
  %145 = phi i8* [%137, %$38] ; # Crt
; # (coErr Exe Tag)
  call void @coErr(i64 %0, i64 %28)
  unreachable
$40:
  %146 = phi i64 [%136, %$38] ; # X
  %147 = phi i8* [%137, %$38] ; # Crt
; # (when (setjmp (Src: (rst))) (ret (loadCoEnv (Src:))))
; # (Src: (rst))
  %148 = getelementptr i8, i8* %87, i32 352
; # (setjmp (Src: (rst)))
  %149 = call i32 @setjmp(i8* %148)
  %150 = icmp ne i32 %149, 0
  br i1 %150, label %$41, label %$42
$41:
  %151 = phi i64 [%146, %$40] ; # X
  %152 = phi i8* [%147, %$40] ; # Crt
; # (Src:)
; # (loadCoEnv (Src:))
  %153 = call i64 @loadCoEnv(i8* %87)
; # (ret (loadCoEnv (Src:)))
  ret i64 %153
$42:
  %154 = phi i64 [%146, %$40] ; # X
  %155 = phi i8* [%147, %$40] ; # Crt
; # (set $Ret $Nil)
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* @$Ret
; # (Crt: org (Src:))
  %156 = getelementptr i8, i8* %139, i32 16
  %157 = bitcast i8* %156 to i8**
  store i8* %87, i8** %157
; # (Crt: otg (Src: tag))
  %158 = getelementptr i8, i8* %139, i32 24
  %159 = ptrtoint i8* %158 to i64
  %160 = ptrtoint i8* %87 to i64
  %161 = inttoptr i64 %160 to i64*
  %162 = load i64, i64* %161
  %163 = inttoptr i64 %159 to i64*
  store i64 %162, i64* %163
; # (Crt: (rst))
  %164 = getelementptr i8, i8* %139, i32 352
; # (longjmp (Crt: (rst)) 1)
  call void @longjmp(i8* %164, i32 1)
  unreachable
$37:
  %165 = phi i64 [%131, %$28] ; # X
  %166 = phi i8* [%132, %$28] ; # Crt
  br label %$27
$27:
  %167 = phi i64 [%128, %$36], [%165, %$37] ; # X
  %168 = phi i8* [%129, %$36], [%166, %$37] ; # Crt
  %169 = phi i64 [%130, %$36], [0, %$37] ; # ->
; # (when (setjmp (Src: (rst))) (ret (loadCoEnv (Src:))))
; # (Src: (rst))
  %170 = getelementptr i8, i8* %87, i32 352
; # (setjmp (Src: (rst)))
  %171 = call i32 @setjmp(i8* %170)
  %172 = icmp ne i32 %171, 0
  br i1 %172, label %$43, label %$44
$43:
  %173 = phi i64 [%167, %$27] ; # X
  %174 = phi i8* [%168, %$27] ; # Crt
; # (Src:)
; # (loadCoEnv (Src:))
  %175 = call i64 @loadCoEnv(i8* %87)
; # (ret (loadCoEnv (Src:)))
  ret i64 %175
$44:
  %176 = phi i64 [%167, %$27] ; # X
  %177 = phi i8* [%168, %$27] ; # Crt
; # (let P (val $CrtFree) (if P (set $CrtFree ((coroutine (stack P)) ...
; # (val $CrtFree)
  %178 = load i8*, i8** @$CrtFree
; # (if P (set $CrtFree ((coroutine (stack P)) lim)) (stack ((corouti...
  %179 = icmp ne i8* %178, null
  br i1 %179, label %$45, label %$46
$45:
  %180 = phi i64 [%176, %$44] ; # X
  %181 = phi i8* [%177, %$44] ; # Crt
  %182 = phi i8* [%178, %$44] ; # P
; # (set $CrtFree ((coroutine (stack P)) lim))
; # (stack P)
  call void @llvm.stackrestore(i8* %182)
; # ((coroutine (stack P)) lim)
  %183 = getelementptr i8, i8* %182, i32 40
  %184 = bitcast i8* %183 to i8**
  %185 = load i8*, i8** %184
  store i8* %185, i8** @$CrtFree
  br label %$47
$46:
  %186 = phi i64 [%176, %$44] ; # X
  %187 = phi i8* [%177, %$44] ; # Crt
  %188 = phi i8* [%178, %$44] ; # P
; # (val $CrtLast)
  %189 = load i8*, i8** @$CrtLast
; # ((coroutine (setq Crt (val $CrtLast))) lim)
  %190 = getelementptr i8, i8* %189, i32 40
  %191 = bitcast i8* %190 to i8**
  %192 = load i8*, i8** %191
; # (stack ((coroutine (setq Crt (val $CrtLast))) lim))
  call void @llvm.stackrestore(i8* %192)
; # (set $CrtLast (setq P (b8+ (+ (val JmpBufSize) (coroutine T)))))
; # (val JmpBufSize)
  %193 = load i64, i64* @JmpBufSize
; # (+ (val JmpBufSize) (coroutine T))
  %194 = add i64 %193, 352
; # (b8+ (+ (val JmpBufSize) (coroutine T)))
  %195 = alloca i8, i64 %194, align 8
  store i8* %195, i8** @$CrtLast
; # ((coroutine Crt) nxt P)
  %196 = getelementptr i8, i8* %189, i32 8
  %197 = bitcast i8* %196 to i8**
  store i8* %195, i8** %197
; # ((coroutine P) nxt null)
  %198 = getelementptr i8, i8* %195, i32 8
  %199 = bitcast i8* %198 to i8**
  store i8* null, i8** %199
  br label %$47
$47:
  %200 = phi i64 [%180, %$45], [%186, %$46] ; # X
  %201 = phi i8* [%181, %$45], [%189, %$46] ; # Crt
  %202 = phi i8* [%182, %$45], [%195, %$46] ; # P
  %203 = phi i8* [%185, %$45], [null, %$46] ; # ->
; # (Src:)
; # (runCo Exe Tag (Src:) P X)
  call void @runCo(i64 %0, i64 %28, i8* %87, i8* %202, i64 %200)
  unreachable
$23:
  %204 = phi i64 [%54, %$21] ; # X
; # (val $Coroutines)
  %205 = load i8*, i8** @$Coroutines
  %206 = icmp ne i8* %205, null
  br i1 %206, label %$49, label %$48
$49:
  %207 = phi i64 [%204, %$23] ; # X
; # (let Crt @ (if (symb? Tag) (when (cnt? (get Tag ZERO)) (setq Crt ...
; # (if (symb? Tag) (when (cnt? (get Tag ZERO)) (setq Crt (i8* (& @ -...
; # (symb? Tag)
  %208 = xor i64 %28, 8
  %209 = and i64 %208, 14
  %210 = icmp eq i64 %209, 0
  br i1 %210, label %$50, label %$51
$50:
  %211 = phi i64 [%207, %$49] ; # X
  %212 = phi i8* [%205, %$49] ; # Crt
; # (when (cnt? (get Tag ZERO)) (setq Crt (i8* (& @ -3))) (unless (==...
; # (get Tag ZERO)
  %213 = call i64 @get(i64 %28, i64 2)
; # (cnt? (get Tag ZERO))
  %214 = and i64 %213, 2
  %215 = icmp ne i64 %214, 0
  br i1 %215, label %$53, label %$54
$53:
  %216 = phi i64 [%211, %$50] ; # X
  %217 = phi i8* [%212, %$50] ; # Crt
; # (& @ -3)
  %218 = and i64 %213, -3
; # (i8* (& @ -3))
  %219 = inttoptr i64 %218 to i8*
; # (unless (== Tag ((coroutine Crt) tag)) (coErr Exe Tag))
; # ((coroutine Crt) tag)
  %220 = ptrtoint i8* %219 to i64
  %221 = inttoptr i64 %220 to i64*
  %222 = load i64, i64* %221
; # (== Tag ((coroutine Crt) tag))
  %223 = icmp eq i64 %28, %222
  br i1 %223, label %$56, label %$55
$55:
  %224 = phi i64 [%216, %$53] ; # X
  %225 = phi i8* [%219, %$53] ; # Crt
; # (coErr Exe Tag)
  call void @coErr(i64 %0, i64 %28)
  unreachable
$56:
  %226 = phi i64 [%216, %$53] ; # X
  %227 = phi i8* [%219, %$53] ; # Crt
; # (: 1 (let P ((coroutine Crt) (env $ErrFrames i8*)) (while P (let ...
  br label %$-1
$-1:
  %228 = phi i64 [%226, %$56], [%395, %$85] ; # X
  %229 = phi i8* [%227, %$56], [%396, %$85] ; # Crt
; # (let P ((coroutine Crt) (env $ErrFrames i8*)) (while P (let Err: ...
; # ((coroutine Crt) (env $ErrFrames i8*))
  %230 = getelementptr i8, i8* %229, i32 152
  %231 = getelementptr i8, i8* %230, i32 56
  %232 = bitcast i8* %231 to i8**
  %233 = load i8*, i8** %232
; # (while P (let Err: (ctFrame P) (when (ge0 (Err: fd)) (close @)) (...
  br label %$57
$57:
  %234 = phi i64 [%228, %$-1], [%249, %$61] ; # X
  %235 = phi i8* [%229, %$-1], [%250, %$61] ; # Crt
  %236 = phi i8* [%233, %$-1], [%253, %$61] ; # P
  %237 = icmp ne i8* %236, null
  br i1 %237, label %$58, label %$59
$58:
  %238 = phi i64 [%234, %$57] ; # X
  %239 = phi i8* [%235, %$57] ; # Crt
  %240 = phi i8* [%236, %$57] ; # P
; # (let Err: (ctFrame P) (when (ge0 (Err: fd)) (close @)) (setq P (E...
; # (when (ge0 (Err: fd)) (close @))
; # (Err: fd)
  %241 = getelementptr i8, i8* %240, i32 8
  %242 = bitcast i8* %241 to i32*
  %243 = load i32, i32* %242
; # (ge0 (Err: fd))
  %244 = icmp sge i32 %243, 0
  br i1 %244, label %$60, label %$61
$60:
  %245 = phi i64 [%238, %$58] ; # X
  %246 = phi i8* [%239, %$58] ; # Crt
  %247 = phi i8* [%240, %$58] ; # P
; # (close @)
  %248 = call i32 @close(i32 %243)
  br label %$61
$61:
  %249 = phi i64 [%238, %$58], [%245, %$60] ; # X
  %250 = phi i8* [%239, %$58], [%246, %$60] ; # Crt
  %251 = phi i8* [%240, %$58], [%247, %$60] ; # P
; # (Err: link)
  %252 = bitcast i8* %240 to i8**
  %253 = load i8*, i8** %252
  br label %$57
$59:
  %254 = phi i64 [%234, %$57] ; # X
  %255 = phi i8* [%235, %$57] ; # Crt
  %256 = phi i8* [%236, %$57] ; # P
; # (let P ((coroutine Crt) (env $OutFrames i8*)) (until (== P (val $...
; # ((coroutine Crt) (env $OutFrames i8*))
  %257 = getelementptr i8, i8* %255, i32 152
  %258 = getelementptr i8, i8* %257, i32 48
  %259 = bitcast i8* %258 to i8**
  %260 = load i8*, i8** %259
; # (until (== P (val $Stdout)) (let Io: (ioFrame P) (when (Io: file)...
  br label %$62
$62:
  %261 = phi i64 [%254, %$59], [%312, %$66] ; # X
  %262 = phi i8* [%255, %$59], [%313, %$66] ; # Crt
  %263 = phi i8* [%260, %$59], [%316, %$66] ; # P
; # (val $Stdout)
  %264 = load i8*, i8** @$Stdout
; # (== P (val $Stdout))
  %265 = icmp eq i8* %263, %264
  br i1 %265, label %$64, label %$63
$63:
  %266 = phi i64 [%261, %$62] ; # X
  %267 = phi i8* [%262, %$62] ; # Crt
  %268 = phi i8* [%263, %$62] ; # P
; # (let Io: (ioFrame P) (when (Io: file) (let Out: (outFile @) (flus...
; # (when (Io: file) (let Out: (outFile @) (flush (Out:)) (when (and ...
; # (Io: file)
  %269 = getelementptr i8, i8* %268, i32 8
  %270 = bitcast i8* %269 to i8**
  %271 = load i8*, i8** %270
  %272 = icmp ne i8* %271, null
  br i1 %272, label %$65, label %$66
$65:
  %273 = phi i64 [%266, %$63] ; # X
  %274 = phi i8* [%267, %$63] ; # Crt
  %275 = phi i8* [%268, %$63] ; # P
; # (let Out: (outFile @) (flush (Out:)) (when (and (ge0 (Out: fd)) (...
; # (Out:)
; # (flush (Out:))
  %276 = call i1 @flush(i8* %271)
; # (when (and (ge0 (Out: fd)) (Io: pid)) (close (Out: fd)) (closeOut...
; # (and (ge0 (Out: fd)) (Io: pid))
; # (Out: fd)
  %277 = bitcast i8* %271 to i32*
  %278 = load i32, i32* %277
; # (ge0 (Out: fd))
  %279 = icmp sge i32 %278, 0
  br i1 %279, label %$68, label %$67
$68:
  %280 = phi i64 [%273, %$65] ; # X
  %281 = phi i8* [%274, %$65] ; # Crt
  %282 = phi i8* [%275, %$65] ; # P
; # (Io: pid)
  %283 = getelementptr i8, i8* %268, i32 24
  %284 = bitcast i8* %283 to i32*
  %285 = load i32, i32* %284
  %286 = icmp ne i32 %285, 0
  br label %$67
$67:
  %287 = phi i64 [%273, %$65], [%280, %$68] ; # X
  %288 = phi i8* [%274, %$65], [%281, %$68] ; # Crt
  %289 = phi i8* [%275, %$65], [%282, %$68] ; # P
  %290 = phi i1 [0, %$65], [%286, %$68] ; # ->
  br i1 %290, label %$69, label %$70
$69:
  %291 = phi i64 [%287, %$67] ; # X
  %292 = phi i8* [%288, %$67] ; # Crt
  %293 = phi i8* [%289, %$67] ; # P
; # (Out: fd)
  %294 = bitcast i8* %271 to i32*
  %295 = load i32, i32* %294
; # (close (Out: fd))
  %296 = call i32 @close(i32 %295)
; # (Out: fd)
  %297 = bitcast i8* %271 to i32*
  %298 = load i32, i32* %297
; # (closeOutFile (Out: fd))
  call void @closeOutFile(i32 %298)
; # (when (> (Io: pid) 1) (waitFile @))
; # (Io: pid)
  %299 = getelementptr i8, i8* %268, i32 24
  %300 = bitcast i8* %299 to i32*
  %301 = load i32, i32* %300
; # (> (Io: pid) 1)
  %302 = icmp sgt i32 %301, 1
  br i1 %302, label %$71, label %$72
$71:
  %303 = phi i64 [%291, %$69] ; # X
  %304 = phi i8* [%292, %$69] ; # Crt
  %305 = phi i8* [%293, %$69] ; # P
; # (waitFile @)
  call void @waitFile(i32 %301)
  br label %$72
$72:
  %306 = phi i64 [%291, %$69], [%303, %$71] ; # X
  %307 = phi i8* [%292, %$69], [%304, %$71] ; # Crt
  %308 = phi i8* [%293, %$69], [%305, %$71] ; # P
  br label %$70
$70:
  %309 = phi i64 [%287, %$67], [%306, %$72] ; # X
  %310 = phi i8* [%288, %$67], [%307, %$72] ; # Crt
  %311 = phi i8* [%289, %$67], [%308, %$72] ; # P
  br label %$66
$66:
  %312 = phi i64 [%266, %$63], [%309, %$70] ; # X
  %313 = phi i8* [%267, %$63], [%310, %$70] ; # Crt
  %314 = phi i8* [%268, %$63], [%311, %$70] ; # P
; # (Io: link)
  %315 = bitcast i8* %268 to i8**
  %316 = load i8*, i8** %315
  br label %$62
$64:
  %317 = phi i64 [%261, %$62] ; # X
  %318 = phi i8* [%262, %$62] ; # Crt
  %319 = phi i8* [%263, %$62] ; # P
; # (let P ((coroutine Crt) (env $InFrames i8*)) (until (== P (val $S...
; # ((coroutine Crt) (env $InFrames i8*))
  %320 = getelementptr i8, i8* %318, i32 152
  %321 = getelementptr i8, i8* %320, i32 40
  %322 = bitcast i8* %321 to i8**
  %323 = load i8*, i8** %322
; # (until (== P (val $Stdin)) (let Io: (ioFrame P) (when (Io: file) ...
  br label %$73
$73:
  %324 = phi i64 [%317, %$64], [%377, %$77] ; # X
  %325 = phi i8* [%318, %$64], [%378, %$77] ; # Crt
  %326 = phi i8* [%323, %$64], [%381, %$77] ; # P
; # (val $Stdin)
  %327 = load i8*, i8** @$Stdin
; # (== P (val $Stdin))
  %328 = icmp eq i8* %326, %327
  br i1 %328, label %$75, label %$74
$74:
  %329 = phi i64 [%324, %$73] ; # X
  %330 = phi i8* [%325, %$73] ; # Crt
  %331 = phi i8* [%326, %$73] ; # P
; # (let Io: (ioFrame P) (when (Io: file) (let In: (inFile @) (when (...
; # (when (Io: file) (let In: (inFile @) (when (and (ge0 (In: fd)) (I...
; # (Io: file)
  %332 = getelementptr i8, i8* %331, i32 8
  %333 = bitcast i8* %332 to i8**
  %334 = load i8*, i8** %333
  %335 = icmp ne i8* %334, null
  br i1 %335, label %$76, label %$77
$76:
  %336 = phi i64 [%329, %$74] ; # X
  %337 = phi i8* [%330, %$74] ; # Crt
  %338 = phi i8* [%331, %$74] ; # P
; # (let In: (inFile @) (when (and (ge0 (In: fd)) (Io: pid)) (close (...
; # (when (and (ge0 (In: fd)) (Io: pid)) (close (In: fd)) (closeInFil...
; # (and (ge0 (In: fd)) (Io: pid))
; # (In: fd)
  %339 = getelementptr i8, i8* %334, i32 8
  %340 = bitcast i8* %339 to i32*
  %341 = load i32, i32* %340
; # (ge0 (In: fd))
  %342 = icmp sge i32 %341, 0
  br i1 %342, label %$79, label %$78
$79:
  %343 = phi i64 [%336, %$76] ; # X
  %344 = phi i8* [%337, %$76] ; # Crt
  %345 = phi i8* [%338, %$76] ; # P
; # (Io: pid)
  %346 = getelementptr i8, i8* %331, i32 24
  %347 = bitcast i8* %346 to i32*
  %348 = load i32, i32* %347
  %349 = icmp ne i32 %348, 0
  br label %$78
$78:
  %350 = phi i64 [%336, %$76], [%343, %$79] ; # X
  %351 = phi i8* [%337, %$76], [%344, %$79] ; # Crt
  %352 = phi i8* [%338, %$76], [%345, %$79] ; # P
  %353 = phi i1 [0, %$76], [%349, %$79] ; # ->
  br i1 %353, label %$80, label %$81
$80:
  %354 = phi i64 [%350, %$78] ; # X
  %355 = phi i8* [%351, %$78] ; # Crt
  %356 = phi i8* [%352, %$78] ; # P
; # (In: fd)
  %357 = getelementptr i8, i8* %334, i32 8
  %358 = bitcast i8* %357 to i32*
  %359 = load i32, i32* %358
; # (close (In: fd))
  %360 = call i32 @close(i32 %359)
; # (In: fd)
  %361 = getelementptr i8, i8* %334, i32 8
  %362 = bitcast i8* %361 to i32*
  %363 = load i32, i32* %362
; # (closeInFile (In: fd))
  call void @closeInFile(i32 %363)
; # (when (> (Io: pid) 1) (waitFile @))
; # (Io: pid)
  %364 = getelementptr i8, i8* %331, i32 24
  %365 = bitcast i8* %364 to i32*
  %366 = load i32, i32* %365
; # (> (Io: pid) 1)
  %367 = icmp sgt i32 %366, 1
  br i1 %367, label %$82, label %$83
$82:
  %368 = phi i64 [%354, %$80] ; # X
  %369 = phi i8* [%355, %$80] ; # Crt
  %370 = phi i8* [%356, %$80] ; # P
; # (waitFile @)
  call void @waitFile(i32 %366)
  br label %$83
$83:
  %371 = phi i64 [%354, %$80], [%368, %$82] ; # X
  %372 = phi i8* [%355, %$80], [%369, %$82] ; # Crt
  %373 = phi i8* [%356, %$80], [%370, %$82] ; # P
  br label %$81
$81:
  %374 = phi i64 [%350, %$78], [%371, %$83] ; # X
  %375 = phi i8* [%351, %$78], [%372, %$83] ; # Crt
  %376 = phi i8* [%352, %$78], [%373, %$83] ; # P
  br label %$77
$77:
  %377 = phi i64 [%329, %$74], [%374, %$81] ; # X
  %378 = phi i8* [%330, %$74], [%375, %$81] ; # Crt
  %379 = phi i8* [%331, %$74], [%376, %$81] ; # P
; # (Io: link)
  %380 = bitcast i8* %331 to i8**
  %381 = load i8*, i8** %380
  br label %$73
$75:
  %382 = phi i64 [%324, %$73] ; # X
  %383 = phi i8* [%325, %$73] ; # Crt
  %384 = phi i8* [%326, %$73] ; # P
; # (stop Crt)
  call void @stop(i8* %383)
  br label %$54
$54:
  %385 = phi i64 [%211, %$50], [%382, %$75] ; # X
  %386 = phi i8* [%212, %$50], [%383, %$75] ; # Crt
  br label %$52
$51:
  %387 = phi i64 [%207, %$49] ; # X
  %388 = phi i8* [%205, %$49] ; # Crt
; # (loop (when (== Tag ((coroutine Crt) tag)) (goto 1)) (? (=0 (setq...
  br label %$84
$84:
  %389 = phi i64 [%387, %$51], [%403, %$87] ; # X
  %390 = phi i8* [%388, %$51], [%404, %$87] ; # Crt
; # (when (== Tag ((coroutine Crt) tag)) (goto 1))
; # ((coroutine Crt) tag)
  %391 = ptrtoint i8* %390 to i64
  %392 = inttoptr i64 %391 to i64*
  %393 = load i64, i64* %392
; # (== Tag ((coroutine Crt) tag))
  %394 = icmp eq i64 %28, %393
  br i1 %394, label %$85, label %$86
$85:
  %395 = phi i64 [%389, %$84] ; # X
  %396 = phi i8* [%390, %$84] ; # Crt
; # (goto 1)
  br label %$-1
$86:
  %397 = phi i64 [%389, %$84] ; # X
  %398 = phi i8* [%390, %$84] ; # Crt
; # (? (=0 (setq Crt ((coroutine Crt) nxt))))
; # ((coroutine Crt) nxt)
  %399 = getelementptr i8, i8* %398, i32 8
  %400 = bitcast i8* %399 to i8**
  %401 = load i8*, i8** %400
; # (=0 (setq Crt ((coroutine Crt) nxt)))
  %402 = icmp eq i8* %401, null
  br i1 %402, label %$88, label %$87
$87:
  %403 = phi i64 [%397, %$86] ; # X
  %404 = phi i8* [%401, %$86] ; # Crt
  br label %$84
$88:
  %405 = phi i64 [%397, %$86] ; # X
  %406 = phi i8* [%401, %$86] ; # Crt
  %407 = phi i64 [0, %$86] ; # ->
  br label %$52
$52:
  %408 = phi i64 [%385, %$54], [%405, %$88] ; # X
  %409 = phi i8* [%386, %$54], [%406, %$88] ; # Crt
  br label %$18
$48:
  %410 = phi i64 [%204, %$23] ; # X
  br label %$18
$18:
  %411 = phi i64 [%408, %$52], [%410, %$48] ; # X
  %412 = phi i64 [%28, %$52], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$48] ; # ->
  br label %$4
$4:
  %413 = phi i64 [%14, %$7], [%411, %$18] ; # X
  %414 = phi i64 [%15, %$7], [%412, %$18] ; # ->
  ret i64 %414
}

define i64 @_Yield(i64) align 8 {
$1:
; # (let (X (cdr Exe) Val (save (eval (++ X))) Tag (eval (++ X)) Crt ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (save (eval (++ X)))
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %17 = load i64, i64* %16
  %18 = alloca i64, i64 2, align 16
  %19 = ptrtoint i64* %18 to i64
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = add i64 %19, 8
  %22 = inttoptr i64 %21 to i64*
  store i64 %17, i64* %22
  %23 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %19, i64* %23
; # (++ X)
  %24 = inttoptr i64 %7 to i64*
  %25 = load i64, i64* %24
  %26 = getelementptr i64, i64* %24, i32 1
  %27 = load i64, i64* %26
; # (eval (++ X))
  %28 = and i64 %25, 6
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %$9, label %$8
$9:
  br label %$7
$8:
  %30 = and i64 %25, 8
  %31 = icmp ne i64 %30, 0
  br i1 %31, label %$11, label %$10
$11:
  %32 = inttoptr i64 %25 to i64*
  %33 = load i64, i64* %32
  br label %$7
$10:
  %34 = call i64 @evList(i64 %25)
  br label %$7
$7:
  %35 = phi i64 [%25, %$9], [%33, %$11], [%34, %$10] ; # ->
; # (val $Coroutines)
  %36 = load i8*, i8** @$Coroutines
; # (unless Crt (err Exe 0 ($ "No coroutines") null))
  %37 = icmp ne i8* %36, null
  br i1 %37, label %$13, label %$12
$12:
  %38 = phi i8* [%36, %$7] ; # Crt
; # (err Exe 0 ($ "No coroutines") null)
  call void @err(i64 %0, i64 0, i8* bitcast ([14 x i8]* @$81 to i8*), i8* null)
  unreachable
$13:
  %39 = phi i8* [%36, %$7] ; # Crt
; # (let (Src: (coroutine (val $Current)) Org: (coroutine (Src: org))...
; # (val $Current)
  %40 = load i8*, i8** @$Current
; # (Src: org)
  %41 = getelementptr i8, i8* %40, i32 16
  %42 = bitcast i8* %41 to i8**
  %43 = load i8*, i8** %42
; # (cond ((not (nil? Tag)) (cond ((t? Tag) (val $Coroutines)) ((not ...
; # (nil? Tag)
  %44 = icmp eq i64 %35, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
; # (not (nil? Tag))
  %45 = icmp eq i1 %44, 0
  br i1 %45, label %$16, label %$15
$16:
  %46 = phi i8* [%39, %$13] ; # Crt
; # (cond ((t? Tag) (val $Coroutines)) ((not (symb? Tag)) (loop (let ...
; # (t? Tag)
  %47 = icmp eq i64 %35, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %47, label %$19, label %$18
$19:
  %48 = phi i8* [%46, %$16] ; # Crt
; # (val $Coroutines)
  %49 = load i8*, i8** @$Coroutines
  br label %$17
$18:
  %50 = phi i8* [%46, %$16] ; # Crt
; # (symb? Tag)
  %51 = xor i64 %35, 8
  %52 = and i64 %51, 14
  %53 = icmp eq i64 %52, 0
; # (not (symb? Tag))
  %54 = icmp eq i1 %53, 0
  br i1 %54, label %$21, label %$20
$21:
  %55 = phi i8* [%50, %$18] ; # Crt
; # (loop (let Crt: (coroutine Crt) (? (== Tag (Crt: tag)) Crt) (unle...
  br label %$22
$22:
  %56 = phi i8* [%55, %$21], [%68, %$27] ; # Crt
; # (let Crt: (coroutine Crt) (? (== Tag (Crt: tag)) Crt) (unless (se...
; # (? (== Tag (Crt: tag)) Crt)
; # (Crt: tag)
  %57 = ptrtoint i8* %56 to i64
  %58 = inttoptr i64 %57 to i64*
  %59 = load i64, i64* %58
; # (== Tag (Crt: tag))
  %60 = icmp eq i64 %35, %59
  br i1 %60, label %$25, label %$23
$25:
  %61 = phi i8* [%56, %$22] ; # Crt
  br label %$24
$23:
  %62 = phi i8* [%56, %$22] ; # Crt
; # (unless (setq Crt (Crt: nxt)) (coErr Exe Tag))
; # (Crt: nxt)
  %63 = getelementptr i8, i8* %56, i32 8
  %64 = bitcast i8* %63 to i8**
  %65 = load i8*, i8** %64
  %66 = icmp ne i8* %65, null
  br i1 %66, label %$27, label %$26
$26:
  %67 = phi i8* [%65, %$23] ; # Crt
; # (coErr Exe Tag)
  call void @coErr(i64 %0, i64 %35)
  unreachable
$27:
  %68 = phi i8* [%65, %$23] ; # Crt
  br label %$22
$24:
  %69 = phi i8* [%61, %$25] ; # Crt
  %70 = phi i8* [%61, %$25] ; # ->
  br label %$17
$20:
  %71 = phi i8* [%50, %$18] ; # Crt
; # (get Tag ZERO)
  %72 = call i64 @get(i64 %35, i64 2)
; # (cnt? (get Tag ZERO))
  %73 = and i64 %72, 2
  %74 = icmp ne i64 %73, 0
  br i1 %74, label %$29, label %$28
$29:
  %75 = phi i8* [%71, %$20] ; # Crt
; # (prog1 (i8* (& @ -3)) (unless (== Tag ((coroutine @) tag)) (coErr...
; # (& @ -3)
  %76 = and i64 %72, -3
; # (i8* (& @ -3))
  %77 = inttoptr i64 %76 to i8*
; # (unless (== Tag ((coroutine @) tag)) (coErr Exe Tag))
; # ((coroutine @) tag)
  %78 = ptrtoint i8* %77 to i64
  %79 = inttoptr i64 %78 to i64*
  %80 = load i64, i64* %79
; # (== Tag ((coroutine @) tag))
  %81 = icmp eq i64 %35, %80
  br i1 %81, label %$31, label %$30
$30:
  %82 = phi i8* [%75, %$29] ; # Crt
; # (coErr Exe Tag)
  call void @coErr(i64 %0, i64 %35)
  unreachable
$31:
  %83 = phi i8* [%75, %$29] ; # Crt
  br label %$17
$28:
  %84 = phi i8* [%71, %$20] ; # Crt
; # (coErr Exe Tag)
  call void @coErr(i64 %0, i64 %35)
  unreachable
$17:
  %85 = phi i8* [%48, %$19], [%69, %$24], [%83, %$31] ; # Crt
  %86 = phi i8* [%49, %$19], [%70, %$24], [%77, %$31] ; # ->
  br label %$14
$15:
  %87 = phi i8* [%39, %$13] ; # Crt
; # (Org:)
  %88 = icmp ne i8* %43, null
  br i1 %88, label %$33, label %$32
$33:
  %89 = phi i8* [%87, %$15] ; # Crt
; # (prog1 @ (unless (== (Org: tag) (Src: otg)) (coErr Exe (Src: otg)...
; # (unless (== (Org: tag) (Src: otg)) (coErr Exe (Src: otg)))
; # (Org: tag)
  %90 = ptrtoint i8* %43 to i64
  %91 = inttoptr i64 %90 to i64*
  %92 = load i64, i64* %91
; # (Src: otg)
  %93 = getelementptr i8, i8* %40, i32 24
  %94 = ptrtoint i8* %93 to i64
  %95 = inttoptr i64 %94 to i64*
  %96 = load i64, i64* %95
; # (== (Org: tag) (Src: otg))
  %97 = icmp eq i64 %92, %96
  br i1 %97, label %$35, label %$34
$34:
  %98 = phi i8* [%89, %$33] ; # Crt
; # (Src: otg)
  %99 = getelementptr i8, i8* %40, i32 24
  %100 = ptrtoint i8* %99 to i64
  %101 = inttoptr i64 %100 to i64*
  %102 = load i64, i64* %101
; # (coErr Exe (Src: otg))
  call void @coErr(i64 %0, i64 %102)
  unreachable
$35:
  %103 = phi i8* [%89, %$33] ; # Crt
  br label %$14
$32:
  %104 = phi i8* [%87, %$15] ; # Crt
; # (tagErr Exe)
  call void @tagErr(i64 %0)
  unreachable
$14:
  %105 = phi i8* [%85, %$17], [%103, %$35] ; # Crt
  %106 = phi i8* [%86, %$17], [%43, %$35] ; # ->
; # (any 0)
; # (any 0)
; # (i8* null)
  %107 = inttoptr i64 0 to i8*
; # (val $Stdin)
  %108 = load i8*, i8** @$Stdin
; # (val $Stdout)
  %109 = load i8*, i8** @$Stdout
; # (i8* null)
  %110 = inttoptr i64 0 to i8*
; # (i8* null)
  %111 = inttoptr i64 0 to i8*
; # (saveCoIO)
  call void @saveCoIO()
; # (unless (t? (Src: tag)) (let P (val $Link) (until (== P (Src: lnk...
; # (Src: tag)
  %112 = ptrtoint i8* %40 to i64
  %113 = inttoptr i64 %112 to i64*
  %114 = load i64, i64* %113
; # (t? (Src: tag))
  %115 = icmp eq i64 %114, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %115, label %$37, label %$36
$36:
  %116 = phi i8* [%105, %$14] ; # Crt
  %117 = phi i64 [0, %$14] ; # Lnk
  %118 = phi i64 [0, %$14] ; # Bnd
  %119 = phi i8* [%107, %$14] ; # Ca
  %120 = phi i8* [%108, %$14] ; # In
  %121 = phi i8* [%109, %$14] ; # Out
  %122 = phi i8* [%110, %$14] ; # Err
  %123 = phi i8* [%111, %$14] ; # Ctl
; # (let P (val $Link) (until (== P (Src: lnk)) (let Q P (setq P (val...
; # (val $Link)
  %124 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %125 = load i64, i64* %124
; # (until (== P (Src: lnk)) (let Q P (setq P (val 2 Q)) (set 2 Q Lnk...
  br label %$38
$38:
  %126 = phi i8* [%116, %$36], [%140, %$39] ; # Crt
  %127 = phi i64 [%117, %$36], [%148, %$39] ; # Lnk
  %128 = phi i64 [%118, %$36], [%142, %$39] ; # Bnd
  %129 = phi i8* [%119, %$36], [%143, %$39] ; # Ca
  %130 = phi i8* [%120, %$36], [%144, %$39] ; # In
  %131 = phi i8* [%121, %$36], [%145, %$39] ; # Out
  %132 = phi i8* [%122, %$36], [%146, %$39] ; # Err
  %133 = phi i8* [%123, %$36], [%147, %$39] ; # Ctl
  %134 = phi i64 [%125, %$36], [%151, %$39] ; # P
; # (Src: lnk)
  %135 = getelementptr i8, i8* %40, i32 56
  %136 = ptrtoint i8* %135 to i64
  %137 = inttoptr i64 %136 to i64*
  %138 = load i64, i64* %137
; # (== P (Src: lnk))
  %139 = icmp eq i64 %134, %138
  br i1 %139, label %$40, label %$39
$39:
  %140 = phi i8* [%126, %$38] ; # Crt
  %141 = phi i64 [%127, %$38] ; # Lnk
  %142 = phi i64 [%128, %$38] ; # Bnd
  %143 = phi i8* [%129, %$38] ; # Ca
  %144 = phi i8* [%130, %$38] ; # In
  %145 = phi i8* [%131, %$38] ; # Out
  %146 = phi i8* [%132, %$38] ; # Err
  %147 = phi i8* [%133, %$38] ; # Ctl
  %148 = phi i64 [%134, %$38] ; # P
; # (let Q P (setq P (val 2 Q)) (set 2 Q Lnk) (setq Lnk Q))
; # (val 2 Q)
  %149 = inttoptr i64 %148 to i64*
  %150 = getelementptr i64, i64* %149, i32 1
  %151 = load i64, i64* %150
; # (set 2 Q Lnk)
  %152 = inttoptr i64 %148 to i64*
  %153 = getelementptr i64, i64* %152, i32 1
  store i64 %141, i64* %153
  br label %$38
$40:
  %154 = phi i8* [%126, %$38] ; # Crt
  %155 = phi i64 [%127, %$38] ; # Lnk
  %156 = phi i64 [%128, %$38] ; # Bnd
  %157 = phi i8* [%129, %$38] ; # Ca
  %158 = phi i8* [%130, %$38] ; # In
  %159 = phi i8* [%131, %$38] ; # Out
  %160 = phi i8* [%132, %$38] ; # Err
  %161 = phi i8* [%133, %$38] ; # Ctl
  %162 = phi i64 [%134, %$38] ; # P
; # (set $Link Lnk)
  %163 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %155, i64* %163
; # (let P (val $Bind) (until (== P (Src: bnd)) (let Q P (xchg (val 2...
; # (val $Bind)
  %164 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  %165 = load i64, i64* %164
; # (until (== P (Src: bnd)) (let Q P (xchg (val 2 Q) Q) (setq P (val...
  br label %$41
$41:
  %166 = phi i8* [%154, %$40], [%180, %$42] ; # Crt
  %167 = phi i64 [%155, %$40], [%181, %$42] ; # Lnk
  %168 = phi i64 [%156, %$40], [%188, %$42] ; # Bnd
  %169 = phi i8* [%157, %$40], [%183, %$42] ; # Ca
  %170 = phi i8* [%158, %$40], [%184, %$42] ; # In
  %171 = phi i8* [%159, %$40], [%185, %$42] ; # Out
  %172 = phi i8* [%160, %$40], [%186, %$42] ; # Err
  %173 = phi i8* [%161, %$40], [%187, %$42] ; # Ctl
  %174 = phi i64 [%165, %$40], [%198, %$42] ; # P
; # (Src: bnd)
  %175 = getelementptr i8, i8* %40, i32 64
  %176 = ptrtoint i8* %175 to i64
  %177 = inttoptr i64 %176 to i64*
  %178 = load i64, i64* %177
; # (== P (Src: bnd))
  %179 = icmp eq i64 %174, %178
  br i1 %179, label %$43, label %$42
$42:
  %180 = phi i8* [%166, %$41] ; # Crt
  %181 = phi i64 [%167, %$41] ; # Lnk
  %182 = phi i64 [%168, %$41] ; # Bnd
  %183 = phi i8* [%169, %$41] ; # Ca
  %184 = phi i8* [%170, %$41] ; # In
  %185 = phi i8* [%171, %$41] ; # Out
  %186 = phi i8* [%172, %$41] ; # Err
  %187 = phi i8* [%173, %$41] ; # Ctl
  %188 = phi i64 [%174, %$41] ; # P
; # (let Q P (xchg (val 2 Q) Q) (setq P (val 3 Q)) (set 3 Q Bnd) (set...
; # (val 2 Q)
  %189 = inttoptr i64 %188 to i64*
  %190 = getelementptr i64, i64* %189, i32 1
  %191 = load i64, i64* %190
; # (xchg (val 2 Q) Q)
  %192 = inttoptr i64 %191 to i64*
  %193 = load i64, i64* %192
  %194 = inttoptr i64 %188 to i64*
  %195 = load i64, i64* %194
  store i64 %195, i64* %192
  store i64 %193, i64* %194
; # (val 3 Q)
  %196 = inttoptr i64 %188 to i64*
  %197 = getelementptr i64, i64* %196, i32 2
  %198 = load i64, i64* %197
; # (set 3 Q Bnd)
  %199 = inttoptr i64 %188 to i64*
  %200 = getelementptr i64, i64* %199, i32 2
  store i64 %182, i64* %200
  br label %$41
$43:
  %201 = phi i8* [%166, %$41] ; # Crt
  %202 = phi i64 [%167, %$41] ; # Lnk
  %203 = phi i64 [%168, %$41] ; # Bnd
  %204 = phi i8* [%169, %$41] ; # Ca
  %205 = phi i8* [%170, %$41] ; # In
  %206 = phi i8* [%171, %$41] ; # Out
  %207 = phi i8* [%172, %$41] ; # Err
  %208 = phi i8* [%173, %$41] ; # Ctl
  %209 = phi i64 [%174, %$41] ; # P
; # (set 3 P Bnd $Bind P)
  %210 = inttoptr i64 %209 to i64*
  %211 = getelementptr i64, i64* %210, i32 2
  store i64 %203, i64* %211
  %212 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %209, i64* %212
; # (let P (val $Catch) (until (== P (Src: ca)) (let Ca: (caFrame P) ...
; # (val $Catch)
  %213 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 32) to i8**)
; # (until (== P (Src: ca)) (let Ca: (caFrame P) (setq P (Ca: link)) ...
  br label %$44
$44:
  %214 = phi i8* [%201, %$43], [%227, %$45] ; # Crt
  %215 = phi i64 [%202, %$43], [%228, %$45] ; # Lnk
  %216 = phi i64 [%203, %$43], [%229, %$45] ; # Bnd
  %217 = phi i8* [%204, %$43], [%235, %$45] ; # Ca
  %218 = phi i8* [%205, %$43], [%231, %$45] ; # In
  %219 = phi i8* [%206, %$43], [%232, %$45] ; # Out
  %220 = phi i8* [%207, %$43], [%233, %$45] ; # Err
  %221 = phi i8* [%208, %$43], [%234, %$45] ; # Ctl
  %222 = phi i8* [%213, %$43], [%237, %$45] ; # P
; # (Src: ca)
  %223 = getelementptr i8, i8* %40, i32 72
  %224 = bitcast i8* %223 to i8**
  %225 = load i8*, i8** %224
; # (== P (Src: ca))
  %226 = icmp eq i8* %222, %225
  br i1 %226, label %$46, label %$45
$45:
  %227 = phi i8* [%214, %$44] ; # Crt
  %228 = phi i64 [%215, %$44] ; # Lnk
  %229 = phi i64 [%216, %$44] ; # Bnd
  %230 = phi i8* [%217, %$44] ; # Ca
  %231 = phi i8* [%218, %$44] ; # In
  %232 = phi i8* [%219, %$44] ; # Out
  %233 = phi i8* [%220, %$44] ; # Err
  %234 = phi i8* [%221, %$44] ; # Ctl
  %235 = phi i8* [%222, %$44] ; # P
; # (let Ca: (caFrame P) (setq P (Ca: link)) (Ca: link Ca) (setq Ca (...
; # (Ca: link)
  %236 = bitcast i8* %235 to i8**
  %237 = load i8*, i8** %236
; # (Ca: link Ca)
  %238 = bitcast i8* %235 to i8**
  store i8* %230, i8** %238
; # (Ca:)
  br label %$44
$46:
  %239 = phi i8* [%214, %$44] ; # Crt
  %240 = phi i64 [%215, %$44] ; # Lnk
  %241 = phi i64 [%216, %$44] ; # Bnd
  %242 = phi i8* [%217, %$44] ; # Ca
  %243 = phi i8* [%218, %$44] ; # In
  %244 = phi i8* [%219, %$44] ; # Out
  %245 = phi i8* [%220, %$44] ; # Err
  %246 = phi i8* [%221, %$44] ; # Ctl
  %247 = phi i8* [%222, %$44] ; # P
; # (set $Catch Ca)
  store i8* %242, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 32) to i8**)
; # (let P (val $InFrames) (until (== P (Src: in)) (let In: (ioFrame ...
; # (val $InFrames)
  %248 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 40) to i8**)
; # (until (== P (Src: in)) (let In: (ioFrame P) (setq P (In: link)) ...
  br label %$47
$47:
  %249 = phi i8* [%239, %$46], [%262, %$48] ; # Crt
  %250 = phi i64 [%240, %$46], [%263, %$48] ; # Lnk
  %251 = phi i64 [%241, %$46], [%264, %$48] ; # Bnd
  %252 = phi i8* [%242, %$46], [%265, %$48] ; # Ca
  %253 = phi i8* [%243, %$46], [%270, %$48] ; # In
  %254 = phi i8* [%244, %$46], [%267, %$48] ; # Out
  %255 = phi i8* [%245, %$46], [%268, %$48] ; # Err
  %256 = phi i8* [%246, %$46], [%269, %$48] ; # Ctl
  %257 = phi i8* [%248, %$46], [%272, %$48] ; # P
; # (Src: in)
  %258 = getelementptr i8, i8* %40, i32 80
  %259 = bitcast i8* %258 to i8**
  %260 = load i8*, i8** %259
; # (== P (Src: in))
  %261 = icmp eq i8* %257, %260
  br i1 %261, label %$49, label %$48
$48:
  %262 = phi i8* [%249, %$47] ; # Crt
  %263 = phi i64 [%250, %$47] ; # Lnk
  %264 = phi i64 [%251, %$47] ; # Bnd
  %265 = phi i8* [%252, %$47] ; # Ca
  %266 = phi i8* [%253, %$47] ; # In
  %267 = phi i8* [%254, %$47] ; # Out
  %268 = phi i8* [%255, %$47] ; # Err
  %269 = phi i8* [%256, %$47] ; # Ctl
  %270 = phi i8* [%257, %$47] ; # P
; # (let In: (ioFrame P) (setq P (In: link)) (In: link In) (setq In (...
; # (In: link)
  %271 = bitcast i8* %270 to i8**
  %272 = load i8*, i8** %271
; # (In: link In)
  %273 = bitcast i8* %270 to i8**
  store i8* %266, i8** %273
; # (In:)
  br label %$47
$49:
  %274 = phi i8* [%249, %$47] ; # Crt
  %275 = phi i64 [%250, %$47] ; # Lnk
  %276 = phi i64 [%251, %$47] ; # Bnd
  %277 = phi i8* [%252, %$47] ; # Ca
  %278 = phi i8* [%253, %$47] ; # In
  %279 = phi i8* [%254, %$47] ; # Out
  %280 = phi i8* [%255, %$47] ; # Err
  %281 = phi i8* [%256, %$47] ; # Ctl
  %282 = phi i8* [%257, %$47] ; # P
; # (set $InFrames In)
  store i8* %278, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 40) to i8**)
; # (let P (val $OutFrames) (until (== P (Src: out)) (let Out: (ioFra...
; # (val $OutFrames)
  %283 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 48) to i8**)
; # (until (== P (Src: out)) (let Out: (ioFrame P) (setq P (Out: link...
  br label %$50
$50:
  %284 = phi i8* [%274, %$49], [%297, %$51] ; # Crt
  %285 = phi i64 [%275, %$49], [%298, %$51] ; # Lnk
  %286 = phi i64 [%276, %$49], [%299, %$51] ; # Bnd
  %287 = phi i8* [%277, %$49], [%300, %$51] ; # Ca
  %288 = phi i8* [%278, %$49], [%301, %$51] ; # In
  %289 = phi i8* [%279, %$49], [%305, %$51] ; # Out
  %290 = phi i8* [%280, %$49], [%303, %$51] ; # Err
  %291 = phi i8* [%281, %$49], [%304, %$51] ; # Ctl
  %292 = phi i8* [%283, %$49], [%307, %$51] ; # P
; # (Src: out)
  %293 = getelementptr i8, i8* %40, i32 88
  %294 = bitcast i8* %293 to i8**
  %295 = load i8*, i8** %294
; # (== P (Src: out))
  %296 = icmp eq i8* %292, %295
  br i1 %296, label %$52, label %$51
$51:
  %297 = phi i8* [%284, %$50] ; # Crt
  %298 = phi i64 [%285, %$50] ; # Lnk
  %299 = phi i64 [%286, %$50] ; # Bnd
  %300 = phi i8* [%287, %$50] ; # Ca
  %301 = phi i8* [%288, %$50] ; # In
  %302 = phi i8* [%289, %$50] ; # Out
  %303 = phi i8* [%290, %$50] ; # Err
  %304 = phi i8* [%291, %$50] ; # Ctl
  %305 = phi i8* [%292, %$50] ; # P
; # (let Out: (ioFrame P) (setq P (Out: link)) (Out: link Out) (setq ...
; # (Out: link)
  %306 = bitcast i8* %305 to i8**
  %307 = load i8*, i8** %306
; # (Out: link Out)
  %308 = bitcast i8* %305 to i8**
  store i8* %302, i8** %308
; # (Out:)
  br label %$50
$52:
  %309 = phi i8* [%284, %$50] ; # Crt
  %310 = phi i64 [%285, %$50] ; # Lnk
  %311 = phi i64 [%286, %$50] ; # Bnd
  %312 = phi i8* [%287, %$50] ; # Ca
  %313 = phi i8* [%288, %$50] ; # In
  %314 = phi i8* [%289, %$50] ; # Out
  %315 = phi i8* [%290, %$50] ; # Err
  %316 = phi i8* [%291, %$50] ; # Ctl
  %317 = phi i8* [%292, %$50] ; # P
; # (set $OutFrames Out)
  store i8* %314, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 48) to i8**)
; # (let P (val $ErrFrames) (until (== P (Src: err)) (let Err: (ctFra...
; # (val $ErrFrames)
  %318 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 56) to i8**)
; # (until (== P (Src: err)) (let Err: (ctFrame P) (setq P (Err: link...
  br label %$53
$53:
  %319 = phi i8* [%309, %$52], [%332, %$54] ; # Crt
  %320 = phi i64 [%310, %$52], [%333, %$54] ; # Lnk
  %321 = phi i64 [%311, %$52], [%334, %$54] ; # Bnd
  %322 = phi i8* [%312, %$52], [%335, %$54] ; # Ca
  %323 = phi i8* [%313, %$52], [%336, %$54] ; # In
  %324 = phi i8* [%314, %$52], [%337, %$54] ; # Out
  %325 = phi i8* [%315, %$52], [%340, %$54] ; # Err
  %326 = phi i8* [%316, %$52], [%339, %$54] ; # Ctl
  %327 = phi i8* [%318, %$52], [%342, %$54] ; # P
; # (Src: err)
  %328 = getelementptr i8, i8* %40, i32 96
  %329 = bitcast i8* %328 to i8**
  %330 = load i8*, i8** %329
; # (== P (Src: err))
  %331 = icmp eq i8* %327, %330
  br i1 %331, label %$55, label %$54
$54:
  %332 = phi i8* [%319, %$53] ; # Crt
  %333 = phi i64 [%320, %$53] ; # Lnk
  %334 = phi i64 [%321, %$53] ; # Bnd
  %335 = phi i8* [%322, %$53] ; # Ca
  %336 = phi i8* [%323, %$53] ; # In
  %337 = phi i8* [%324, %$53] ; # Out
  %338 = phi i8* [%325, %$53] ; # Err
  %339 = phi i8* [%326, %$53] ; # Ctl
  %340 = phi i8* [%327, %$53] ; # P
; # (let Err: (ctFrame P) (setq P (Err: link)) (Err: link Err) (setq ...
; # (Err: link)
  %341 = bitcast i8* %340 to i8**
  %342 = load i8*, i8** %341
; # (Err: link Err)
  %343 = bitcast i8* %340 to i8**
  store i8* %338, i8** %343
; # (Err:)
  br label %$53
$55:
  %344 = phi i8* [%319, %$53] ; # Crt
  %345 = phi i64 [%320, %$53] ; # Lnk
  %346 = phi i64 [%321, %$53] ; # Bnd
  %347 = phi i8* [%322, %$53] ; # Ca
  %348 = phi i8* [%323, %$53] ; # In
  %349 = phi i8* [%324, %$53] ; # Out
  %350 = phi i8* [%325, %$53] ; # Err
  %351 = phi i8* [%326, %$53] ; # Ctl
  %352 = phi i8* [%327, %$53] ; # P
; # (set $ErrFrames Err)
  store i8* %350, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 56) to i8**)
; # (let P (val $CtlFrames) (until (== P (Src: ctl)) (let Ctl: (ctFra...
; # (val $CtlFrames)
  %353 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 64) to i8**)
; # (until (== P (Src: ctl)) (let Ctl: (ctFrame P) (setq P (Ctl: link...
  br label %$56
$56:
  %354 = phi i8* [%344, %$55], [%367, %$57] ; # Crt
  %355 = phi i64 [%345, %$55], [%368, %$57] ; # Lnk
  %356 = phi i64 [%346, %$55], [%369, %$57] ; # Bnd
  %357 = phi i8* [%347, %$55], [%370, %$57] ; # Ca
  %358 = phi i8* [%348, %$55], [%371, %$57] ; # In
  %359 = phi i8* [%349, %$55], [%372, %$57] ; # Out
  %360 = phi i8* [%350, %$55], [%373, %$57] ; # Err
  %361 = phi i8* [%351, %$55], [%375, %$57] ; # Ctl
  %362 = phi i8* [%353, %$55], [%377, %$57] ; # P
; # (Src: ctl)
  %363 = getelementptr i8, i8* %40, i32 104
  %364 = bitcast i8* %363 to i8**
  %365 = load i8*, i8** %364
; # (== P (Src: ctl))
  %366 = icmp eq i8* %362, %365
  br i1 %366, label %$58, label %$57
$57:
  %367 = phi i8* [%354, %$56] ; # Crt
  %368 = phi i64 [%355, %$56] ; # Lnk
  %369 = phi i64 [%356, %$56] ; # Bnd
  %370 = phi i8* [%357, %$56] ; # Ca
  %371 = phi i8* [%358, %$56] ; # In
  %372 = phi i8* [%359, %$56] ; # Out
  %373 = phi i8* [%360, %$56] ; # Err
  %374 = phi i8* [%361, %$56] ; # Ctl
  %375 = phi i8* [%362, %$56] ; # P
; # (let Ctl: (ctFrame P) (setq P (Ctl: link)) (Ctl: link Ctl) (setq ...
; # (Ctl: link)
  %376 = bitcast i8* %375 to i8**
  %377 = load i8*, i8** %376
; # (Ctl: link Ctl)
  %378 = bitcast i8* %375 to i8**
  store i8* %374, i8** %378
; # (Ctl:)
  br label %$56
$58:
  %379 = phi i8* [%354, %$56] ; # Crt
  %380 = phi i64 [%355, %$56] ; # Lnk
  %381 = phi i64 [%356, %$56] ; # Bnd
  %382 = phi i8* [%357, %$56] ; # Ca
  %383 = phi i8* [%358, %$56] ; # In
  %384 = phi i8* [%359, %$56] ; # Out
  %385 = phi i8* [%360, %$56] ; # Err
  %386 = phi i8* [%361, %$56] ; # Ctl
  %387 = phi i8* [%362, %$56] ; # P
; # (set $CtlFrames Ctl)
  store i8* %386, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 64) to i8**)
  br label %$37
$37:
  %388 = phi i8* [%105, %$14], [%379, %$58] ; # Crt
  %389 = phi i64 [0, %$14], [%380, %$58] ; # Lnk
  %390 = phi i64 [0, %$14], [%381, %$58] ; # Bnd
  %391 = phi i8* [%107, %$14], [%382, %$58] ; # Ca
  %392 = phi i8* [%108, %$14], [%383, %$58] ; # In
  %393 = phi i8* [%109, %$14], [%384, %$58] ; # Out
  %394 = phi i8* [%110, %$14], [%385, %$58] ; # Err
  %395 = phi i8* [%111, %$14], [%386, %$58] ; # Ctl
; # (Src:)
; # (saveCoEnv (Src:))
  call void @saveCoEnv(i8* %40)
; # (unless (setjmp (Src: (rst))) (set $Ret Val) (longjmp (Dst: (rst)...
; # (Src: (rst))
  %396 = getelementptr i8, i8* %40, i32 352
; # (setjmp (Src: (rst)))
  %397 = call i32 @setjmp(i8* %396)
  %398 = icmp ne i32 %397, 0
  br i1 %398, label %$60, label %$59
$59:
  %399 = phi i8* [%388, %$37] ; # Crt
  %400 = phi i64 [%389, %$37] ; # Lnk
  %401 = phi i64 [%390, %$37] ; # Bnd
  %402 = phi i8* [%391, %$37] ; # Ca
  %403 = phi i8* [%392, %$37] ; # In
  %404 = phi i8* [%393, %$37] ; # Out
  %405 = phi i8* [%394, %$37] ; # Err
  %406 = phi i8* [%395, %$37] ; # Ctl
; # (set $Ret Val)
  store i64 %15, i64* @$Ret
; # (Dst: (rst))
  %407 = getelementptr i8, i8* %106, i32 352
; # (longjmp (Dst: (rst)) 1)
  call void @longjmp(i8* %407, i32 1)
  unreachable
$60:
  %408 = phi i8* [%388, %$37] ; # Crt
  %409 = phi i64 [%389, %$37] ; # Lnk
  %410 = phi i64 [%390, %$37] ; # Bnd
  %411 = phi i8* [%391, %$37] ; # Ca
  %412 = phi i8* [%392, %$37] ; # In
  %413 = phi i8* [%393, %$37] ; # Out
  %414 = phi i8* [%394, %$37] ; # Err
  %415 = phi i8* [%395, %$37] ; # Ctl
; # (unless (t? (Src: tag)) (unless (and ((setq Org: (coroutine (Src:...
; # (Src: tag)
  %416 = ptrtoint i8* %40 to i64
  %417 = inttoptr i64 %416 to i64*
  %418 = load i64, i64* %417
; # (t? (Src: tag))
  %419 = icmp eq i64 %418, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %419, label %$62, label %$61
$61:
  %420 = phi i8* [%408, %$60] ; # Crt
  %421 = phi i64 [%409, %$60] ; # Lnk
  %422 = phi i64 [%410, %$60] ; # Bnd
  %423 = phi i8* [%411, %$60] ; # Ca
  %424 = phi i8* [%412, %$60] ; # In
  %425 = phi i8* [%413, %$60] ; # Out
  %426 = phi i8* [%414, %$60] ; # Err
  %427 = phi i8* [%415, %$60] ; # Ctl
; # (unless (and ((setq Org: (coroutine (Src: org)))) (== (Org: tag) ...
; # (and ((setq Org: (coroutine (Src: org)))) (== (Org: tag) (Src: ot...
; # (Src: org)
  %428 = getelementptr i8, i8* %40, i32 16
  %429 = bitcast i8* %428 to i8**
  %430 = load i8*, i8** %429
; # ((setq Org: (coroutine (Src: org))))
  %431 = icmp ne i8* %430, null
  br i1 %431, label %$64, label %$63
$64:
  %432 = phi i8* [%420, %$61] ; # Crt
  %433 = phi i64 [%421, %$61] ; # Lnk
  %434 = phi i64 [%422, %$61] ; # Bnd
  %435 = phi i8* [%423, %$61] ; # Ca
  %436 = phi i8* [%424, %$61] ; # In
  %437 = phi i8* [%425, %$61] ; # Out
  %438 = phi i8* [%426, %$61] ; # Err
  %439 = phi i8* [%427, %$61] ; # Ctl
; # (Org: tag)
  %440 = ptrtoint i8* %430 to i64
  %441 = inttoptr i64 %440 to i64*
  %442 = load i64, i64* %441
; # (Src: otg)
  %443 = getelementptr i8, i8* %40, i32 24
  %444 = ptrtoint i8* %443 to i64
  %445 = inttoptr i64 %444 to i64*
  %446 = load i64, i64* %445
; # (== (Org: tag) (Src: otg))
  %447 = icmp eq i64 %442, %446
  br label %$63
$63:
  %448 = phi i8* [%420, %$61], [%432, %$64] ; # Crt
  %449 = phi i64 [%421, %$61], [%433, %$64] ; # Lnk
  %450 = phi i64 [%422, %$61], [%434, %$64] ; # Bnd
  %451 = phi i8* [%423, %$61], [%435, %$64] ; # Ca
  %452 = phi i8* [%424, %$61], [%436, %$64] ; # In
  %453 = phi i8* [%425, %$61], [%437, %$64] ; # Out
  %454 = phi i8* [%426, %$61], [%438, %$64] ; # Err
  %455 = phi i8* [%427, %$61], [%439, %$64] ; # Ctl
  %456 = phi i1 [0, %$61], [%447, %$64] ; # ->
  br i1 %456, label %$66, label %$65
$65:
  %457 = phi i8* [%448, %$63] ; # Crt
  %458 = phi i64 [%449, %$63] ; # Lnk
  %459 = phi i64 [%450, %$63] ; # Bnd
  %460 = phi i8* [%451, %$63] ; # Ca
  %461 = phi i8* [%452, %$63] ; # In
  %462 = phi i8* [%453, %$63] ; # Out
  %463 = phi i8* [%454, %$63] ; # Err
  %464 = phi i8* [%455, %$63] ; # Ctl
; # (Src:)
; # (loadCoEnv (Src:))
  %465 = call i64 @loadCoEnv(i8* %40)
; # (Src: otg)
  %466 = getelementptr i8, i8* %40, i32 24
  %467 = ptrtoint i8* %466 to i64
  %468 = inttoptr i64 %467 to i64*
  %469 = load i64, i64* %468
; # (coErr Exe (Src: otg))
  call void @coErr(i64 %0, i64 %469)
  unreachable
$66:
  %470 = phi i8* [%448, %$63] ; # Crt
  %471 = phi i64 [%449, %$63] ; # Lnk
  %472 = phi i64 [%450, %$63] ; # Bnd
  %473 = phi i8* [%451, %$63] ; # Ca
  %474 = phi i8* [%452, %$63] ; # In
  %475 = phi i8* [%453, %$63] ; # Out
  %476 = phi i8* [%454, %$63] ; # Err
  %477 = phi i8* [%455, %$63] ; # Ctl
; # (let P (Org: (env $CtlFrames i8*)) (Src: ctl P) (while Ctl (let C...
; # (Org: (env $CtlFrames i8*))
  %478 = getelementptr i8, i8* %430, i32 152
  %479 = getelementptr i8, i8* %478, i32 64
  %480 = bitcast i8* %479 to i8**
  %481 = load i8*, i8** %480
; # (Src: ctl P)
  %482 = getelementptr i8, i8* %40, i32 104
  %483 = bitcast i8* %482 to i8**
  store i8* %481, i8** %483
; # (while Ctl (let Ctl: (ctFrame Ctl) (setq Ctl (Ctl: link)) (Ctl: l...
  br label %$67
$67:
  %484 = phi i8* [%470, %$66], [%494, %$68] ; # Crt
  %485 = phi i64 [%471, %$66], [%495, %$68] ; # Lnk
  %486 = phi i64 [%472, %$66], [%496, %$68] ; # Bnd
  %487 = phi i8* [%473, %$66], [%497, %$68] ; # Ca
  %488 = phi i8* [%474, %$66], [%498, %$68] ; # In
  %489 = phi i8* [%475, %$66], [%499, %$68] ; # Out
  %490 = phi i8* [%476, %$66], [%500, %$68] ; # Err
  %491 = phi i8* [%477, %$66], [%504, %$68] ; # Ctl
  %492 = phi i8* [%481, %$66], [%501, %$68] ; # P
  %493 = icmp ne i8* %491, null
  br i1 %493, label %$68, label %$69
$68:
  %494 = phi i8* [%484, %$67] ; # Crt
  %495 = phi i64 [%485, %$67] ; # Lnk
  %496 = phi i64 [%486, %$67] ; # Bnd
  %497 = phi i8* [%487, %$67] ; # Ca
  %498 = phi i8* [%488, %$67] ; # In
  %499 = phi i8* [%489, %$67] ; # Out
  %500 = phi i8* [%490, %$67] ; # Err
  %501 = phi i8* [%491, %$67] ; # Ctl
  %502 = phi i8* [%492, %$67] ; # P
; # (let Ctl: (ctFrame Ctl) (setq Ctl (Ctl: link)) (Ctl: link P) (set...
; # (Ctl: link)
  %503 = bitcast i8* %501 to i8**
  %504 = load i8*, i8** %503
; # (Ctl: link P)
  %505 = bitcast i8* %501 to i8**
  store i8* %502, i8** %505
; # (Ctl:)
  br label %$67
$69:
  %506 = phi i8* [%484, %$67] ; # Crt
  %507 = phi i64 [%485, %$67] ; # Lnk
  %508 = phi i64 [%486, %$67] ; # Bnd
  %509 = phi i8* [%487, %$67] ; # Ca
  %510 = phi i8* [%488, %$67] ; # In
  %511 = phi i8* [%489, %$67] ; # Out
  %512 = phi i8* [%490, %$67] ; # Err
  %513 = phi i8* [%491, %$67] ; # Ctl
  %514 = phi i8* [%492, %$67] ; # P
; # (Src: (env $CtlFrames i8*) P)
  %515 = getelementptr i8, i8* %40, i32 152
  %516 = getelementptr i8, i8* %515, i32 64
  %517 = bitcast i8* %516 to i8**
  store i8* %514, i8** %517
; # (let P (Org: (env $ErrFrames i8*)) (Src: err P) (while Err (let E...
; # (Org: (env $ErrFrames i8*))
  %518 = getelementptr i8, i8* %430, i32 152
  %519 = getelementptr i8, i8* %518, i32 56
  %520 = bitcast i8* %519 to i8**
  %521 = load i8*, i8** %520
; # (Src: err P)
  %522 = getelementptr i8, i8* %40, i32 96
  %523 = bitcast i8* %522 to i8**
  store i8* %521, i8** %523
; # (while Err (let Err: (ctFrame Err) (setq Err (Err: link)) (Err: l...
  br label %$70
$70:
  %524 = phi i8* [%506, %$69], [%534, %$71] ; # Crt
  %525 = phi i64 [%507, %$69], [%535, %$71] ; # Lnk
  %526 = phi i64 [%508, %$69], [%536, %$71] ; # Bnd
  %527 = phi i8* [%509, %$69], [%537, %$71] ; # Ca
  %528 = phi i8* [%510, %$69], [%538, %$71] ; # In
  %529 = phi i8* [%511, %$69], [%539, %$71] ; # Out
  %530 = phi i8* [%512, %$69], [%544, %$71] ; # Err
  %531 = phi i8* [%513, %$69], [%541, %$71] ; # Ctl
  %532 = phi i8* [%521, %$69], [%540, %$71] ; # P
  %533 = icmp ne i8* %530, null
  br i1 %533, label %$71, label %$72
$71:
  %534 = phi i8* [%524, %$70] ; # Crt
  %535 = phi i64 [%525, %$70] ; # Lnk
  %536 = phi i64 [%526, %$70] ; # Bnd
  %537 = phi i8* [%527, %$70] ; # Ca
  %538 = phi i8* [%528, %$70] ; # In
  %539 = phi i8* [%529, %$70] ; # Out
  %540 = phi i8* [%530, %$70] ; # Err
  %541 = phi i8* [%531, %$70] ; # Ctl
  %542 = phi i8* [%532, %$70] ; # P
; # (let Err: (ctFrame Err) (setq Err (Err: link)) (Err: link P) (set...
; # (Err: link)
  %543 = bitcast i8* %540 to i8**
  %544 = load i8*, i8** %543
; # (Err: link P)
  %545 = bitcast i8* %540 to i8**
  store i8* %542, i8** %545
; # (Err:)
  br label %$70
$72:
  %546 = phi i8* [%524, %$70] ; # Crt
  %547 = phi i64 [%525, %$70] ; # Lnk
  %548 = phi i64 [%526, %$70] ; # Bnd
  %549 = phi i8* [%527, %$70] ; # Ca
  %550 = phi i8* [%528, %$70] ; # In
  %551 = phi i8* [%529, %$70] ; # Out
  %552 = phi i8* [%530, %$70] ; # Err
  %553 = phi i8* [%531, %$70] ; # Ctl
  %554 = phi i8* [%532, %$70] ; # P
; # (Src: (env $ErrFrames i8*) P)
  %555 = getelementptr i8, i8* %40, i32 152
  %556 = getelementptr i8, i8* %555, i32 56
  %557 = bitcast i8* %556 to i8**
  store i8* %554, i8** %557
; # (let P (Org: (env $OutFrames i8*)) (Src: out P) (until (== Out (v...
; # (Org: (env $OutFrames i8*))
  %558 = getelementptr i8, i8* %430, i32 152
  %559 = getelementptr i8, i8* %558, i32 48
  %560 = bitcast i8* %559 to i8**
  %561 = load i8*, i8** %560
; # (Src: out P)
  %562 = getelementptr i8, i8* %40, i32 88
  %563 = bitcast i8* %562 to i8**
  store i8* %561, i8** %563
; # (until (== Out (val $Stdout)) (let Out: (ioFrame Out) (setq Out (...
  br label %$73
$73:
  %564 = phi i8* [%546, %$72], [%575, %$74] ; # Crt
  %565 = phi i64 [%547, %$72], [%576, %$74] ; # Lnk
  %566 = phi i64 [%548, %$72], [%577, %$74] ; # Bnd
  %567 = phi i8* [%549, %$72], [%578, %$74] ; # Ca
  %568 = phi i8* [%550, %$72], [%579, %$74] ; # In
  %569 = phi i8* [%551, %$72], [%585, %$74] ; # Out
  %570 = phi i8* [%552, %$72], [%581, %$74] ; # Err
  %571 = phi i8* [%553, %$72], [%582, %$74] ; # Ctl
  %572 = phi i8* [%561, %$72], [%580, %$74] ; # P
; # (val $Stdout)
  %573 = load i8*, i8** @$Stdout
; # (== Out (val $Stdout))
  %574 = icmp eq i8* %569, %573
  br i1 %574, label %$75, label %$74
$74:
  %575 = phi i8* [%564, %$73] ; # Crt
  %576 = phi i64 [%565, %$73] ; # Lnk
  %577 = phi i64 [%566, %$73] ; # Bnd
  %578 = phi i8* [%567, %$73] ; # Ca
  %579 = phi i8* [%568, %$73] ; # In
  %580 = phi i8* [%569, %$73] ; # Out
  %581 = phi i8* [%570, %$73] ; # Err
  %582 = phi i8* [%571, %$73] ; # Ctl
  %583 = phi i8* [%572, %$73] ; # P
; # (let Out: (ioFrame Out) (setq Out (Out: link)) (Out: link P) (set...
; # (Out: link)
  %584 = bitcast i8* %580 to i8**
  %585 = load i8*, i8** %584
; # (Out: link P)
  %586 = bitcast i8* %580 to i8**
  store i8* %583, i8** %586
; # (Out:)
  br label %$73
$75:
  %587 = phi i8* [%564, %$73] ; # Crt
  %588 = phi i64 [%565, %$73] ; # Lnk
  %589 = phi i64 [%566, %$73] ; # Bnd
  %590 = phi i8* [%567, %$73] ; # Ca
  %591 = phi i8* [%568, %$73] ; # In
  %592 = phi i8* [%569, %$73] ; # Out
  %593 = phi i8* [%570, %$73] ; # Err
  %594 = phi i8* [%571, %$73] ; # Ctl
  %595 = phi i8* [%572, %$73] ; # P
; # (Src: (env $OutFrames i8*) P)
  %596 = getelementptr i8, i8* %40, i32 152
  %597 = getelementptr i8, i8* %596, i32 48
  %598 = bitcast i8* %597 to i8**
  store i8* %595, i8** %598
; # (let P (Org: (env $InFrames i8*)) (Src: in P) (until (== In (val ...
; # (Org: (env $InFrames i8*))
  %599 = getelementptr i8, i8* %430, i32 152
  %600 = getelementptr i8, i8* %599, i32 40
  %601 = bitcast i8* %600 to i8**
  %602 = load i8*, i8** %601
; # (Src: in P)
  %603 = getelementptr i8, i8* %40, i32 80
  %604 = bitcast i8* %603 to i8**
  store i8* %602, i8** %604
; # (until (== In (val $Stdin)) (let In: (ioFrame In) (setq In (In: l...
  br label %$76
$76:
  %605 = phi i8* [%587, %$75], [%616, %$77] ; # Crt
  %606 = phi i64 [%588, %$75], [%617, %$77] ; # Lnk
  %607 = phi i64 [%589, %$75], [%618, %$77] ; # Bnd
  %608 = phi i8* [%590, %$75], [%619, %$77] ; # Ca
  %609 = phi i8* [%591, %$75], [%626, %$77] ; # In
  %610 = phi i8* [%592, %$75], [%621, %$77] ; # Out
  %611 = phi i8* [%593, %$75], [%622, %$77] ; # Err
  %612 = phi i8* [%594, %$75], [%623, %$77] ; # Ctl
  %613 = phi i8* [%602, %$75], [%620, %$77] ; # P
; # (val $Stdin)
  %614 = load i8*, i8** @$Stdin
; # (== In (val $Stdin))
  %615 = icmp eq i8* %609, %614
  br i1 %615, label %$78, label %$77
$77:
  %616 = phi i8* [%605, %$76] ; # Crt
  %617 = phi i64 [%606, %$76] ; # Lnk
  %618 = phi i64 [%607, %$76] ; # Bnd
  %619 = phi i8* [%608, %$76] ; # Ca
  %620 = phi i8* [%609, %$76] ; # In
  %621 = phi i8* [%610, %$76] ; # Out
  %622 = phi i8* [%611, %$76] ; # Err
  %623 = phi i8* [%612, %$76] ; # Ctl
  %624 = phi i8* [%613, %$76] ; # P
; # (let In: (ioFrame In) (setq In (In: link)) (In: link P) (setq P (...
; # (In: link)
  %625 = bitcast i8* %620 to i8**
  %626 = load i8*, i8** %625
; # (In: link P)
  %627 = bitcast i8* %620 to i8**
  store i8* %624, i8** %627
; # (In:)
  br label %$76
$78:
  %628 = phi i8* [%605, %$76] ; # Crt
  %629 = phi i64 [%606, %$76] ; # Lnk
  %630 = phi i64 [%607, %$76] ; # Bnd
  %631 = phi i8* [%608, %$76] ; # Ca
  %632 = phi i8* [%609, %$76] ; # In
  %633 = phi i8* [%610, %$76] ; # Out
  %634 = phi i8* [%611, %$76] ; # Err
  %635 = phi i8* [%612, %$76] ; # Ctl
  %636 = phi i8* [%613, %$76] ; # P
; # (Src: (env $InFrames i8*) P)
  %637 = getelementptr i8, i8* %40, i32 152
  %638 = getelementptr i8, i8* %637, i32 40
  %639 = bitcast i8* %638 to i8**
  store i8* %636, i8** %639
; # (let P (Org: (env $Catch i8*)) (Src: ca P) (while Ca (let Ca: (ca...
; # (Org: (env $Catch i8*))
  %640 = getelementptr i8, i8* %430, i32 152
  %641 = getelementptr i8, i8* %640, i32 32
  %642 = bitcast i8* %641 to i8**
  %643 = load i8*, i8** %642
; # (Src: ca P)
  %644 = getelementptr i8, i8* %40, i32 72
  %645 = bitcast i8* %644 to i8**
  store i8* %643, i8** %645
; # (while Ca (let Ca: (caFrame Ca) (setq Ca (Ca: link)) (Ca: link P)...
  br label %$79
$79:
  %646 = phi i8* [%628, %$78], [%656, %$80] ; # Crt
  %647 = phi i64 [%629, %$78], [%657, %$80] ; # Lnk
  %648 = phi i64 [%630, %$78], [%658, %$80] ; # Bnd
  %649 = phi i8* [%631, %$78], [%666, %$80] ; # Ca
  %650 = phi i8* [%632, %$78], [%660, %$80] ; # In
  %651 = phi i8* [%633, %$78], [%661, %$80] ; # Out
  %652 = phi i8* [%634, %$78], [%662, %$80] ; # Err
  %653 = phi i8* [%635, %$78], [%663, %$80] ; # Ctl
  %654 = phi i8* [%643, %$78], [%659, %$80] ; # P
  %655 = icmp ne i8* %649, null
  br i1 %655, label %$80, label %$81
$80:
  %656 = phi i8* [%646, %$79] ; # Crt
  %657 = phi i64 [%647, %$79] ; # Lnk
  %658 = phi i64 [%648, %$79] ; # Bnd
  %659 = phi i8* [%649, %$79] ; # Ca
  %660 = phi i8* [%650, %$79] ; # In
  %661 = phi i8* [%651, %$79] ; # Out
  %662 = phi i8* [%652, %$79] ; # Err
  %663 = phi i8* [%653, %$79] ; # Ctl
  %664 = phi i8* [%654, %$79] ; # P
; # (let Ca: (caFrame Ca) (setq Ca (Ca: link)) (Ca: link P) (setq P (...
; # (Ca: link)
  %665 = bitcast i8* %659 to i8**
  %666 = load i8*, i8** %665
; # (Ca: link P)
  %667 = bitcast i8* %659 to i8**
  store i8* %664, i8** %667
; # (Ca:)
  br label %$79
$81:
  %668 = phi i8* [%646, %$79] ; # Crt
  %669 = phi i64 [%647, %$79] ; # Lnk
  %670 = phi i64 [%648, %$79] ; # Bnd
  %671 = phi i8* [%649, %$79] ; # Ca
  %672 = phi i8* [%650, %$79] ; # In
  %673 = phi i8* [%651, %$79] ; # Out
  %674 = phi i8* [%652, %$79] ; # Err
  %675 = phi i8* [%653, %$79] ; # Ctl
  %676 = phi i8* [%654, %$79] ; # P
; # (Src: (env $Catch i8*) P)
  %677 = getelementptr i8, i8* %40, i32 152
  %678 = getelementptr i8, i8* %677, i32 32
  %679 = bitcast i8* %678 to i8**
  store i8* %676, i8** %679
; # (let P (Src: bnd) (set 3 P (Org: (env $Bind any))) (while Bnd (le...
; # (Src: bnd)
  %680 = getelementptr i8, i8* %40, i32 64
  %681 = ptrtoint i8* %680 to i64
  %682 = inttoptr i64 %681 to i64*
  %683 = load i64, i64* %682
; # (set 3 P (Org: (env $Bind any)))
; # (Org: (env $Bind any))
  %684 = getelementptr i8, i8* %430, i32 152
  %685 = getelementptr i8, i8* %684, i32 8
  %686 = ptrtoint i8* %685 to i64
  %687 = inttoptr i64 %686 to i64*
  %688 = load i64, i64* %687
  %689 = inttoptr i64 %683 to i64*
  %690 = getelementptr i64, i64* %689, i32 2
  store i64 %688, i64* %690
; # (while Bnd (let Q Bnd (xchg (val 2 Q) Q) (setq Bnd (val 3 Q)) (se...
  br label %$82
$82:
  %691 = phi i8* [%668, %$81], [%701, %$83] ; # Crt
  %692 = phi i64 [%669, %$81], [%702, %$83] ; # Lnk
  %693 = phi i64 [%670, %$81], [%719, %$83] ; # Bnd
  %694 = phi i8* [%671, %$81], [%704, %$83] ; # Ca
  %695 = phi i8* [%672, %$81], [%705, %$83] ; # In
  %696 = phi i8* [%673, %$81], [%706, %$83] ; # Out
  %697 = phi i8* [%674, %$81], [%707, %$83] ; # Err
  %698 = phi i8* [%675, %$81], [%708, %$83] ; # Ctl
  %699 = phi i64 [%683, %$81], [%703, %$83] ; # P
  %700 = icmp ne i64 %693, 0
  br i1 %700, label %$83, label %$84
$83:
  %701 = phi i8* [%691, %$82] ; # Crt
  %702 = phi i64 [%692, %$82] ; # Lnk
  %703 = phi i64 [%693, %$82] ; # Bnd
  %704 = phi i8* [%694, %$82] ; # Ca
  %705 = phi i8* [%695, %$82] ; # In
  %706 = phi i8* [%696, %$82] ; # Out
  %707 = phi i8* [%697, %$82] ; # Err
  %708 = phi i8* [%698, %$82] ; # Ctl
  %709 = phi i64 [%699, %$82] ; # P
; # (let Q Bnd (xchg (val 2 Q) Q) (setq Bnd (val 3 Q)) (set 3 Q P) (s...
; # (val 2 Q)
  %710 = inttoptr i64 %703 to i64*
  %711 = getelementptr i64, i64* %710, i32 1
  %712 = load i64, i64* %711
; # (xchg (val 2 Q) Q)
  %713 = inttoptr i64 %712 to i64*
  %714 = load i64, i64* %713
  %715 = inttoptr i64 %703 to i64*
  %716 = load i64, i64* %715
  store i64 %716, i64* %713
  store i64 %714, i64* %715
; # (val 3 Q)
  %717 = inttoptr i64 %703 to i64*
  %718 = getelementptr i64, i64* %717, i32 2
  %719 = load i64, i64* %718
; # (set 3 Q P)
  %720 = inttoptr i64 %703 to i64*
  %721 = getelementptr i64, i64* %720, i32 2
  store i64 %709, i64* %721
  br label %$82
$84:
  %722 = phi i8* [%691, %$82] ; # Crt
  %723 = phi i64 [%692, %$82] ; # Lnk
  %724 = phi i64 [%693, %$82] ; # Bnd
  %725 = phi i8* [%694, %$82] ; # Ca
  %726 = phi i8* [%695, %$82] ; # In
  %727 = phi i8* [%696, %$82] ; # Out
  %728 = phi i8* [%697, %$82] ; # Err
  %729 = phi i8* [%698, %$82] ; # Ctl
  %730 = phi i64 [%699, %$82] ; # P
; # (Src: (env $Bind any) P)
  %731 = getelementptr i8, i8* %40, i32 152
  %732 = getelementptr i8, i8* %731, i32 8
  %733 = ptrtoint i8* %732 to i64
  %734 = inttoptr i64 %733 to i64*
  store i64 %730, i64* %734
; # (let P (Org: (env $Link any)) (Src: lnk P) (while Lnk (let Q Lnk ...
; # (Org: (env $Link any))
  %735 = getelementptr i8, i8* %430, i32 152
  %736 = ptrtoint i8* %735 to i64
  %737 = inttoptr i64 %736 to i64*
  %738 = load i64, i64* %737
; # (Src: lnk P)
  %739 = getelementptr i8, i8* %40, i32 56
  %740 = ptrtoint i8* %739 to i64
  %741 = inttoptr i64 %740 to i64*
  store i64 %738, i64* %741
; # (while Lnk (let Q Lnk (setq Lnk (val 2 Q)) (set 2 Q P) (setq P Q)...
  br label %$85
$85:
  %742 = phi i8* [%722, %$84], [%752, %$86] ; # Crt
  %743 = phi i64 [%723, %$84], [%763, %$86] ; # Lnk
  %744 = phi i64 [%724, %$84], [%754, %$86] ; # Bnd
  %745 = phi i8* [%725, %$84], [%755, %$86] ; # Ca
  %746 = phi i8* [%726, %$84], [%756, %$86] ; # In
  %747 = phi i8* [%727, %$84], [%757, %$86] ; # Out
  %748 = phi i8* [%728, %$84], [%758, %$86] ; # Err
  %749 = phi i8* [%729, %$84], [%759, %$86] ; # Ctl
  %750 = phi i64 [%738, %$84], [%753, %$86] ; # P
  %751 = icmp ne i64 %743, 0
  br i1 %751, label %$86, label %$87
$86:
  %752 = phi i8* [%742, %$85] ; # Crt
  %753 = phi i64 [%743, %$85] ; # Lnk
  %754 = phi i64 [%744, %$85] ; # Bnd
  %755 = phi i8* [%745, %$85] ; # Ca
  %756 = phi i8* [%746, %$85] ; # In
  %757 = phi i8* [%747, %$85] ; # Out
  %758 = phi i8* [%748, %$85] ; # Err
  %759 = phi i8* [%749, %$85] ; # Ctl
  %760 = phi i64 [%750, %$85] ; # P
; # (let Q Lnk (setq Lnk (val 2 Q)) (set 2 Q P) (setq P Q))
; # (val 2 Q)
  %761 = inttoptr i64 %753 to i64*
  %762 = getelementptr i64, i64* %761, i32 1
  %763 = load i64, i64* %762
; # (set 2 Q P)
  %764 = inttoptr i64 %753 to i64*
  %765 = getelementptr i64, i64* %764, i32 1
  store i64 %760, i64* %765
  br label %$85
$87:
  %766 = phi i8* [%742, %$85] ; # Crt
  %767 = phi i64 [%743, %$85] ; # Lnk
  %768 = phi i64 [%744, %$85] ; # Bnd
  %769 = phi i8* [%745, %$85] ; # Ca
  %770 = phi i8* [%746, %$85] ; # In
  %771 = phi i8* [%747, %$85] ; # Out
  %772 = phi i8* [%748, %$85] ; # Err
  %773 = phi i8* [%749, %$85] ; # Ctl
  %774 = phi i64 [%750, %$85] ; # P
; # (Src: (env $Link any) P)
  %775 = getelementptr i8, i8* %40, i32 152
  %776 = ptrtoint i8* %775 to i64
  %777 = inttoptr i64 %776 to i64*
  store i64 %774, i64* %777
  br label %$62
$62:
  %778 = phi i8* [%408, %$60], [%766, %$87] ; # Crt
  %779 = phi i64 [%409, %$60], [%767, %$87] ; # Lnk
  %780 = phi i64 [%410, %$60], [%768, %$87] ; # Bnd
  %781 = phi i8* [%411, %$60], [%769, %$87] ; # Ca
  %782 = phi i8* [%412, %$60], [%770, %$87] ; # In
  %783 = phi i8* [%413, %$60], [%771, %$87] ; # Out
  %784 = phi i8* [%414, %$60], [%772, %$87] ; # Err
  %785 = phi i8* [%415, %$60], [%773, %$87] ; # Ctl
; # (Src:)
; # (loadCoEnv (Src:))
  %786 = call i64 @loadCoEnv(i8* %40)
; # (drop *Safe)
  %787 = inttoptr i64 %19 to i64*
  %788 = getelementptr i64, i64* %787, i32 1
  %789 = load i64, i64* %788
  %790 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %789, i64* %790
  ret i64 %786
}

define i64 @brkLoad(i64) align 8 {
$1:
; # (when (and ((inFile (val (val $InFiles))) tty) ((outFile (val 2 (...
; # (and ((inFile (val (val $InFiles))) tty) ((outFile (val 2 (val $O...
; # (val $InFiles)
  %1 = load i8**, i8*** @$InFiles
; # (val (val $InFiles))
  %2 = load i8*, i8** %1
; # ((inFile (val (val $InFiles))) tty)
  %3 = getelementptr i8, i8* %2, i32 4128
  %4 = bitcast i8* %3 to i1*
  %5 = load i1, i1* %4
  br i1 %5, label %$3, label %$2
$3:
  %6 = phi i64 [%0, %$1] ; # Exe
; # (val $OutFiles)
  %7 = load i8**, i8*** @$OutFiles
; # (val 2 (val $OutFiles))
  %8 = getelementptr i8*, i8** %7, i32 1
  %9 = load i8*, i8** %8
; # ((outFile (val 2 (val $OutFiles))) tty)
  %10 = getelementptr i8, i8* %9, i32 4104
  %11 = bitcast i8* %10 to i1*
  %12 = load i1, i1* %11
  br i1 %12, label %$4, label %$2
$4:
  %13 = phi i64 [%6, %$3] ; # Exe
; # (val $Break)
  %14 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 16) to i64) to i64*
  %15 = load i64, i64* %14
; # (=0 (val $Break))
  %16 = icmp eq i64 %15, 0
  br label %$2
$2:
  %17 = phi i64 [%0, %$1], [%6, %$3], [%13, %$4] ; # Exe
  %18 = phi i1 [0, %$1], [0, %$3], [%16, %$4] ; # ->
  br i1 %18, label %$5, label %$6
$5:
  %19 = phi i64 [%17, %$2] ; # Exe
; # (let P (val $Bind) (setq P (push (val $At) $At P 0)) (setq P (pus...
; # (val $Bind)
  %20 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  %21 = load i64, i64* %20
; # (val $At)
  %22 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  %23 = load i64, i64* %22
; # (push (val $At) $At P 0)
  %24 = alloca i64, i64 4, align 16
  %25 = ptrtoint i64* %24 to i64
  %26 = inttoptr i64 %25 to i64*
  store i64 %23, i64* %26
  %27 = add i64 %25, 8
  %28 = inttoptr i64 %27 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64), i64* %28
  %29 = add i64 %25, 16
  %30 = inttoptr i64 %29 to i64*
  store i64 %21, i64* %30
  %31 = add i64 %25, 24
  %32 = inttoptr i64 %31 to i64*
  store i64 0, i64* %32
; # (val $Up)
  %33 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 728) to i64) to i64*
  %34 = load i64, i64* %33
; # (push (val $Up) $Up P)
  %35 = alloca i64, i64 3, align 16
  %36 = ptrtoint i64* %35 to i64
  %37 = inttoptr i64 %36 to i64*
  store i64 %34, i64* %37
  %38 = add i64 %36, 8
  %39 = inttoptr i64 %38 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 728) to i64), i64* %39
  %40 = add i64 %36, 16
  %41 = inttoptr i64 %40 to i64*
  store i64 %25, i64* %41
; # (set $Up Exe)
  %42 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 728) to i64) to i64*
  store i64 %19, i64* %42
; # (set $Break (set $Bind (push (val $Run) $Run P)))
; # (set $Bind (push (val $Run) $Run P))
; # (val $Run)
  %43 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 600) to i64) to i64*
  %44 = load i64, i64* %43
; # (push (val $Run) $Run P)
  %45 = alloca i64, i64 3, align 16
  %46 = ptrtoint i64* %45 to i64
  %47 = inttoptr i64 %46 to i64*
  store i64 %44, i64* %47
  %48 = add i64 %46, 8
  %49 = inttoptr i64 %48 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 600) to i64), i64* %49
  %50 = add i64 %46, 16
  %51 = inttoptr i64 %50 to i64*
  store i64 %36, i64* %51
  %52 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %46, i64* %52
  %53 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 16) to i64) to i64*
  store i64 %46, i64* %53
; # (set $Run $Nil)
  %54 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 600) to i64) to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %54
; # (b8+ (ioFrame T))
  %55 = alloca i8, i64 28, align 8
; # (val $OutFiles)
  %56 = load i8**, i8*** @$OutFiles
; # (val 2 (val $OutFiles))
  %57 = getelementptr i8*, i8** %56, i32 1
  %58 = load i8*, i8** %57
; # (pushOutFile (b8+ (ioFrame T)) (val 2 (val $OutFiles)) 0)
  call void @pushOutFile(i8* %55, i8* %58, i32 0)
; # (print Exe)
  call void @print(i64 %19)
; # (newline)
  call void @newline()
; # (repl 0 ($ "! ") $Nil)
  %59 = call i64 @repl(i64 0, i8* bitcast ([3 x i8]* @$82 to i8*), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (popOutFiles)
  call void @popOutFiles()
; # (val $Up)
  %60 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 728) to i64) to i64*
  %61 = load i64, i64* %60
; # (let P (val $Bind) (set $Run (val P)) (setq P (val 3 P)) (set $Up...
; # (val $Bind)
  %62 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  %63 = load i64, i64* %62
; # (set $Run (val P))
; # (val P)
  %64 = inttoptr i64 %63 to i64*
  %65 = load i64, i64* %64
  %66 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 600) to i64) to i64*
  store i64 %65, i64* %66
; # (val 3 P)
  %67 = inttoptr i64 %63 to i64*
  %68 = getelementptr i64, i64* %67, i32 2
  %69 = load i64, i64* %68
; # (set $Up (val P))
; # (val P)
  %70 = inttoptr i64 %69 to i64*
  %71 = load i64, i64* %70
  %72 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 728) to i64) to i64*
  store i64 %71, i64* %72
; # (val 3 P)
  %73 = inttoptr i64 %69 to i64*
  %74 = getelementptr i64, i64* %73, i32 2
  %75 = load i64, i64* %74
; # (set $At (val P))
; # (val P)
  %76 = inttoptr i64 %75 to i64*
  %77 = load i64, i64* %76
  %78 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  store i64 %77, i64* %78
; # (set $Bind (val 3 P))
; # (val 3 P)
  %79 = inttoptr i64 %75 to i64*
  %80 = getelementptr i64, i64* %79, i32 2
  %81 = load i64, i64* %80
  %82 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %81, i64* %82
; # (set $Break 0)
  %83 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 16) to i64) to i64*
  store i64 0, i64* %83
  br label %$6
$6:
  %84 = phi i64 [%17, %$2], [%61, %$5] ; # Exe
  ret i64 %84
}

define i64 @_Break(i64) align 8 {
$1:
; # (let X (cdr Exe) (unless (nil? (val $Dbg)) (setq X (brkLoad X))) ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (unless (nil? (val $Dbg)) (setq X (brkLoad X)))
; # (val $Dbg)
  %4 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 824) to i64) to i64*
  %5 = load i64, i64* %4
; # (nil? (val $Dbg))
  %6 = icmp eq i64 %5, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %6, label %$3, label %$2
$2:
  %7 = phi i64 [%3, %$1] ; # X
; # (brkLoad X)
  %8 = call i64 @brkLoad(i64 %7)
  br label %$3
$3:
  %9 = phi i64 [%3, %$1], [%8, %$2] ; # X
; # (eval X)
  %10 = and i64 %9, 6
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  br label %$4
$5:
  %12 = and i64 %9, 8
  %13 = icmp ne i64 %12, 0
  br i1 %13, label %$8, label %$7
$8:
  %14 = inttoptr i64 %9 to i64*
  %15 = load i64, i64* %14
  br label %$4
$7:
  %16 = call i64 @evList(i64 %9)
  br label %$4
$4:
  %17 = phi i64 [%9, %$6], [%15, %$8], [%16, %$7] ; # ->
  ret i64 %17
}

define i64 @_E(i64) align 8 {
$1:
; # (let P (val $Break) (unless P (err Exe 0 ($ "No Break") null)) (l...
; # (val $Break)
  %1 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 16) to i64) to i64*
  %2 = load i64, i64* %1
; # (unless P (err Exe 0 ($ "No Break") null))
  %3 = icmp ne i64 %2, 0
  br i1 %3, label %$3, label %$2
$2:
; # (err Exe 0 ($ "No Break") null)
  call void @err(i64 %0, i64 0, i8* bitcast ([9 x i8]* @$83 to i8*), i8* null)
  unreachable
$3:
; # (let (Dbg (save (val $Dbg)) At (save (val $At)) Run (save (val $R...
; # (val $Dbg)
  %4 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 824) to i64) to i64*
  %5 = load i64, i64* %4
; # (save (val $Dbg))
  %6 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %7 = load i64, i64* %6
  %8 = alloca i64, i64 2, align 16
  %9 = ptrtoint i64* %8 to i64
  %10 = inttoptr i64 %9 to i64*
  store i64 %5, i64* %10
  %11 = add i64 %9, 8
  %12 = inttoptr i64 %11 to i64*
  store i64 %7, i64* %12
  %13 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %9, i64* %13
; # (val $At)
  %14 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  %15 = load i64, i64* %14
; # (save (val $At))
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %17 = load i64, i64* %16
  %18 = alloca i64, i64 2, align 16
  %19 = ptrtoint i64* %18 to i64
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = add i64 %19, 8
  %22 = inttoptr i64 %21 to i64*
  store i64 %17, i64* %22
  %23 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %19, i64* %23
; # (val $Run)
  %24 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 600) to i64) to i64*
  %25 = load i64, i64* %24
; # (save (val $Run))
  %26 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %27 = load i64, i64* %26
  %28 = alloca i64, i64 2, align 16
  %29 = ptrtoint i64* %28 to i64
  %30 = inttoptr i64 %29 to i64*
  store i64 %25, i64* %30
  %31 = add i64 %29, 8
  %32 = inttoptr i64 %31 to i64*
  store i64 %27, i64* %32
  %33 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %29, i64* %33
; # (set $Dbg $Nil $Run (val P) $At (val (val 3 (val 3 P))))
  %34 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 824) to i64) to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %34
; # (val P)
  %35 = inttoptr i64 %2 to i64*
  %36 = load i64, i64* %35
  %37 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 600) to i64) to i64*
  store i64 %36, i64* %37
; # (val 3 P)
  %38 = inttoptr i64 %2 to i64*
  %39 = getelementptr i64, i64* %38, i32 2
  %40 = load i64, i64* %39
; # (val 3 (val 3 P))
  %41 = inttoptr i64 %40 to i64*
  %42 = getelementptr i64, i64* %41, i32 2
  %43 = load i64, i64* %42
; # (val (val 3 (val 3 P)))
  %44 = inttoptr i64 %43 to i64*
  %45 = load i64, i64* %44
  %46 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  store i64 %45, i64* %46
; # (let (In: (ioFrame (val $InFrames)) Out: (ioFrame (val $OutFrames...
; # (val $InFrames)
  %47 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 40) to i8**)
; # (val $OutFrames)
  %48 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 48) to i8**)
; # (popInFiles)
  call void @popInFiles()
; # (popOutFiles)
  call void @popOutFiles()
; # (prog1 (if (pair (cdr Exe)) (run @) (eval (val $Up))) (if (Out: f...
; # (if (pair (cdr Exe)) (run @) (eval (val $Up)))
; # (cdr Exe)
  %49 = inttoptr i64 %0 to i64*
  %50 = getelementptr i64, i64* %49, i32 1
  %51 = load i64, i64* %50
; # (pair (cdr Exe))
  %52 = and i64 %51, 15
  %53 = icmp eq i64 %52, 0
  br i1 %53, label %$4, label %$5
$4:
; # (run @)
  br label %$7
$7:
  %54 = phi i64 [%51, %$4], [%76, %$16] ; # Prg
  %55 = inttoptr i64 %54 to i64*
  %56 = load i64, i64* %55
  %57 = getelementptr i64, i64* %55, i32 1
  %58 = load i64, i64* %57
  %59 = and i64 %58, 15
  %60 = icmp ne i64 %59, 0
  br i1 %60, label %$10, label %$8
$10:
  %61 = phi i64 [%58, %$7] ; # Prg
  %62 = and i64 %56, 6
  %63 = icmp ne i64 %62, 0
  br i1 %63, label %$13, label %$12
$13:
  br label %$11
$12:
  %64 = and i64 %56, 8
  %65 = icmp ne i64 %64, 0
  br i1 %65, label %$15, label %$14
$15:
  %66 = inttoptr i64 %56 to i64*
  %67 = load i64, i64* %66
  br label %$11
$14:
  %68 = call i64 @evList(i64 %56)
  br label %$11
$11:
  %69 = phi i64 [%56, %$13], [%67, %$15], [%68, %$14] ; # ->
  br label %$9
$8:
  %70 = phi i64 [%58, %$7] ; # Prg
  %71 = and i64 %56, 15
  %72 = icmp eq i64 %71, 0
  br i1 %72, label %$17, label %$16
$17:
  %73 = phi i64 [%70, %$8] ; # Prg
  %74 = call i64 @evList(i64 %56)
  %75 = icmp ne i64 %74, 0
  br label %$16
$16:
  %76 = phi i64 [%70, %$8], [%73, %$17] ; # Prg
  %77 = phi i1 [0, %$8], [%75, %$17] ; # ->
  br label %$7
$9:
  %78 = phi i64 [%61, %$11] ; # Prg
  %79 = phi i64 [%69, %$11] ; # ->
  br label %$6
$5:
; # (val $Up)
  %80 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 728) to i64) to i64*
  %81 = load i64, i64* %80
; # (eval (val $Up))
  %82 = and i64 %81, 6
  %83 = icmp ne i64 %82, 0
  br i1 %83, label %$20, label %$19
$20:
  br label %$18
$19:
  %84 = and i64 %81, 8
  %85 = icmp ne i64 %84, 0
  br i1 %85, label %$22, label %$21
$22:
  %86 = inttoptr i64 %81 to i64*
  %87 = load i64, i64* %86
  br label %$18
$21:
  %88 = call i64 @evList(i64 %81)
  br label %$18
$18:
  %89 = phi i64 [%81, %$20], [%87, %$22], [%88, %$21] ; # ->
  br label %$6
$6:
  %90 = phi i64 [%79, %$9], [%89, %$18] ; # ->
; # (if (Out: file) (pushOutFile (Out:) (Out: file) (Out: pid)) (push...
; # (Out: file)
  %91 = getelementptr i8, i8* %48, i32 8
  %92 = bitcast i8* %91 to i8**
  %93 = load i8*, i8** %92
  %94 = icmp ne i8* %93, null
  br i1 %94, label %$23, label %$24
$23:
; # (Out:)
; # (Out: file)
  %95 = getelementptr i8, i8* %48, i32 8
  %96 = bitcast i8* %95 to i8**
  %97 = load i8*, i8** %96
; # (Out: pid)
  %98 = getelementptr i8, i8* %48, i32 24
  %99 = bitcast i8* %98 to i32*
  %100 = load i32, i32* %99
; # (pushOutFile (Out:) (Out: file) (Out: pid))
  call void @pushOutFile(i8* %48, i8* %97, i32 %100)
  br label %$25
$24:
; # (Out:)
; # (Out:)
; # ((ioxFrame (Out:)) exe)
  %101 = getelementptr i8, i8* %48, i32 24
  %102 = ptrtoint i8* %101 to i64
  %103 = inttoptr i64 %102 to i64*
  %104 = load i64, i64* %103
; # (pushOutput (Out:) ((ioxFrame (Out:)) exe))
  call void @pushOutput(i8* %48, i64 %104)
  br label %$25
$25:
; # (if (In: file) (pushInFile (In:) (In: file) (In: pid)) (pushInput...
; # (In: file)
  %105 = getelementptr i8, i8* %47, i32 8
  %106 = bitcast i8* %105 to i8**
  %107 = load i8*, i8** %106
  %108 = icmp ne i8* %107, null
  br i1 %108, label %$26, label %$27
$26:
; # (In:)
; # (In: file)
  %109 = getelementptr i8, i8* %47, i32 8
  %110 = bitcast i8* %109 to i8**
  %111 = load i8*, i8** %110
; # (In: pid)
  %112 = getelementptr i8, i8* %47, i32 24
  %113 = bitcast i8* %112 to i32*
  %114 = load i32, i32* %113
; # (pushInFile (In:) (In: file) (In: pid))
  call void @pushInFile(i8* %47, i8* %111, i32 %114)
  br label %$28
$27:
; # (In:)
; # (In:)
; # ((ioxFrame (In:)) exe)
  %115 = getelementptr i8, i8* %47, i32 24
  %116 = ptrtoint i8* %115 to i64
  %117 = inttoptr i64 %116 to i64*
  %118 = load i64, i64* %117
; # (pushInput (In:) ((ioxFrame (In:)) exe))
  call void @pushInput(i8* %47, i64 %118)
  br label %$28
$28:
; # (set $Run Run $At At $Dbg Dbg)
  %119 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 600) to i64) to i64*
  store i64 %25, i64* %119
  %120 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  store i64 %15, i64* %120
  %121 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 824) to i64) to i64*
  store i64 %5, i64* %121
; # (drop *Safe)
  %122 = inttoptr i64 %9 to i64*
  %123 = getelementptr i64, i64* %122, i32 1
  %124 = load i64, i64* %123
  %125 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %124, i64* %125
  ret i64 %90
}

define void @trace(i32, i64) align 8 {
$1:
; # (when (> C 64) (setq C 64))
; # (> C 64)
  %2 = icmp sgt i32 %0, 64
  br i1 %2, label %$2, label %$3
$2:
  %3 = phi i32 [%0, %$1] ; # C
  br label %$3
$3:
  %4 = phi i32 [%0, %$1], [64, %$2] ; # C
; # (while (ge0 (dec 'C)) (space))
  br label %$4
$4:
  %5 = phi i32 [%4, %$3], [%8, %$5] ; # C
; # (dec 'C)
  %6 = sub i32 %5, 1
; # (ge0 (dec 'C))
  %7 = icmp sge i32 %6, 0
  br i1 %7, label %$5, label %$6
$5:
  %8 = phi i32 [%6, %$4] ; # C
; # (space)
  call void @space()
  br label %$4
$6:
  %9 = phi i32 [%6, %$4] ; # C
; # (if (atom X) (print @) (print (car X)) (space) (print (cdr X)) (s...
; # (atom X)
  %10 = and i64 %1, 15
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$7, label %$8
$7:
  %12 = phi i32 [%9, %$6] ; # C
; # (print @)
  call void @print(i64 %1)
  br label %$9
$8:
  %13 = phi i32 [%9, %$6] ; # C
; # (car X)
  %14 = inttoptr i64 %1 to i64*
  %15 = load i64, i64* %14
; # (print (car X))
  call void @print(i64 %15)
; # (space)
  call void @space()
; # (cdr X)
  %16 = inttoptr i64 %1 to i64*
  %17 = getelementptr i64, i64* %16, i32 1
  %18 = load i64, i64* %17
; # (print (cdr X))
  call void @print(i64 %18)
; # (space)
  call void @space()
; # (val $This)
  %19 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 488) to i64) to i64*
  %20 = load i64, i64* %19
; # (print (val $This))
  call void @print(i64 %20)
  br label %$9
$9:
  %21 = phi i32 [%12, %$7], [%13, %$8] ; # C
  ret void
}

define i64 @_Trace(i64) align 8 {
$1:
; # (let X (cdr Exe) (if (nil? (val $Dbg)) (run (cddr X)) (let (Out (...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (if (nil? (val $Dbg)) (run (cddr X)) (let (Out (val $OutFile) Put...
; # (val $Dbg)
  %4 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 824) to i64) to i64*
  %5 = load i64, i64* %4
; # (nil? (val $Dbg))
  %6 = icmp eq i64 %5, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %6, label %$2, label %$3
$2:
  %7 = phi i64 [%3, %$1] ; # X
; # (cddr X)
  %8 = inttoptr i64 %7 to i64*
  %9 = getelementptr i64, i64* %8, i32 1
  %10 = load i64, i64* %9
  %11 = inttoptr i64 %10 to i64*
  %12 = getelementptr i64, i64* %11, i32 1
  %13 = load i64, i64* %12
; # (run (cddr X))
  br label %$5
$5:
  %14 = phi i64 [%13, %$2], [%36, %$14] ; # Prg
  %15 = inttoptr i64 %14 to i64*
  %16 = load i64, i64* %15
  %17 = getelementptr i64, i64* %15, i32 1
  %18 = load i64, i64* %17
  %19 = and i64 %18, 15
  %20 = icmp ne i64 %19, 0
  br i1 %20, label %$8, label %$6
$8:
  %21 = phi i64 [%18, %$5] ; # Prg
  %22 = and i64 %16, 6
  %23 = icmp ne i64 %22, 0
  br i1 %23, label %$11, label %$10
$11:
  br label %$9
$10:
  %24 = and i64 %16, 8
  %25 = icmp ne i64 %24, 0
  br i1 %25, label %$13, label %$12
$13:
  %26 = inttoptr i64 %16 to i64*
  %27 = load i64, i64* %26
  br label %$9
$12:
  %28 = call i64 @evList(i64 %16)
  br label %$9
$9:
  %29 = phi i64 [%16, %$11], [%27, %$13], [%28, %$12] ; # ->
  br label %$7
$6:
  %30 = phi i64 [%18, %$5] ; # Prg
  %31 = and i64 %16, 15
  %32 = icmp eq i64 %31, 0
  br i1 %32, label %$15, label %$14
$15:
  %33 = phi i64 [%30, %$6] ; # Prg
  %34 = call i64 @evList(i64 %16)
  %35 = icmp ne i64 %34, 0
  br label %$14
$14:
  %36 = phi i64 [%30, %$6], [%33, %$15] ; # Prg
  %37 = phi i1 [0, %$6], [%35, %$15] ; # ->
  br label %$5
$7:
  %38 = phi i64 [%21, %$9] ; # Prg
  %39 = phi i64 [%29, %$9] ; # ->
  br label %$4
$3:
  %40 = phi i64 [%3, %$1] ; # X
; # (let (Out (val $OutFile) Put (val (i8** $Put))) (set $OutFile (va...
; # (val $OutFile)
  %41 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 80) to i8**)
; # (i8** $Put)
  %42 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**) to i8**
; # (val (i8** $Put))
  %43 = load i8*, i8** %42
; # (set $OutFile (val 3 (val $OutFiles)) $Put (fun (void i8) _putStd...
; # (val $OutFiles)
  %44 = load i8**, i8*** @$OutFiles
; # (val 3 (val $OutFiles))
  %45 = getelementptr i8*, i8** %44, i32 2
  %46 = load i8*, i8** %45
  store i8* %46, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 80) to i8**)
; # (fun (void i8) _putStdout)
  store void(i8)* @_putStdout, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
; # (let (Y (++ X) Z (++ X)) (trace (set $Trace (inc (val $Trace))) Y...
; # (++ X)
  %47 = inttoptr i64 %40 to i64*
  %48 = load i64, i64* %47
  %49 = getelementptr i64, i64* %47, i32 1
  %50 = load i64, i64* %49
; # (++ X)
  %51 = inttoptr i64 %50 to i64*
  %52 = load i64, i64* %51
  %53 = getelementptr i64, i64* %51, i32 1
  %54 = load i64, i64* %53
; # (set $Trace (inc (val $Trace)))
; # (val $Trace)
  %55 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 184) to i32*)
; # (inc (val $Trace))
  %56 = add i32 %55, 1
  store i32 %56, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 184) to i32*)
; # (trace (set $Trace (inc (val $Trace))) Y)
  call void @trace(i32 %56, i64 %48)
; # (outString ($ " :"))
  call void @outString(i8* bitcast ([3 x i8]* @$84 to i8*))
; # (while (pair Z) (space) (print (val (++ Z))))
  br label %$16
$16:
  %57 = phi i64 [%54, %$3], [%61, %$17] ; # X
  %58 = phi i64 [%52, %$3], [%66, %$17] ; # Z
; # (pair Z)
  %59 = and i64 %58, 15
  %60 = icmp eq i64 %59, 0
  br i1 %60, label %$17, label %$18
$17:
  %61 = phi i64 [%57, %$16] ; # X
  %62 = phi i64 [%58, %$16] ; # Z
; # (space)
  call void @space()
; # (++ Z)
  %63 = inttoptr i64 %62 to i64*
  %64 = load i64, i64* %63
  %65 = getelementptr i64, i64* %63, i32 1
  %66 = load i64, i64* %65
; # (val (++ Z))
  %67 = inttoptr i64 %64 to i64*
  %68 = load i64, i64* %67
; # (print (val (++ Z)))
  call void @print(i64 %68)
  br label %$16
$18:
  %69 = phi i64 [%57, %$16] ; # X
  %70 = phi i64 [%58, %$16] ; # Z
; # (cond ((== Z $At) (setq Z (val $Next)) (while (pair Z) (space) (p...
; # (== Z $At)
  %71 = icmp eq i64 %70, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64)
  br i1 %71, label %$21, label %$20
$21:
  %72 = phi i64 [%69, %$18] ; # X
  %73 = phi i64 [%70, %$18] ; # Z
; # (val $Next)
  %74 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 128) to i64) to i64*
  %75 = load i64, i64* %74
; # (while (pair Z) (space) (print (cdr Z)) (setq Z (car Z)))
  br label %$22
$22:
  %76 = phi i64 [%72, %$21], [%80, %$23] ; # X
  %77 = phi i64 [%75, %$21], [%86, %$23] ; # Z
; # (pair Z)
  %78 = and i64 %77, 15
  %79 = icmp eq i64 %78, 0
  br i1 %79, label %$23, label %$24
$23:
  %80 = phi i64 [%76, %$22] ; # X
  %81 = phi i64 [%77, %$22] ; # Z
; # (space)
  call void @space()
; # (cdr Z)
  %82 = inttoptr i64 %81 to i64*
  %83 = getelementptr i64, i64* %82, i32 1
  %84 = load i64, i64* %83
; # (print (cdr Z))
  call void @print(i64 %84)
; # (car Z)
  %85 = inttoptr i64 %81 to i64*
  %86 = load i64, i64* %85
  br label %$22
$24:
  %87 = phi i64 [%76, %$22] ; # X
  %88 = phi i64 [%77, %$22] ; # Z
  br label %$19
$20:
  %89 = phi i64 [%69, %$18] ; # X
  %90 = phi i64 [%70, %$18] ; # Z
; # (nil? Z)
  %91 = icmp eq i64 %90, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
; # (not (nil? Z))
  %92 = icmp eq i1 %91, 0
  br i1 %92, label %$26, label %$25
$26:
  %93 = phi i64 [%89, %$20] ; # X
  %94 = phi i64 [%90, %$20] ; # Z
; # (space)
  call void @space()
; # (val Z)
  %95 = inttoptr i64 %94 to i64*
  %96 = load i64, i64* %95
; # (print (val Z))
  call void @print(i64 %96)
  br label %$19
$25:
  %97 = phi i64 [%89, %$20] ; # X
  %98 = phi i64 [%90, %$20] ; # Z
  br label %$19
$19:
  %99 = phi i64 [%87, %$24], [%93, %$26], [%97, %$25] ; # X
  %100 = phi i64 [%88, %$24], [%94, %$26], [%98, %$25] ; # Z
; # (newline)
  call void @newline()
; # (set (i8** $Put) Put $OutFile Out)
; # (i8** $Put)
  %101 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**) to i8**
  store i8* %43, i8** %101
  store i8* %41, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 80) to i8**)
; # (prog1 (run X) (set $OutFile (val 3 (val $OutFiles)) $Put (fun (v...
; # (run X)
  br label %$27
$27:
  %102 = phi i64 [%99, %$19], [%124, %$36] ; # Prg
  %103 = inttoptr i64 %102 to i64*
  %104 = load i64, i64* %103
  %105 = getelementptr i64, i64* %103, i32 1
  %106 = load i64, i64* %105
  %107 = and i64 %106, 15
  %108 = icmp ne i64 %107, 0
  br i1 %108, label %$30, label %$28
$30:
  %109 = phi i64 [%106, %$27] ; # Prg
  %110 = and i64 %104, 6
  %111 = icmp ne i64 %110, 0
  br i1 %111, label %$33, label %$32
$33:
  br label %$31
$32:
  %112 = and i64 %104, 8
  %113 = icmp ne i64 %112, 0
  br i1 %113, label %$35, label %$34
$35:
  %114 = inttoptr i64 %104 to i64*
  %115 = load i64, i64* %114
  br label %$31
$34:
  %116 = call i64 @evList(i64 %104)
  br label %$31
$31:
  %117 = phi i64 [%104, %$33], [%115, %$35], [%116, %$34] ; # ->
  br label %$29
$28:
  %118 = phi i64 [%106, %$27] ; # Prg
  %119 = and i64 %104, 15
  %120 = icmp eq i64 %119, 0
  br i1 %120, label %$37, label %$36
$37:
  %121 = phi i64 [%118, %$28] ; # Prg
  %122 = call i64 @evList(i64 %104)
  %123 = icmp ne i64 %122, 0
  br label %$36
$36:
  %124 = phi i64 [%118, %$28], [%121, %$37] ; # Prg
  %125 = phi i1 [0, %$28], [%123, %$37] ; # ->
  br label %$27
$29:
  %126 = phi i64 [%109, %$31] ; # Prg
  %127 = phi i64 [%117, %$31] ; # ->
; # (set $OutFile (val 3 (val $OutFiles)) $Put (fun (void i8) _putStd...
; # (val $OutFiles)
  %128 = load i8**, i8*** @$OutFiles
; # (val 3 (val $OutFiles))
  %129 = getelementptr i8*, i8** %128, i32 2
  %130 = load i8*, i8** %129
  store i8* %130, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 80) to i8**)
; # (fun (void i8) _putStdout)
  store void(i8)* @_putStdout, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
; # (let I (val $Trace) (trace I Y) (set $Trace (dec I)))
; # (val $Trace)
  %131 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 184) to i32*)
; # (trace I Y)
  call void @trace(i32 %131, i64 %48)
; # (set $Trace (dec I))
; # (dec I)
  %132 = sub i32 %131, 1
  store i32 %132, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 184) to i32*)
; # (outString ($ " = "))
  call void @outString(i8* bitcast ([4 x i8]* @$85 to i8*))
; # (print @)
  call void @print(i64 %127)
; # (newline)
  call void @newline()
; # (set (i8** $Put) Put $OutFile Out)
; # (i8** $Put)
  %133 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**) to i8**
  store i8* %43, i8** %133
  store i8* %41, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 80) to i8**)
  br label %$4
$4:
  %134 = phi i64 [%7, %$7], [%99, %$29] ; # X
  %135 = phi i64 [%39, %$7], [%127, %$29] ; # ->
  ret i64 %135
}

define i64 @_Exec(i64) align 8 {
$1:
; # (let (X (cdr Exe) Av (b8* (inc (length X))) Cmd (xName (evSym X))...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (length X)
  br label %$2
$2:
  %4 = phi i64 [%3, %$1], [%13, %$3] ; # X
  %5 = phi i64 [0, %$1], [%10, %$3] ; # N
  %6 = and i64 %4, 15
  %7 = icmp eq i64 %6, 0
  br i1 %7, label %$3, label %$4
$3:
  %8 = phi i64 [%4, %$2] ; # X
  %9 = phi i64 [%5, %$2] ; # N
  %10 = add i64 %9, 1
  %11 = inttoptr i64 %8 to i64*
  %12 = getelementptr i64, i64* %11, i32 1
  %13 = load i64, i64* %12
  br label %$2
$4:
  %14 = phi i64 [%4, %$2] ; # X
  %15 = phi i64 [%5, %$2] ; # N
; # (inc (length X))
  %16 = add i64 %15, 1
; # (b8* (inc (length X)))
  %17 = alloca i8*, i64 %16
; # (evSym X)
  %18 = call i64 @evSym(i64 %3)
; # (xName (evSym X))
  %19 = call i64 @xName(i64 %18)
; # (set Av (pathString Cmd (b8 (pathSize Cmd))))
; # (pathSize Cmd)
  %20 = call i64 @pathSize(i64 %19)
; # (b8 (pathSize Cmd))
  %21 = alloca i8, i64 %20
; # (pathString Cmd (b8 (pathSize Cmd)))
  %22 = call i8* @pathString(i64 %19, i8* %21)
  store i8* %22, i8** %17
; # (stkChk Exe)
  %23 = load i8*, i8** @$StkLimit
  %24 = call i8* @llvm.stacksave()
  %25 = icmp ugt i8* %23, %24
  br i1 %25, label %$5, label %$6
$5:
  call void @stkErr(i64 %0)
  unreachable
$6:
; # (let A Av (while (pair (shift X)) (let Nm (xName (evSym X)) (set ...
; # (while (pair (shift X)) (let Nm (xName (evSym X)) (set (inc 'A) (...
  br label %$7
$7:
  %26 = phi i64 [%3, %$6], [%33, %$11] ; # X
  %27 = phi i8** [%17, %$6], [%37, %$11] ; # A
; # (shift X)
  %28 = inttoptr i64 %26 to i64*
  %29 = getelementptr i64, i64* %28, i32 1
  %30 = load i64, i64* %29
; # (pair (shift X))
  %31 = and i64 %30, 15
  %32 = icmp eq i64 %31, 0
  br i1 %32, label %$8, label %$9
$8:
  %33 = phi i64 [%30, %$7] ; # X
  %34 = phi i8** [%27, %$7] ; # A
; # (let Nm (xName (evSym X)) (set (inc 'A) (bufString Nm (b8 (bufSiz...
; # (evSym X)
  %35 = call i64 @evSym(i64 %33)
; # (xName (evSym X))
  %36 = call i64 @xName(i64 %35)
; # (set (inc 'A) (bufString Nm (b8 (bufSize Nm))))
; # (inc 'A)
  %37 = getelementptr i8*, i8** %34, i32 1
; # (bufSize Nm)
  %38 = call i64 @bufSize(i64 %36)
; # (b8 (bufSize Nm))
  %39 = alloca i8, i64 %38
; # (bufString Nm (b8 (bufSize Nm)))
  %40 = call i8* @bufString(i64 %36, i8* %39)
  store i8* %40, i8** %37
; # (stkChk Exe)
  %41 = load i8*, i8** @$StkLimit
  %42 = call i8* @llvm.stacksave()
  %43 = icmp ugt i8* %41, %42
  br i1 %43, label %$10, label %$11
$10:
  call void @stkErr(i64 %0)
  unreachable
$11:
  br label %$7
$9:
  %44 = phi i64 [%30, %$7] ; # X
  %45 = phi i8** [%27, %$7] ; # A
; # (set (inc 'A) null)
; # (inc 'A)
  %46 = getelementptr i8*, i8** %45, i32 1
  store i8* null, i8** %46
; # (flushAll)
  call void @flushAll()
; # (val Av)
  %47 = load i8*, i8** %17
; # (execvp (val Av) Av)
  %48 = call i32 @execvp(i8* %47, i8** %17)
; # (val Av)
  %49 = load i8*, i8** %17
; # (execErr (val Av))
  call void @execErr(i8* %49)
  unreachable
}

define i64 @_Call(i64) align 8 {
$1:
; # (let (X (cdr Exe) Av (b8* (inc (length X))) Cmd (xName (evSym X))...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (length X)
  br label %$2
$2:
  %4 = phi i64 [%3, %$1], [%13, %$3] ; # X
  %5 = phi i64 [0, %$1], [%10, %$3] ; # N
  %6 = and i64 %4, 15
  %7 = icmp eq i64 %6, 0
  br i1 %7, label %$3, label %$4
$3:
  %8 = phi i64 [%4, %$2] ; # X
  %9 = phi i64 [%5, %$2] ; # N
  %10 = add i64 %9, 1
  %11 = inttoptr i64 %8 to i64*
  %12 = getelementptr i64, i64* %11, i32 1
  %13 = load i64, i64* %12
  br label %$2
$4:
  %14 = phi i64 [%4, %$2] ; # X
  %15 = phi i64 [%5, %$2] ; # N
; # (inc (length X))
  %16 = add i64 %15, 1
; # (b8* (inc (length X)))
  %17 = alloca i8*, i64 %16
; # (evSym X)
  %18 = call i64 @evSym(i64 %3)
; # (xName (evSym X))
  %19 = call i64 @xName(i64 %18)
; # (set Av (pathString Cmd (b8 (pathSize Cmd))))
; # (pathSize Cmd)
  %20 = call i64 @pathSize(i64 %19)
; # (b8 (pathSize Cmd))
  %21 = alloca i8, i64 %20
; # (pathString Cmd (b8 (pathSize Cmd)))
  %22 = call i8* @pathString(i64 %19, i8* %21)
  store i8* %22, i8** %17
; # (stkChk Exe)
  %23 = load i8*, i8** @$StkLimit
  %24 = call i8* @llvm.stacksave()
  %25 = icmp ugt i8* %23, %24
  br i1 %25, label %$5, label %$6
$5:
  call void @stkErr(i64 %0)
  unreachable
$6:
; # (let A Av (while (pair (shift X)) (let Nm (xName (evSym X)) (set ...
; # (while (pair (shift X)) (let Nm (xName (evSym X)) (set (inc 'A) (...
  br label %$7
$7:
  %26 = phi i64 [%3, %$6], [%33, %$11] ; # X
  %27 = phi i8** [%17, %$6], [%37, %$11] ; # A
; # (shift X)
  %28 = inttoptr i64 %26 to i64*
  %29 = getelementptr i64, i64* %28, i32 1
  %30 = load i64, i64* %29
; # (pair (shift X))
  %31 = and i64 %30, 15
  %32 = icmp eq i64 %31, 0
  br i1 %32, label %$8, label %$9
$8:
  %33 = phi i64 [%30, %$7] ; # X
  %34 = phi i8** [%27, %$7] ; # A
; # (let Nm (xName (evSym X)) (set (inc 'A) (bufString Nm (b8 (bufSiz...
; # (evSym X)
  %35 = call i64 @evSym(i64 %33)
; # (xName (evSym X))
  %36 = call i64 @xName(i64 %35)
; # (set (inc 'A) (bufString Nm (b8 (bufSize Nm))))
; # (inc 'A)
  %37 = getelementptr i8*, i8** %34, i32 1
; # (bufSize Nm)
  %38 = call i64 @bufSize(i64 %36)
; # (b8 (bufSize Nm))
  %39 = alloca i8, i64 %38
; # (bufString Nm (b8 (bufSize Nm)))
  %40 = call i8* @bufString(i64 %36, i8* %39)
  store i8* %40, i8** %37
; # (stkChk Exe)
  %41 = load i8*, i8** @$StkLimit
  %42 = call i8* @llvm.stacksave()
  %43 = icmp ugt i8* %41, %42
  br i1 %43, label %$10, label %$11
$10:
  call void @stkErr(i64 %0)
  unreachable
$11:
  br label %$7
$9:
  %44 = phi i64 [%30, %$7] ; # X
  %45 = phi i8** [%27, %$7] ; # A
; # (set (inc 'A) null)
; # (inc 'A)
  %46 = getelementptr i8*, i8** %45, i32 1
  store i8* null, i8** %46
; # (flushAll)
  call void @flushAll()
; # (let (Tc (tcgetpgrp 0) Fg (and (val Tio) (== Tc (getpgrp)))) (con...
; # (tcgetpgrp 0)
  %47 = call i32 @tcgetpgrp(i32 0)
; # (and (val Tio) (== Tc (getpgrp)))
; # (val Tio)
  %48 = load i1, i1* @Tio
  br i1 %48, label %$13, label %$12
$13:
  %49 = phi i64 [%44, %$9] ; # X
; # (getpgrp)
  %50 = call i32 @getpgrp()
; # (== Tc (getpgrp))
  %51 = icmp eq i32 %47, %50
  br label %$12
$12:
  %52 = phi i64 [%44, %$9], [%49, %$13] ; # X
  %53 = phi i1 [0, %$9], [%51, %$13] ; # ->
; # (cond ((lt0 (fork)) (forkErr Exe)) ((=0 @) (setpgid 0 0) (when Fg...
; # (fork)
  %54 = call i32 @fork()
; # (lt0 (fork))
  %55 = icmp slt i32 %54, 0
  br i1 %55, label %$16, label %$15
$16:
  %56 = phi i64 [%52, %$12] ; # X
; # (forkErr Exe)
  call void @forkErr(i64 %0)
  unreachable
$15:
  %57 = phi i64 [%52, %$12] ; # X
; # (=0 @)
  %58 = icmp eq i32 %54, 0
  br i1 %58, label %$18, label %$17
$18:
  %59 = phi i64 [%57, %$15] ; # X
; # (setpgid 0 0)
  %60 = call i32 @setpgid(i32 0, i32 0)
; # (when Fg (tcsetpgrp 0 (getpid)))
  br i1 %53, label %$19, label %$20
$19:
  %61 = phi i64 [%59, %$18] ; # X
; # (getpid)
  %62 = call i32 @getpid()
; # (tcsetpgrp 0 (getpid))
  %63 = call i32 @tcsetpgrp(i32 0, i32 %62)
  br label %$20
$20:
  %64 = phi i64 [%59, %$18], [%61, %$19] ; # X
; # (val Av)
  %65 = load i8*, i8** %17
; # (execvp (val Av) Av)
  %66 = call i32 @execvp(i8* %65, i8** %17)
; # (val Av)
  %67 = load i8*, i8** %17
; # (execErr (val Av))
  call void @execErr(i8* %67)
  unreachable
$17:
  %68 = phi i64 [%57, %$15] ; # X
  br label %$14
$14:
  %69 = phi i64 [%68, %$17] ; # X
  %70 = phi i64 [0, %$17] ; # ->
; # (let (Pid @ Res (b32 1)) (setpgid Pid 0) (when Fg (tcsetpgrp 0 Pi...
; # (b32 1)
  %71 = alloca i32, i64 1
; # (setpgid Pid 0)
  %72 = call i32 @setpgid(i32 %54, i32 0)
; # (when Fg (tcsetpgrp 0 Pid))
  br i1 %53, label %$21, label %$22
$21:
  %73 = phi i64 [%69, %$14] ; # X
; # (tcsetpgrp 0 Pid)
  %74 = call i32 @tcsetpgrp(i32 0, i32 %54)
  br label %$22
$22:
  %75 = phi i64 [%69, %$14], [%73, %$21] ; # X
; # (loop (while (lt0 (waitWuntraced Pid Res)) (unless (== (gErrno) E...
  br label %$23
$23:
  %76 = phi i64 [%75, %$22], [%109, %$40] ; # X
; # (while (lt0 (waitWuntraced Pid Res)) (unless (== (gErrno) EINTR) ...
  br label %$24
$24:
  %77 = phi i64 [%76, %$23], [%84, %$30] ; # X
; # (waitWuntraced Pid Res)
  %78 = call i32 @waitWuntraced(i32 %54, i32* %71)
; # (lt0 (waitWuntraced Pid Res))
  %79 = icmp slt i32 %78, 0
  br i1 %79, label %$25, label %$26
$25:
  %80 = phi i64 [%77, %$24] ; # X
; # (unless (== (gErrno) EINTR) (err Exe 0 ($ "wait pid") null))
; # (gErrno)
  %81 = call i32 @gErrno()
; # (== (gErrno) EINTR)
  %82 = icmp eq i32 %81, 2
  br i1 %82, label %$28, label %$27
$27:
  %83 = phi i64 [%80, %$25] ; # X
; # (err Exe 0 ($ "wait pid") null)
  call void @err(i64 %0, i64 0, i8* bitcast ([9 x i8]* @$86 to i8*), i8* null)
  unreachable
$28:
  %84 = phi i64 [%80, %$25] ; # X
; # (sigChk Exe)
  %85 = load volatile i32, i32* bitcast ([16 x i32]* @$Signal to i32*)
  %86 = icmp ne i32 %85, 0
  br i1 %86, label %$29, label %$30
$29:
  call void @sighandler(i64 %0)
  br label %$30
$30:
  br label %$24
$26:
  %87 = phi i64 [%77, %$24] ; # X
; # (when Fg (tcsetpgrp 0 Tc))
  br i1 %53, label %$31, label %$32
$31:
  %88 = phi i64 [%87, %$26] ; # X
; # (tcsetpgrp 0 Tc)
  %89 = call i32 @tcsetpgrp(i32 0, i32 %47)
  br label %$32
$32:
  %90 = phi i64 [%87, %$26], [%88, %$31] ; # X
; # (? (=0 (wifStopped Res)) (set $At2 (cnt (i64 (val Res)))) (if (va...
; # (wifStopped Res)
  %91 = call i32 @wifStopped(i32* %71)
; # (=0 (wifStopped Res))
  %92 = icmp eq i32 %91, 0
  br i1 %92, label %$35, label %$33
$35:
  %93 = phi i64 [%90, %$32] ; # X
; # (set $At2 (cnt (i64 (val Res))))
; # (val Res)
  %94 = load i32, i32* %71
; # (i64 (val Res))
  %95 = sext i32 %94 to i64
; # (cnt (i64 (val Res)))
  %96 = shl i64 %95, 4
  %97 = or i64 %96, 2
  %98 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 456) to i64) to i64*
  store i64 %97, i64* %98
; # (if (val Res) $Nil $T)
; # (val Res)
  %99 = load i32, i32* %71
  %100 = icmp ne i32 %99, 0
  br i1 %100, label %$36, label %$37
$36:
  %101 = phi i64 [%93, %$35] ; # X
  br label %$38
$37:
  %102 = phi i64 [%93, %$35] ; # X
  br label %$38
$38:
  %103 = phi i64 [%101, %$36], [%102, %$37] ; # X
  %104 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$36], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$37] ; # ->
  br label %$34
$33:
  %105 = phi i64 [%90, %$32] ; # X
; # (repl 0 ($ "+ ") $Nil)
  %106 = call i64 @repl(i64 0, i8* bitcast ([3 x i8]* @$87 to i8*), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (when Fg (tcsetpgrp 0 Pid))
  br i1 %53, label %$39, label %$40
$39:
  %107 = phi i64 [%105, %$33] ; # X
; # (tcsetpgrp 0 Pid)
  %108 = call i32 @tcsetpgrp(i32 0, i32 %54)
  br label %$40
$40:
  %109 = phi i64 [%105, %$33], [%107, %$39] ; # X
; # (val SIGCONT Sig)
  %110 = getelementptr i32, i32* @Sig, i32 8
  %111 = load i32, i32* %110
; # (kill Pid (val SIGCONT Sig))
  %112 = call i32 @kill(i32 %54, i32 %111)
  br label %$23
$34:
  %113 = phi i64 [%103, %$38] ; # X
  %114 = phi i64 [%104, %$38] ; # ->
  ret i64 %114
}

define i64 @_Ipid(i64) align 8 {
$1:
; # (let Io: (ioFrame (val $InFrames)) (if (and (Io: file) (> (Io: pi...
; # (val $InFrames)
  %1 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 40) to i8**)
; # (if (and (Io: file) (> (Io: pid) 1)) (cnt (i64 (Io: pid))) $Nil)
; # (and (Io: file) (> (Io: pid) 1))
; # (Io: file)
  %2 = getelementptr i8, i8* %1, i32 8
  %3 = bitcast i8* %2 to i8**
  %4 = load i8*, i8** %3
  %5 = icmp ne i8* %4, null
  br i1 %5, label %$3, label %$2
$3:
; # (Io: pid)
  %6 = getelementptr i8, i8* %1, i32 24
  %7 = bitcast i8* %6 to i32*
  %8 = load i32, i32* %7
; # (> (Io: pid) 1)
  %9 = icmp sgt i32 %8, 1
  br label %$2
$2:
  %10 = phi i1 [0, %$1], [%9, %$3] ; # ->
  br i1 %10, label %$4, label %$5
$4:
; # (Io: pid)
  %11 = getelementptr i8, i8* %1, i32 24
  %12 = bitcast i8* %11 to i32*
  %13 = load i32, i32* %12
; # (i64 (Io: pid))
  %14 = sext i32 %13 to i64
; # (cnt (i64 (Io: pid)))
  %15 = shl i64 %14, 4
  %16 = or i64 %15, 2
  br label %$6
$5:
  br label %$6
$6:
  %17 = phi i64 [%16, %$4], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$5] ; # ->
  ret i64 %17
}

define i64 @_Opid(i64) align 8 {
$1:
; # (let Io: (ioFrame (val $OutFrames)) (if (and (Io: file) (> (Io: p...
; # (val $OutFrames)
  %1 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 48) to i8**)
; # (if (and (Io: file) (> (Io: pid) 1)) (cnt (i64 (Io: pid))) $Nil)
; # (and (Io: file) (> (Io: pid) 1))
; # (Io: file)
  %2 = getelementptr i8, i8* %1, i32 8
  %3 = bitcast i8* %2 to i8**
  %4 = load i8*, i8** %3
  %5 = icmp ne i8* %4, null
  br i1 %5, label %$3, label %$2
$3:
; # (Io: pid)
  %6 = getelementptr i8, i8* %1, i32 24
  %7 = bitcast i8* %6 to i32*
  %8 = load i32, i32* %7
; # (> (Io: pid) 1)
  %9 = icmp sgt i32 %8, 1
  br label %$2
$2:
  %10 = phi i1 [0, %$1], [%9, %$3] ; # ->
  br i1 %10, label %$4, label %$5
$4:
; # (Io: pid)
  %11 = getelementptr i8, i8* %1, i32 24
  %12 = bitcast i8* %11 to i32*
  %13 = load i32, i32* %12
; # (i64 (Io: pid))
  %14 = sext i32 %13 to i64
; # (cnt (i64 (Io: pid)))
  %15 = shl i64 %14, 4
  %16 = or i64 %15, 2
  br label %$6
$5:
  br label %$6
$6:
  %17 = phi i64 [%16, %$4], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$5] ; # ->
  ret i64 %17
}

define i64 @_Kill(i64) align 8 {
$1:
; # (let (X (cdr Exe) Pid (i32 (evCnt Exe X))) (if (kill Pid (if (ato...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (evCnt Exe X)
  %4 = call i64 @evCnt(i64 %0, i64 %3)
; # (i32 (evCnt Exe X))
  %5 = trunc i64 %4 to i32
; # (if (kill Pid (if (atom (shift X)) (val SIGTERM Sig) (i32 (evCnt ...
; # (if (atom (shift X)) (val SIGTERM Sig) (i32 (evCnt Exe X)))
; # (shift X)
  %6 = inttoptr i64 %3 to i64*
  %7 = getelementptr i64, i64* %6, i32 1
  %8 = load i64, i64* %7
; # (atom (shift X))
  %9 = and i64 %8, 15
  %10 = icmp ne i64 %9, 0
  br i1 %10, label %$2, label %$3
$2:
  %11 = phi i64 [%8, %$1] ; # X
; # (val SIGTERM Sig)
  %12 = getelementptr i32, i32* @Sig, i32 6
  %13 = load i32, i32* %12
  br label %$4
$3:
  %14 = phi i64 [%8, %$1] ; # X
; # (evCnt Exe X)
  %15 = call i64 @evCnt(i64 %0, i64 %14)
; # (i32 (evCnt Exe X))
  %16 = trunc i64 %15 to i32
  br label %$4
$4:
  %17 = phi i64 [%11, %$2], [%14, %$3] ; # X
  %18 = phi i32 [%13, %$2], [%16, %$3] ; # ->
; # (kill Pid (if (atom (shift X)) (val SIGTERM Sig) (i32 (evCnt Exe ...
  %19 = call i32 @kill(i32 %5, i32 %18)
  %20 = icmp ne i32 %19, 0
  br i1 %20, label %$5, label %$6
$5:
  %21 = phi i64 [%17, %$4] ; # X
  br label %$7
$6:
  %22 = phi i64 [%17, %$4] ; # X
  br label %$7
$7:
  %23 = phi i64 [%21, %$5], [%22, %$6] ; # X
  %24 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$5], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$6] ; # ->
  ret i64 %24
}

define i64 @_Fork(i64) align 8 {
$1:
; # (if (forkLisp Exe) (cnt (i64 @)) $Nil)
; # (forkLisp Exe)
  %1 = call i32 @forkLisp(i64 %0)
  %2 = icmp ne i32 %1, 0
  br i1 %2, label %$2, label %$3
$2:
; # (i64 @)
  %3 = sext i32 %1 to i64
; # (cnt (i64 @))
  %4 = shl i64 %3, 4
  %5 = or i64 %4, 2
  br label %$4
$3:
  br label %$4
$4:
  %6 = phi i64 [%5, %$2], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$3] ; # ->
  ret i64 %6
}

define i64 @_Detach(i64) align 8 {
$1:
; # (prog1 (val $PPid) (unless (nil? @) (set $PPid $Nil) (close (val ...
; # (val $PPid)
  %1 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 216) to i64) to i64*
  %2 = load i64, i64* %1
; # (unless (nil? @) (set $PPid $Nil) (close (val $Tell)) (set $Tell ...
; # (nil? @)
  %3 = icmp eq i64 %2, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %3, label %$3, label %$2
$2:
; # (set $PPid $Nil)
  %4 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 216) to i64) to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %4
; # (val $Tell)
  %5 = load i32, i32* @$Tell
; # (close (val $Tell))
  %6 = call i32 @close(i32 %5)
; # (set $Tell 0)
  store i32 0, i32* @$Tell
; # (let H (val $Hear) (close H) (closeInFile H) (closeOutFile H))
; # (val $Hear)
  %7 = load i32, i32* @$Hear
; # (close H)
  %8 = call i32 @close(i32 %7)
; # (closeInFile H)
  call void @closeInFile(i32 %7)
; # (closeOutFile H)
  call void @closeOutFile(i32 %7)
; # (set $Hear 0)
  store i32 0, i32* @$Hear
; # (val $Mic)
  %9 = load i32, i32* @$Mic
; # (close (val $Mic))
  %10 = call i32 @close(i32 %9)
; # (set $Mic 0)
  store i32 0, i32* @$Mic
; # (set $Slot 0)
  store i32 0, i32* @$Slot
; # (setsid)
  %11 = call i32 @setsid()
  br label %$3
$3:
  ret i64 %2
}

define i64 @_Bye(i64) align 8 {
$1:
; # (if (nil? (eval (cadr Exe))) 0 (i32 (xCnt Exe @)))
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (nil? (eval (cadr Exe)))
  %14 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %14, label %$7, label %$8
$7:
  br label %$9
$8:
; # (xCnt Exe @)
  %15 = call i64 @xCnt(i64 %0, i64 %13)
; # (i32 (xCnt Exe @))
  %16 = trunc i64 %15 to i32
  br label %$9
$9:
  %17 = phi i32 [0, %$7], [%16, %$8] ; # ->
; # (bye (if (nil? (eval (cadr Exe))) 0 (i32 (xCnt Exe @))))
  call void @bye(i32 %17)
  unreachable
}

define void @makeErr(i64) align 8 {
$1:
; # (err Exe 0 ($ "Not making") null)
  call void @err(i64 %0, i64 0, i8* bitcast ([11 x i8]* @$88 to i8*), i8* null)
  unreachable
}

define i64 @_Car(i64) align 8 {
$1:
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (chkA (eval (cadr Exe)))
  %14 = and i64 %13, 6
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$7, label %$8
$7:
  call void @varErr(i64 %0, i64 %13)
  unreachable
$8:
  %16 = inttoptr i64 %13 to i64*
  %17 = load i64, i64* %16
  ret i64 %17
}

define i64 @_Cdr(i64) align 8 {
$1:
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (chkD (eval (cadr Exe)))
  %14 = and i64 %13, 15
  %15 = icmp eq i64 %14, 0
  br i1 %15, label %$7, label %$8
$8:
  %16 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$7
$7:
  %17 = phi i1 [1, %$2], [%16, %$8] ; # ->
  br i1 %17, label %$10, label %$9
$9:
  call void @lstErr(i64 %0, i64 %13)
  unreachable
$10:
  %18 = inttoptr i64 %13 to i64*
  %19 = getelementptr i64, i64* %18, i32 1
  %20 = load i64, i64* %19
  ret i64 %20
}

define i64 @_Caar(i64) align 8 {
$1:
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (chkA (eval (cadr Exe)))
  %14 = and i64 %13, 6
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$7, label %$8
$7:
  call void @varErr(i64 %0, i64 %13)
  unreachable
$8:
  %16 = inttoptr i64 %13 to i64*
  %17 = load i64, i64* %16
; # (chkA (chkA (eval (cadr Exe))))
  %18 = and i64 %17, 6
  %19 = icmp ne i64 %18, 0
  br i1 %19, label %$9, label %$10
$9:
  call void @varErr(i64 %0, i64 %17)
  unreachable
$10:
  %20 = inttoptr i64 %17 to i64*
  %21 = load i64, i64* %20
  ret i64 %21
}

define i64 @_Cadr(i64) align 8 {
$1:
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (chkD (eval (cadr Exe)))
  %14 = and i64 %13, 15
  %15 = icmp eq i64 %14, 0
  br i1 %15, label %$7, label %$8
$8:
  %16 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$7
$7:
  %17 = phi i1 [1, %$2], [%16, %$8] ; # ->
  br i1 %17, label %$10, label %$9
$9:
  call void @lstErr(i64 %0, i64 %13)
  unreachable
$10:
  %18 = inttoptr i64 %13 to i64*
  %19 = getelementptr i64, i64* %18, i32 1
  %20 = load i64, i64* %19
; # (chkA (chkD (eval (cadr Exe))))
  %21 = and i64 %20, 6
  %22 = icmp ne i64 %21, 0
  br i1 %22, label %$11, label %$12
$11:
  call void @varErr(i64 %0, i64 %20)
  unreachable
$12:
  %23 = inttoptr i64 %20 to i64*
  %24 = load i64, i64* %23
  ret i64 %24
}

define i64 @_Cdar(i64) align 8 {
$1:
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (chkA (eval (cadr Exe)))
  %14 = and i64 %13, 6
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$7, label %$8
$7:
  call void @varErr(i64 %0, i64 %13)
  unreachable
$8:
  %16 = inttoptr i64 %13 to i64*
  %17 = load i64, i64* %16
; # (chkD (chkA (eval (cadr Exe))))
  %18 = and i64 %17, 15
  %19 = icmp eq i64 %18, 0
  br i1 %19, label %$9, label %$10
$10:
  %20 = icmp eq i64 %17, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$9
$9:
  %21 = phi i1 [1, %$8], [%20, %$10] ; # ->
  br i1 %21, label %$12, label %$11
$11:
  call void @lstErr(i64 %0, i64 %17)
  unreachable
$12:
  %22 = inttoptr i64 %17 to i64*
  %23 = getelementptr i64, i64* %22, i32 1
  %24 = load i64, i64* %23
  ret i64 %24
}

define i64 @_Cddr(i64) align 8 {
$1:
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (chkD (eval (cadr Exe)))
  %14 = and i64 %13, 15
  %15 = icmp eq i64 %14, 0
  br i1 %15, label %$7, label %$8
$8:
  %16 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$7
$7:
  %17 = phi i1 [1, %$2], [%16, %$8] ; # ->
  br i1 %17, label %$10, label %$9
$9:
  call void @lstErr(i64 %0, i64 %13)
  unreachable
$10:
  %18 = inttoptr i64 %13 to i64*
  %19 = getelementptr i64, i64* %18, i32 1
  %20 = load i64, i64* %19
; # (chkD (chkD (eval (cadr Exe))))
  %21 = and i64 %20, 15
  %22 = icmp eq i64 %21, 0
  br i1 %22, label %$11, label %$12
$12:
  %23 = icmp eq i64 %20, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$11
$11:
  %24 = phi i1 [1, %$10], [%23, %$12] ; # ->
  br i1 %24, label %$14, label %$13
$13:
  call void @lstErr(i64 %0, i64 %20)
  unreachable
$14:
  %25 = inttoptr i64 %20 to i64*
  %26 = getelementptr i64, i64* %25, i32 1
  %27 = load i64, i64* %26
  ret i64 %27
}

define i64 @_Caaar(i64) align 8 {
$1:
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (chkA (eval (cadr Exe)))
  %14 = and i64 %13, 6
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$7, label %$8
$7:
  call void @varErr(i64 %0, i64 %13)
  unreachable
$8:
  %16 = inttoptr i64 %13 to i64*
  %17 = load i64, i64* %16
; # (chkA (chkA (eval (cadr Exe))))
  %18 = and i64 %17, 6
  %19 = icmp ne i64 %18, 0
  br i1 %19, label %$9, label %$10
$9:
  call void @varErr(i64 %0, i64 %17)
  unreachable
$10:
  %20 = inttoptr i64 %17 to i64*
  %21 = load i64, i64* %20
; # (chkA (chkA (chkA (eval (cadr Exe)))))
  %22 = and i64 %21, 6
  %23 = icmp ne i64 %22, 0
  br i1 %23, label %$11, label %$12
$11:
  call void @varErr(i64 %0, i64 %21)
  unreachable
$12:
  %24 = inttoptr i64 %21 to i64*
  %25 = load i64, i64* %24
  ret i64 %25
}

define i64 @_Caadr(i64) align 8 {
$1:
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (chkD (eval (cadr Exe)))
  %14 = and i64 %13, 15
  %15 = icmp eq i64 %14, 0
  br i1 %15, label %$7, label %$8
$8:
  %16 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$7
$7:
  %17 = phi i1 [1, %$2], [%16, %$8] ; # ->
  br i1 %17, label %$10, label %$9
$9:
  call void @lstErr(i64 %0, i64 %13)
  unreachable
$10:
  %18 = inttoptr i64 %13 to i64*
  %19 = getelementptr i64, i64* %18, i32 1
  %20 = load i64, i64* %19
; # (chkA (chkD (eval (cadr Exe))))
  %21 = and i64 %20, 6
  %22 = icmp ne i64 %21, 0
  br i1 %22, label %$11, label %$12
$11:
  call void @varErr(i64 %0, i64 %20)
  unreachable
$12:
  %23 = inttoptr i64 %20 to i64*
  %24 = load i64, i64* %23
; # (chkA (chkA (chkD (eval (cadr Exe)))))
  %25 = and i64 %24, 6
  %26 = icmp ne i64 %25, 0
  br i1 %26, label %$13, label %$14
$13:
  call void @varErr(i64 %0, i64 %24)
  unreachable
$14:
  %27 = inttoptr i64 %24 to i64*
  %28 = load i64, i64* %27
  ret i64 %28
}

define i64 @_Cadar(i64) align 8 {
$1:
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (chkA (eval (cadr Exe)))
  %14 = and i64 %13, 6
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$7, label %$8
$7:
  call void @varErr(i64 %0, i64 %13)
  unreachable
$8:
  %16 = inttoptr i64 %13 to i64*
  %17 = load i64, i64* %16
; # (chkD (chkA (eval (cadr Exe))))
  %18 = and i64 %17, 15
  %19 = icmp eq i64 %18, 0
  br i1 %19, label %$9, label %$10
$10:
  %20 = icmp eq i64 %17, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$9
$9:
  %21 = phi i1 [1, %$8], [%20, %$10] ; # ->
  br i1 %21, label %$12, label %$11
$11:
  call void @lstErr(i64 %0, i64 %17)
  unreachable
$12:
  %22 = inttoptr i64 %17 to i64*
  %23 = getelementptr i64, i64* %22, i32 1
  %24 = load i64, i64* %23
; # (chkA (chkD (chkA (eval (cadr Exe)))))
  %25 = and i64 %24, 6
  %26 = icmp ne i64 %25, 0
  br i1 %26, label %$13, label %$14
$13:
  call void @varErr(i64 %0, i64 %24)
  unreachable
$14:
  %27 = inttoptr i64 %24 to i64*
  %28 = load i64, i64* %27
  ret i64 %28
}

define i64 @_Caddr(i64) align 8 {
$1:
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (chkD (eval (cadr Exe)))
  %14 = and i64 %13, 15
  %15 = icmp eq i64 %14, 0
  br i1 %15, label %$7, label %$8
$8:
  %16 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$7
$7:
  %17 = phi i1 [1, %$2], [%16, %$8] ; # ->
  br i1 %17, label %$10, label %$9
$9:
  call void @lstErr(i64 %0, i64 %13)
  unreachable
$10:
  %18 = inttoptr i64 %13 to i64*
  %19 = getelementptr i64, i64* %18, i32 1
  %20 = load i64, i64* %19
; # (chkD (chkD (eval (cadr Exe))))
  %21 = and i64 %20, 15
  %22 = icmp eq i64 %21, 0
  br i1 %22, label %$11, label %$12
$12:
  %23 = icmp eq i64 %20, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$11
$11:
  %24 = phi i1 [1, %$10], [%23, %$12] ; # ->
  br i1 %24, label %$14, label %$13
$13:
  call void @lstErr(i64 %0, i64 %20)
  unreachable
$14:
  %25 = inttoptr i64 %20 to i64*
  %26 = getelementptr i64, i64* %25, i32 1
  %27 = load i64, i64* %26
; # (chkA (chkD (chkD (eval (cadr Exe)))))
  %28 = and i64 %27, 6
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %$15, label %$16
$15:
  call void @varErr(i64 %0, i64 %27)
  unreachable
$16:
  %30 = inttoptr i64 %27 to i64*
  %31 = load i64, i64* %30
  ret i64 %31
}

define i64 @_Cdaar(i64) align 8 {
$1:
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (chkA (eval (cadr Exe)))
  %14 = and i64 %13, 6
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$7, label %$8
$7:
  call void @varErr(i64 %0, i64 %13)
  unreachable
$8:
  %16 = inttoptr i64 %13 to i64*
  %17 = load i64, i64* %16
; # (chkA (chkA (eval (cadr Exe))))
  %18 = and i64 %17, 6
  %19 = icmp ne i64 %18, 0
  br i1 %19, label %$9, label %$10
$9:
  call void @varErr(i64 %0, i64 %17)
  unreachable
$10:
  %20 = inttoptr i64 %17 to i64*
  %21 = load i64, i64* %20
; # (chkD (chkA (chkA (eval (cadr Exe)))))
  %22 = and i64 %21, 15
  %23 = icmp eq i64 %22, 0
  br i1 %23, label %$11, label %$12
$12:
  %24 = icmp eq i64 %21, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$11
$11:
  %25 = phi i1 [1, %$10], [%24, %$12] ; # ->
  br i1 %25, label %$14, label %$13
$13:
  call void @lstErr(i64 %0, i64 %21)
  unreachable
$14:
  %26 = inttoptr i64 %21 to i64*
  %27 = getelementptr i64, i64* %26, i32 1
  %28 = load i64, i64* %27
  ret i64 %28
}

define i64 @_Cdadr(i64) align 8 {
$1:
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (chkD (eval (cadr Exe)))
  %14 = and i64 %13, 15
  %15 = icmp eq i64 %14, 0
  br i1 %15, label %$7, label %$8
$8:
  %16 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$7
$7:
  %17 = phi i1 [1, %$2], [%16, %$8] ; # ->
  br i1 %17, label %$10, label %$9
$9:
  call void @lstErr(i64 %0, i64 %13)
  unreachable
$10:
  %18 = inttoptr i64 %13 to i64*
  %19 = getelementptr i64, i64* %18, i32 1
  %20 = load i64, i64* %19
; # (chkA (chkD (eval (cadr Exe))))
  %21 = and i64 %20, 6
  %22 = icmp ne i64 %21, 0
  br i1 %22, label %$11, label %$12
$11:
  call void @varErr(i64 %0, i64 %20)
  unreachable
$12:
  %23 = inttoptr i64 %20 to i64*
  %24 = load i64, i64* %23
; # (chkD (chkA (chkD (eval (cadr Exe)))))
  %25 = and i64 %24, 15
  %26 = icmp eq i64 %25, 0
  br i1 %26, label %$13, label %$14
$14:
  %27 = icmp eq i64 %24, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$13
$13:
  %28 = phi i1 [1, %$12], [%27, %$14] ; # ->
  br i1 %28, label %$16, label %$15
$15:
  call void @lstErr(i64 %0, i64 %24)
  unreachable
$16:
  %29 = inttoptr i64 %24 to i64*
  %30 = getelementptr i64, i64* %29, i32 1
  %31 = load i64, i64* %30
  ret i64 %31
}

define i64 @_Cddar(i64) align 8 {
$1:
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (chkA (eval (cadr Exe)))
  %14 = and i64 %13, 6
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$7, label %$8
$7:
  call void @varErr(i64 %0, i64 %13)
  unreachable
$8:
  %16 = inttoptr i64 %13 to i64*
  %17 = load i64, i64* %16
; # (chkD (chkA (eval (cadr Exe))))
  %18 = and i64 %17, 15
  %19 = icmp eq i64 %18, 0
  br i1 %19, label %$9, label %$10
$10:
  %20 = icmp eq i64 %17, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$9
$9:
  %21 = phi i1 [1, %$8], [%20, %$10] ; # ->
  br i1 %21, label %$12, label %$11
$11:
  call void @lstErr(i64 %0, i64 %17)
  unreachable
$12:
  %22 = inttoptr i64 %17 to i64*
  %23 = getelementptr i64, i64* %22, i32 1
  %24 = load i64, i64* %23
; # (chkD (chkD (chkA (eval (cadr Exe)))))
  %25 = and i64 %24, 15
  %26 = icmp eq i64 %25, 0
  br i1 %26, label %$13, label %$14
$14:
  %27 = icmp eq i64 %24, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$13
$13:
  %28 = phi i1 [1, %$12], [%27, %$14] ; # ->
  br i1 %28, label %$16, label %$15
$15:
  call void @lstErr(i64 %0, i64 %24)
  unreachable
$16:
  %29 = inttoptr i64 %24 to i64*
  %30 = getelementptr i64, i64* %29, i32 1
  %31 = load i64, i64* %30
  ret i64 %31
}

define i64 @_Cdddr(i64) align 8 {
$1:
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (chkD (eval (cadr Exe)))
  %14 = and i64 %13, 15
  %15 = icmp eq i64 %14, 0
  br i1 %15, label %$7, label %$8
$8:
  %16 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$7
$7:
  %17 = phi i1 [1, %$2], [%16, %$8] ; # ->
  br i1 %17, label %$10, label %$9
$9:
  call void @lstErr(i64 %0, i64 %13)
  unreachable
$10:
  %18 = inttoptr i64 %13 to i64*
  %19 = getelementptr i64, i64* %18, i32 1
  %20 = load i64, i64* %19
; # (chkD (chkD (eval (cadr Exe))))
  %21 = and i64 %20, 15
  %22 = icmp eq i64 %21, 0
  br i1 %22, label %$11, label %$12
$12:
  %23 = icmp eq i64 %20, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$11
$11:
  %24 = phi i1 [1, %$10], [%23, %$12] ; # ->
  br i1 %24, label %$14, label %$13
$13:
  call void @lstErr(i64 %0, i64 %20)
  unreachable
$14:
  %25 = inttoptr i64 %20 to i64*
  %26 = getelementptr i64, i64* %25, i32 1
  %27 = load i64, i64* %26
; # (chkD (chkD (chkD (eval (cadr Exe)))))
  %28 = and i64 %27, 15
  %29 = icmp eq i64 %28, 0
  br i1 %29, label %$15, label %$16
$16:
  %30 = icmp eq i64 %27, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$15
$15:
  %31 = phi i1 [1, %$14], [%30, %$16] ; # ->
  br i1 %31, label %$18, label %$17
$17:
  call void @lstErr(i64 %0, i64 %27)
  unreachable
$18:
  %32 = inttoptr i64 %27 to i64*
  %33 = getelementptr i64, i64* %32, i32 1
  %34 = load i64, i64* %33
  ret i64 %34
}

define i64 @_Caaaar(i64) align 8 {
$1:
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (chkA (eval (cadr Exe)))
  %14 = and i64 %13, 6
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$7, label %$8
$7:
  call void @varErr(i64 %0, i64 %13)
  unreachable
$8:
  %16 = inttoptr i64 %13 to i64*
  %17 = load i64, i64* %16
; # (chkA (chkA (eval (cadr Exe))))
  %18 = and i64 %17, 6
  %19 = icmp ne i64 %18, 0
  br i1 %19, label %$9, label %$10
$9:
  call void @varErr(i64 %0, i64 %17)
  unreachable
$10:
  %20 = inttoptr i64 %17 to i64*
  %21 = load i64, i64* %20
; # (chkA (chkA (chkA (eval (cadr Exe)))))
  %22 = and i64 %21, 6
  %23 = icmp ne i64 %22, 0
  br i1 %23, label %$11, label %$12
$11:
  call void @varErr(i64 %0, i64 %21)
  unreachable
$12:
  %24 = inttoptr i64 %21 to i64*
  %25 = load i64, i64* %24
; # (chkA (chkA (chkA (chkA (eval (cadr Exe))))))
  %26 = and i64 %25, 6
  %27 = icmp ne i64 %26, 0
  br i1 %27, label %$13, label %$14
$13:
  call void @varErr(i64 %0, i64 %25)
  unreachable
$14:
  %28 = inttoptr i64 %25 to i64*
  %29 = load i64, i64* %28
  ret i64 %29
}

define i64 @_Caaadr(i64) align 8 {
$1:
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (chkD (eval (cadr Exe)))
  %14 = and i64 %13, 15
  %15 = icmp eq i64 %14, 0
  br i1 %15, label %$7, label %$8
$8:
  %16 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$7
$7:
  %17 = phi i1 [1, %$2], [%16, %$8] ; # ->
  br i1 %17, label %$10, label %$9
$9:
  call void @lstErr(i64 %0, i64 %13)
  unreachable
$10:
  %18 = inttoptr i64 %13 to i64*
  %19 = getelementptr i64, i64* %18, i32 1
  %20 = load i64, i64* %19
; # (chkA (chkD (eval (cadr Exe))))
  %21 = and i64 %20, 6
  %22 = icmp ne i64 %21, 0
  br i1 %22, label %$11, label %$12
$11:
  call void @varErr(i64 %0, i64 %20)
  unreachable
$12:
  %23 = inttoptr i64 %20 to i64*
  %24 = load i64, i64* %23
; # (chkA (chkA (chkD (eval (cadr Exe)))))
  %25 = and i64 %24, 6
  %26 = icmp ne i64 %25, 0
  br i1 %26, label %$13, label %$14
$13:
  call void @varErr(i64 %0, i64 %24)
  unreachable
$14:
  %27 = inttoptr i64 %24 to i64*
  %28 = load i64, i64* %27
; # (chkA (chkA (chkA (chkD (eval (cadr Exe))))))
  %29 = and i64 %28, 6
  %30 = icmp ne i64 %29, 0
  br i1 %30, label %$15, label %$16
$15:
  call void @varErr(i64 %0, i64 %28)
  unreachable
$16:
  %31 = inttoptr i64 %28 to i64*
  %32 = load i64, i64* %31
  ret i64 %32
}

define i64 @_Caadar(i64) align 8 {
$1:
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (chkA (eval (cadr Exe)))
  %14 = and i64 %13, 6
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$7, label %$8
$7:
  call void @varErr(i64 %0, i64 %13)
  unreachable
$8:
  %16 = inttoptr i64 %13 to i64*
  %17 = load i64, i64* %16
; # (chkD (chkA (eval (cadr Exe))))
  %18 = and i64 %17, 15
  %19 = icmp eq i64 %18, 0
  br i1 %19, label %$9, label %$10
$10:
  %20 = icmp eq i64 %17, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$9
$9:
  %21 = phi i1 [1, %$8], [%20, %$10] ; # ->
  br i1 %21, label %$12, label %$11
$11:
  call void @lstErr(i64 %0, i64 %17)
  unreachable
$12:
  %22 = inttoptr i64 %17 to i64*
  %23 = getelementptr i64, i64* %22, i32 1
  %24 = load i64, i64* %23
; # (chkA (chkD (chkA (eval (cadr Exe)))))
  %25 = and i64 %24, 6
  %26 = icmp ne i64 %25, 0
  br i1 %26, label %$13, label %$14
$13:
  call void @varErr(i64 %0, i64 %24)
  unreachable
$14:
  %27 = inttoptr i64 %24 to i64*
  %28 = load i64, i64* %27
; # (chkA (chkA (chkD (chkA (eval (cadr Exe))))))
  %29 = and i64 %28, 6
  %30 = icmp ne i64 %29, 0
  br i1 %30, label %$15, label %$16
$15:
  call void @varErr(i64 %0, i64 %28)
  unreachable
$16:
  %31 = inttoptr i64 %28 to i64*
  %32 = load i64, i64* %31
  ret i64 %32
}

define i64 @_Caaddr(i64) align 8 {
$1:
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (chkD (eval (cadr Exe)))
  %14 = and i64 %13, 15
  %15 = icmp eq i64 %14, 0
  br i1 %15, label %$7, label %$8
$8:
  %16 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$7
$7:
  %17 = phi i1 [1, %$2], [%16, %$8] ; # ->
  br i1 %17, label %$10, label %$9
$9:
  call void @lstErr(i64 %0, i64 %13)
  unreachable
$10:
  %18 = inttoptr i64 %13 to i64*
  %19 = getelementptr i64, i64* %18, i32 1
  %20 = load i64, i64* %19
; # (chkD (chkD (eval (cadr Exe))))
  %21 = and i64 %20, 15
  %22 = icmp eq i64 %21, 0
  br i1 %22, label %$11, label %$12
$12:
  %23 = icmp eq i64 %20, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$11
$11:
  %24 = phi i1 [1, %$10], [%23, %$12] ; # ->
  br i1 %24, label %$14, label %$13
$13:
  call void @lstErr(i64 %0, i64 %20)
  unreachable
$14:
  %25 = inttoptr i64 %20 to i64*
  %26 = getelementptr i64, i64* %25, i32 1
  %27 = load i64, i64* %26
; # (chkA (chkD (chkD (eval (cadr Exe)))))
  %28 = and i64 %27, 6
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %$15, label %$16
$15:
  call void @varErr(i64 %0, i64 %27)
  unreachable
$16:
  %30 = inttoptr i64 %27 to i64*
  %31 = load i64, i64* %30
; # (chkA (chkA (chkD (chkD (eval (cadr Exe))))))
  %32 = and i64 %31, 6
  %33 = icmp ne i64 %32, 0
  br i1 %33, label %$17, label %$18
$17:
  call void @varErr(i64 %0, i64 %31)
  unreachable
$18:
  %34 = inttoptr i64 %31 to i64*
  %35 = load i64, i64* %34
  ret i64 %35
}

define i64 @_Cadaar(i64) align 8 {
$1:
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (chkA (eval (cadr Exe)))
  %14 = and i64 %13, 6
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$7, label %$8
$7:
  call void @varErr(i64 %0, i64 %13)
  unreachable
$8:
  %16 = inttoptr i64 %13 to i64*
  %17 = load i64, i64* %16
; # (chkA (chkA (eval (cadr Exe))))
  %18 = and i64 %17, 6
  %19 = icmp ne i64 %18, 0
  br i1 %19, label %$9, label %$10
$9:
  call void @varErr(i64 %0, i64 %17)
  unreachable
$10:
  %20 = inttoptr i64 %17 to i64*
  %21 = load i64, i64* %20
; # (chkD (chkA (chkA (eval (cadr Exe)))))
  %22 = and i64 %21, 15
  %23 = icmp eq i64 %22, 0
  br i1 %23, label %$11, label %$12
$12:
  %24 = icmp eq i64 %21, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$11
$11:
  %25 = phi i1 [1, %$10], [%24, %$12] ; # ->
  br i1 %25, label %$14, label %$13
$13:
  call void @lstErr(i64 %0, i64 %21)
  unreachable
$14:
  %26 = inttoptr i64 %21 to i64*
  %27 = getelementptr i64, i64* %26, i32 1
  %28 = load i64, i64* %27
; # (chkA (chkD (chkA (chkA (eval (cadr Exe))))))
  %29 = and i64 %28, 6
  %30 = icmp ne i64 %29, 0
  br i1 %30, label %$15, label %$16
$15:
  call void @varErr(i64 %0, i64 %28)
  unreachable
$16:
  %31 = inttoptr i64 %28 to i64*
  %32 = load i64, i64* %31
  ret i64 %32
}

define i64 @_Cadadr(i64) align 8 {
$1:
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (chkD (eval (cadr Exe)))
  %14 = and i64 %13, 15
  %15 = icmp eq i64 %14, 0
  br i1 %15, label %$7, label %$8
$8:
  %16 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$7
$7:
  %17 = phi i1 [1, %$2], [%16, %$8] ; # ->
  br i1 %17, label %$10, label %$9
$9:
  call void @lstErr(i64 %0, i64 %13)
  unreachable
$10:
  %18 = inttoptr i64 %13 to i64*
  %19 = getelementptr i64, i64* %18, i32 1
  %20 = load i64, i64* %19
; # (chkA (chkD (eval (cadr Exe))))
  %21 = and i64 %20, 6
  %22 = icmp ne i64 %21, 0
  br i1 %22, label %$11, label %$12
$11:
  call void @varErr(i64 %0, i64 %20)
  unreachable
$12:
  %23 = inttoptr i64 %20 to i64*
  %24 = load i64, i64* %23
; # (chkD (chkA (chkD (eval (cadr Exe)))))
  %25 = and i64 %24, 15
  %26 = icmp eq i64 %25, 0
  br i1 %26, label %$13, label %$14
$14:
  %27 = icmp eq i64 %24, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$13
$13:
  %28 = phi i1 [1, %$12], [%27, %$14] ; # ->
  br i1 %28, label %$16, label %$15
$15:
  call void @lstErr(i64 %0, i64 %24)
  unreachable
$16:
  %29 = inttoptr i64 %24 to i64*
  %30 = getelementptr i64, i64* %29, i32 1
  %31 = load i64, i64* %30
; # (chkA (chkD (chkA (chkD (eval (cadr Exe))))))
  %32 = and i64 %31, 6
  %33 = icmp ne i64 %32, 0
  br i1 %33, label %$17, label %$18
$17:
  call void @varErr(i64 %0, i64 %31)
  unreachable
$18:
  %34 = inttoptr i64 %31 to i64*
  %35 = load i64, i64* %34
  ret i64 %35
}

define i64 @_Caddar(i64) align 8 {
$1:
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (chkA (eval (cadr Exe)))
  %14 = and i64 %13, 6
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$7, label %$8
$7:
  call void @varErr(i64 %0, i64 %13)
  unreachable
$8:
  %16 = inttoptr i64 %13 to i64*
  %17 = load i64, i64* %16
; # (chkD (chkA (eval (cadr Exe))))
  %18 = and i64 %17, 15
  %19 = icmp eq i64 %18, 0
  br i1 %19, label %$9, label %$10
$10:
  %20 = icmp eq i64 %17, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$9
$9:
  %21 = phi i1 [1, %$8], [%20, %$10] ; # ->
  br i1 %21, label %$12, label %$11
$11:
  call void @lstErr(i64 %0, i64 %17)
  unreachable
$12:
  %22 = inttoptr i64 %17 to i64*
  %23 = getelementptr i64, i64* %22, i32 1
  %24 = load i64, i64* %23
; # (chkD (chkD (chkA (eval (cadr Exe)))))
  %25 = and i64 %24, 15
  %26 = icmp eq i64 %25, 0
  br i1 %26, label %$13, label %$14
$14:
  %27 = icmp eq i64 %24, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$13
$13:
  %28 = phi i1 [1, %$12], [%27, %$14] ; # ->
  br i1 %28, label %$16, label %$15
$15:
  call void @lstErr(i64 %0, i64 %24)
  unreachable
$16:
  %29 = inttoptr i64 %24 to i64*
  %30 = getelementptr i64, i64* %29, i32 1
  %31 = load i64, i64* %30
; # (chkA (chkD (chkD (chkA (eval (cadr Exe))))))
  %32 = and i64 %31, 6
  %33 = icmp ne i64 %32, 0
  br i1 %33, label %$17, label %$18
$17:
  call void @varErr(i64 %0, i64 %31)
  unreachable
$18:
  %34 = inttoptr i64 %31 to i64*
  %35 = load i64, i64* %34
  ret i64 %35
}

define i64 @_Cadddr(i64) align 8 {
$1:
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (chkD (eval (cadr Exe)))
  %14 = and i64 %13, 15
  %15 = icmp eq i64 %14, 0
  br i1 %15, label %$7, label %$8
$8:
  %16 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$7
$7:
  %17 = phi i1 [1, %$2], [%16, %$8] ; # ->
  br i1 %17, label %$10, label %$9
$9:
  call void @lstErr(i64 %0, i64 %13)
  unreachable
$10:
  %18 = inttoptr i64 %13 to i64*
  %19 = getelementptr i64, i64* %18, i32 1
  %20 = load i64, i64* %19
; # (chkD (chkD (eval (cadr Exe))))
  %21 = and i64 %20, 15
  %22 = icmp eq i64 %21, 0
  br i1 %22, label %$11, label %$12
$12:
  %23 = icmp eq i64 %20, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$11
$11:
  %24 = phi i1 [1, %$10], [%23, %$12] ; # ->
  br i1 %24, label %$14, label %$13
$13:
  call void @lstErr(i64 %0, i64 %20)
  unreachable
$14:
  %25 = inttoptr i64 %20 to i64*
  %26 = getelementptr i64, i64* %25, i32 1
  %27 = load i64, i64* %26
; # (chkD (chkD (chkD (eval (cadr Exe)))))
  %28 = and i64 %27, 15
  %29 = icmp eq i64 %28, 0
  br i1 %29, label %$15, label %$16
$16:
  %30 = icmp eq i64 %27, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$15
$15:
  %31 = phi i1 [1, %$14], [%30, %$16] ; # ->
  br i1 %31, label %$18, label %$17
$17:
  call void @lstErr(i64 %0, i64 %27)
  unreachable
$18:
  %32 = inttoptr i64 %27 to i64*
  %33 = getelementptr i64, i64* %32, i32 1
  %34 = load i64, i64* %33
; # (chkA (chkD (chkD (chkD (eval (cadr Exe))))))
  %35 = and i64 %34, 6
  %36 = icmp ne i64 %35, 0
  br i1 %36, label %$19, label %$20
$19:
  call void @varErr(i64 %0, i64 %34)
  unreachable
$20:
  %37 = inttoptr i64 %34 to i64*
  %38 = load i64, i64* %37
  ret i64 %38
}

define i64 @_Cdaaar(i64) align 8 {
$1:
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (chkA (eval (cadr Exe)))
  %14 = and i64 %13, 6
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$7, label %$8
$7:
  call void @varErr(i64 %0, i64 %13)
  unreachable
$8:
  %16 = inttoptr i64 %13 to i64*
  %17 = load i64, i64* %16
; # (chkA (chkA (eval (cadr Exe))))
  %18 = and i64 %17, 6
  %19 = icmp ne i64 %18, 0
  br i1 %19, label %$9, label %$10
$9:
  call void @varErr(i64 %0, i64 %17)
  unreachable
$10:
  %20 = inttoptr i64 %17 to i64*
  %21 = load i64, i64* %20
; # (chkA (chkA (chkA (eval (cadr Exe)))))
  %22 = and i64 %21, 6
  %23 = icmp ne i64 %22, 0
  br i1 %23, label %$11, label %$12
$11:
  call void @varErr(i64 %0, i64 %21)
  unreachable
$12:
  %24 = inttoptr i64 %21 to i64*
  %25 = load i64, i64* %24
; # (chkD (chkA (chkA (chkA (eval (cadr Exe))))))
  %26 = and i64 %25, 15
  %27 = icmp eq i64 %26, 0
  br i1 %27, label %$13, label %$14
$14:
  %28 = icmp eq i64 %25, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$13
$13:
  %29 = phi i1 [1, %$12], [%28, %$14] ; # ->
  br i1 %29, label %$16, label %$15
$15:
  call void @lstErr(i64 %0, i64 %25)
  unreachable
$16:
  %30 = inttoptr i64 %25 to i64*
  %31 = getelementptr i64, i64* %30, i32 1
  %32 = load i64, i64* %31
  ret i64 %32
}

define i64 @_Cdaadr(i64) align 8 {
$1:
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (chkD (eval (cadr Exe)))
  %14 = and i64 %13, 15
  %15 = icmp eq i64 %14, 0
  br i1 %15, label %$7, label %$8
$8:
  %16 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$7
$7:
  %17 = phi i1 [1, %$2], [%16, %$8] ; # ->
  br i1 %17, label %$10, label %$9
$9:
  call void @lstErr(i64 %0, i64 %13)
  unreachable
$10:
  %18 = inttoptr i64 %13 to i64*
  %19 = getelementptr i64, i64* %18, i32 1
  %20 = load i64, i64* %19
; # (chkA (chkD (eval (cadr Exe))))
  %21 = and i64 %20, 6
  %22 = icmp ne i64 %21, 0
  br i1 %22, label %$11, label %$12
$11:
  call void @varErr(i64 %0, i64 %20)
  unreachable
$12:
  %23 = inttoptr i64 %20 to i64*
  %24 = load i64, i64* %23
; # (chkA (chkA (chkD (eval (cadr Exe)))))
  %25 = and i64 %24, 6
  %26 = icmp ne i64 %25, 0
  br i1 %26, label %$13, label %$14
$13:
  call void @varErr(i64 %0, i64 %24)
  unreachable
$14:
  %27 = inttoptr i64 %24 to i64*
  %28 = load i64, i64* %27
; # (chkD (chkA (chkA (chkD (eval (cadr Exe))))))
  %29 = and i64 %28, 15
  %30 = icmp eq i64 %29, 0
  br i1 %30, label %$15, label %$16
$16:
  %31 = icmp eq i64 %28, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$15
$15:
  %32 = phi i1 [1, %$14], [%31, %$16] ; # ->
  br i1 %32, label %$18, label %$17
$17:
  call void @lstErr(i64 %0, i64 %28)
  unreachable
$18:
  %33 = inttoptr i64 %28 to i64*
  %34 = getelementptr i64, i64* %33, i32 1
  %35 = load i64, i64* %34
  ret i64 %35
}

define i64 @_Cdadar(i64) align 8 {
$1:
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (chkA (eval (cadr Exe)))
  %14 = and i64 %13, 6
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$7, label %$8
$7:
  call void @varErr(i64 %0, i64 %13)
  unreachable
$8:
  %16 = inttoptr i64 %13 to i64*
  %17 = load i64, i64* %16
; # (chkD (chkA (eval (cadr Exe))))
  %18 = and i64 %17, 15
  %19 = icmp eq i64 %18, 0
  br i1 %19, label %$9, label %$10
$10:
  %20 = icmp eq i64 %17, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$9
$9:
  %21 = phi i1 [1, %$8], [%20, %$10] ; # ->
  br i1 %21, label %$12, label %$11
$11:
  call void @lstErr(i64 %0, i64 %17)
  unreachable
$12:
  %22 = inttoptr i64 %17 to i64*
  %23 = getelementptr i64, i64* %22, i32 1
  %24 = load i64, i64* %23
; # (chkA (chkD (chkA (eval (cadr Exe)))))
  %25 = and i64 %24, 6
  %26 = icmp ne i64 %25, 0
  br i1 %26, label %$13, label %$14
$13:
  call void @varErr(i64 %0, i64 %24)
  unreachable
$14:
  %27 = inttoptr i64 %24 to i64*
  %28 = load i64, i64* %27
; # (chkD (chkA (chkD (chkA (eval (cadr Exe))))))
  %29 = and i64 %28, 15
  %30 = icmp eq i64 %29, 0
  br i1 %30, label %$15, label %$16
$16:
  %31 = icmp eq i64 %28, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$15
$15:
  %32 = phi i1 [1, %$14], [%31, %$16] ; # ->
  br i1 %32, label %$18, label %$17
$17:
  call void @lstErr(i64 %0, i64 %28)
  unreachable
$18:
  %33 = inttoptr i64 %28 to i64*
  %34 = getelementptr i64, i64* %33, i32 1
  %35 = load i64, i64* %34
  ret i64 %35
}

define i64 @_Cdaddr(i64) align 8 {
$1:
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (chkD (eval (cadr Exe)))
  %14 = and i64 %13, 15
  %15 = icmp eq i64 %14, 0
  br i1 %15, label %$7, label %$8
$8:
  %16 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$7
$7:
  %17 = phi i1 [1, %$2], [%16, %$8] ; # ->
  br i1 %17, label %$10, label %$9
$9:
  call void @lstErr(i64 %0, i64 %13)
  unreachable
$10:
  %18 = inttoptr i64 %13 to i64*
  %19 = getelementptr i64, i64* %18, i32 1
  %20 = load i64, i64* %19
; # (chkD (chkD (eval (cadr Exe))))
  %21 = and i64 %20, 15
  %22 = icmp eq i64 %21, 0
  br i1 %22, label %$11, label %$12
$12:
  %23 = icmp eq i64 %20, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$11
$11:
  %24 = phi i1 [1, %$10], [%23, %$12] ; # ->
  br i1 %24, label %$14, label %$13
$13:
  call void @lstErr(i64 %0, i64 %20)
  unreachable
$14:
  %25 = inttoptr i64 %20 to i64*
  %26 = getelementptr i64, i64* %25, i32 1
  %27 = load i64, i64* %26
; # (chkA (chkD (chkD (eval (cadr Exe)))))
  %28 = and i64 %27, 6
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %$15, label %$16
$15:
  call void @varErr(i64 %0, i64 %27)
  unreachable
$16:
  %30 = inttoptr i64 %27 to i64*
  %31 = load i64, i64* %30
; # (chkD (chkA (chkD (chkD (eval (cadr Exe))))))
  %32 = and i64 %31, 15
  %33 = icmp eq i64 %32, 0
  br i1 %33, label %$17, label %$18
$18:
  %34 = icmp eq i64 %31, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$17
$17:
  %35 = phi i1 [1, %$16], [%34, %$18] ; # ->
  br i1 %35, label %$20, label %$19
$19:
  call void @lstErr(i64 %0, i64 %31)
  unreachable
$20:
  %36 = inttoptr i64 %31 to i64*
  %37 = getelementptr i64, i64* %36, i32 1
  %38 = load i64, i64* %37
  ret i64 %38
}

define i64 @_Cddaar(i64) align 8 {
$1:
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (chkA (eval (cadr Exe)))
  %14 = and i64 %13, 6
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$7, label %$8
$7:
  call void @varErr(i64 %0, i64 %13)
  unreachable
$8:
  %16 = inttoptr i64 %13 to i64*
  %17 = load i64, i64* %16
; # (chkA (chkA (eval (cadr Exe))))
  %18 = and i64 %17, 6
  %19 = icmp ne i64 %18, 0
  br i1 %19, label %$9, label %$10
$9:
  call void @varErr(i64 %0, i64 %17)
  unreachable
$10:
  %20 = inttoptr i64 %17 to i64*
  %21 = load i64, i64* %20
; # (chkD (chkA (chkA (eval (cadr Exe)))))
  %22 = and i64 %21, 15
  %23 = icmp eq i64 %22, 0
  br i1 %23, label %$11, label %$12
$12:
  %24 = icmp eq i64 %21, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$11
$11:
  %25 = phi i1 [1, %$10], [%24, %$12] ; # ->
  br i1 %25, label %$14, label %$13
$13:
  call void @lstErr(i64 %0, i64 %21)
  unreachable
$14:
  %26 = inttoptr i64 %21 to i64*
  %27 = getelementptr i64, i64* %26, i32 1
  %28 = load i64, i64* %27
; # (chkD (chkD (chkA (chkA (eval (cadr Exe))))))
  %29 = and i64 %28, 15
  %30 = icmp eq i64 %29, 0
  br i1 %30, label %$15, label %$16
$16:
  %31 = icmp eq i64 %28, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$15
$15:
  %32 = phi i1 [1, %$14], [%31, %$16] ; # ->
  br i1 %32, label %$18, label %$17
$17:
  call void @lstErr(i64 %0, i64 %28)
  unreachable
$18:
  %33 = inttoptr i64 %28 to i64*
  %34 = getelementptr i64, i64* %33, i32 1
  %35 = load i64, i64* %34
  ret i64 %35
}

define i64 @_Cddadr(i64) align 8 {
$1:
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (chkD (eval (cadr Exe)))
  %14 = and i64 %13, 15
  %15 = icmp eq i64 %14, 0
  br i1 %15, label %$7, label %$8
$8:
  %16 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$7
$7:
  %17 = phi i1 [1, %$2], [%16, %$8] ; # ->
  br i1 %17, label %$10, label %$9
$9:
  call void @lstErr(i64 %0, i64 %13)
  unreachable
$10:
  %18 = inttoptr i64 %13 to i64*
  %19 = getelementptr i64, i64* %18, i32 1
  %20 = load i64, i64* %19
; # (chkA (chkD (eval (cadr Exe))))
  %21 = and i64 %20, 6
  %22 = icmp ne i64 %21, 0
  br i1 %22, label %$11, label %$12
$11:
  call void @varErr(i64 %0, i64 %20)
  unreachable
$12:
  %23 = inttoptr i64 %20 to i64*
  %24 = load i64, i64* %23
; # (chkD (chkA (chkD (eval (cadr Exe)))))
  %25 = and i64 %24, 15
  %26 = icmp eq i64 %25, 0
  br i1 %26, label %$13, label %$14
$14:
  %27 = icmp eq i64 %24, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$13
$13:
  %28 = phi i1 [1, %$12], [%27, %$14] ; # ->
  br i1 %28, label %$16, label %$15
$15:
  call void @lstErr(i64 %0, i64 %24)
  unreachable
$16:
  %29 = inttoptr i64 %24 to i64*
  %30 = getelementptr i64, i64* %29, i32 1
  %31 = load i64, i64* %30
; # (chkD (chkD (chkA (chkD (eval (cadr Exe))))))
  %32 = and i64 %31, 15
  %33 = icmp eq i64 %32, 0
  br i1 %33, label %$17, label %$18
$18:
  %34 = icmp eq i64 %31, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$17
$17:
  %35 = phi i1 [1, %$16], [%34, %$18] ; # ->
  br i1 %35, label %$20, label %$19
$19:
  call void @lstErr(i64 %0, i64 %31)
  unreachable
$20:
  %36 = inttoptr i64 %31 to i64*
  %37 = getelementptr i64, i64* %36, i32 1
  %38 = load i64, i64* %37
  ret i64 %38
}

define i64 @_Cdddar(i64) align 8 {
$1:
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (chkA (eval (cadr Exe)))
  %14 = and i64 %13, 6
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$7, label %$8
$7:
  call void @varErr(i64 %0, i64 %13)
  unreachable
$8:
  %16 = inttoptr i64 %13 to i64*
  %17 = load i64, i64* %16
; # (chkD (chkA (eval (cadr Exe))))
  %18 = and i64 %17, 15
  %19 = icmp eq i64 %18, 0
  br i1 %19, label %$9, label %$10
$10:
  %20 = icmp eq i64 %17, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$9
$9:
  %21 = phi i1 [1, %$8], [%20, %$10] ; # ->
  br i1 %21, label %$12, label %$11
$11:
  call void @lstErr(i64 %0, i64 %17)
  unreachable
$12:
  %22 = inttoptr i64 %17 to i64*
  %23 = getelementptr i64, i64* %22, i32 1
  %24 = load i64, i64* %23
; # (chkD (chkD (chkA (eval (cadr Exe)))))
  %25 = and i64 %24, 15
  %26 = icmp eq i64 %25, 0
  br i1 %26, label %$13, label %$14
$14:
  %27 = icmp eq i64 %24, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$13
$13:
  %28 = phi i1 [1, %$12], [%27, %$14] ; # ->
  br i1 %28, label %$16, label %$15
$15:
  call void @lstErr(i64 %0, i64 %24)
  unreachable
$16:
  %29 = inttoptr i64 %24 to i64*
  %30 = getelementptr i64, i64* %29, i32 1
  %31 = load i64, i64* %30
; # (chkD (chkD (chkD (chkA (eval (cadr Exe))))))
  %32 = and i64 %31, 15
  %33 = icmp eq i64 %32, 0
  br i1 %33, label %$17, label %$18
$18:
  %34 = icmp eq i64 %31, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$17
$17:
  %35 = phi i1 [1, %$16], [%34, %$18] ; # ->
  br i1 %35, label %$20, label %$19
$19:
  call void @lstErr(i64 %0, i64 %31)
  unreachable
$20:
  %36 = inttoptr i64 %31 to i64*
  %37 = getelementptr i64, i64* %36, i32 1
  %38 = load i64, i64* %37
  ret i64 %38
}

define i64 @_Cddddr(i64) align 8 {
$1:
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (chkD (eval (cadr Exe)))
  %14 = and i64 %13, 15
  %15 = icmp eq i64 %14, 0
  br i1 %15, label %$7, label %$8
$8:
  %16 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$7
$7:
  %17 = phi i1 [1, %$2], [%16, %$8] ; # ->
  br i1 %17, label %$10, label %$9
$9:
  call void @lstErr(i64 %0, i64 %13)
  unreachable
$10:
  %18 = inttoptr i64 %13 to i64*
  %19 = getelementptr i64, i64* %18, i32 1
  %20 = load i64, i64* %19
; # (chkD (chkD (eval (cadr Exe))))
  %21 = and i64 %20, 15
  %22 = icmp eq i64 %21, 0
  br i1 %22, label %$11, label %$12
$12:
  %23 = icmp eq i64 %20, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$11
$11:
  %24 = phi i1 [1, %$10], [%23, %$12] ; # ->
  br i1 %24, label %$14, label %$13
$13:
  call void @lstErr(i64 %0, i64 %20)
  unreachable
$14:
  %25 = inttoptr i64 %20 to i64*
  %26 = getelementptr i64, i64* %25, i32 1
  %27 = load i64, i64* %26
; # (chkD (chkD (chkD (eval (cadr Exe)))))
  %28 = and i64 %27, 15
  %29 = icmp eq i64 %28, 0
  br i1 %29, label %$15, label %$16
$16:
  %30 = icmp eq i64 %27, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$15
$15:
  %31 = phi i1 [1, %$14], [%30, %$16] ; # ->
  br i1 %31, label %$18, label %$17
$17:
  call void @lstErr(i64 %0, i64 %27)
  unreachable
$18:
  %32 = inttoptr i64 %27 to i64*
  %33 = getelementptr i64, i64* %32, i32 1
  %34 = load i64, i64* %33
; # (chkD (chkD (chkD (chkD (eval (cadr Exe))))))
  %35 = and i64 %34, 15
  %36 = icmp eq i64 %35, 0
  br i1 %36, label %$19, label %$20
$20:
  %37 = icmp eq i64 %34, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$19
$19:
  %38 = phi i1 [1, %$18], [%37, %$20] ; # ->
  br i1 %38, label %$22, label %$21
$21:
  call void @lstErr(i64 %0, i64 %34)
  unreachable
$22:
  %39 = inttoptr i64 %34 to i64*
  %40 = getelementptr i64, i64* %39, i32 1
  %41 = load i64, i64* %40
  ret i64 %41
}

define i64 @_Nth(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (save (eval (++ X)))) (loop (? (atom Y) Y) (l...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (save (eval (++ X)))
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %17 = load i64, i64* %16
  %18 = alloca i64, i64 2, align 16
  %19 = ptrtoint i64* %18 to i64
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = add i64 %19, 8
  %22 = inttoptr i64 %21 to i64*
  store i64 %17, i64* %22
  %23 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %19, i64* %23
; # (loop (? (atom Y) Y) (let C (evCnt Exe X) (? (lt0 (dec 'C)) $Nil)...
  br label %$7
$7:
  %24 = phi i64 [%7, %$2], [%62, %$16] ; # X
  %25 = phi i64 [%15, %$2], [%65, %$16] ; # Y
; # (? (atom Y) Y)
; # (atom Y)
  %26 = and i64 %25, 15
  %27 = icmp ne i64 %26, 0
  br i1 %27, label %$10, label %$8
$10:
  %28 = phi i64 [%24, %$7] ; # X
  %29 = phi i64 [%25, %$7] ; # Y
  br label %$9
$8:
  %30 = phi i64 [%24, %$7] ; # X
  %31 = phi i64 [%25, %$7] ; # Y
; # (let C (evCnt Exe X) (? (lt0 (dec 'C)) $Nil) (while (ge0 (dec 'C)...
; # (evCnt Exe X)
  %32 = call i64 @evCnt(i64 %0, i64 %30)
; # (? (lt0 (dec 'C)) $Nil)
; # (dec 'C)
  %33 = sub i64 %32, 1
; # (lt0 (dec 'C))
  %34 = icmp slt i64 %33, 0
  br i1 %34, label %$12, label %$11
$12:
  %35 = phi i64 [%30, %$8] ; # X
  %36 = phi i64 [%31, %$8] ; # Y
  %37 = phi i64 [%33, %$8] ; # C
  br label %$9
$11:
  %38 = phi i64 [%30, %$8] ; # X
  %39 = phi i64 [%31, %$8] ; # Y
  %40 = phi i64 [%33, %$8] ; # C
; # (while (ge0 (dec 'C)) (shift Y))
  br label %$13
$13:
  %41 = phi i64 [%38, %$11], [%46, %$14] ; # X
  %42 = phi i64 [%39, %$11], [%51, %$14] ; # Y
  %43 = phi i64 [%40, %$11], [%48, %$14] ; # C
; # (dec 'C)
  %44 = sub i64 %43, 1
; # (ge0 (dec 'C))
  %45 = icmp sge i64 %44, 0
  br i1 %45, label %$14, label %$15
$14:
  %46 = phi i64 [%41, %$13] ; # X
  %47 = phi i64 [%42, %$13] ; # Y
  %48 = phi i64 [%44, %$13] ; # C
; # (shift Y)
  %49 = inttoptr i64 %47 to i64*
  %50 = getelementptr i64, i64* %49, i32 1
  %51 = load i64, i64* %50
  br label %$13
$15:
  %52 = phi i64 [%41, %$13] ; # X
  %53 = phi i64 [%42, %$13] ; # Y
  %54 = phi i64 [%44, %$13] ; # C
; # (? (atom (shift X)) Y)
; # (shift X)
  %55 = inttoptr i64 %52 to i64*
  %56 = getelementptr i64, i64* %55, i32 1
  %57 = load i64, i64* %56
; # (atom (shift X))
  %58 = and i64 %57, 15
  %59 = icmp ne i64 %58, 0
  br i1 %59, label %$17, label %$16
$17:
  %60 = phi i64 [%57, %$15] ; # X
  %61 = phi i64 [%53, %$15] ; # Y
  br label %$9
$16:
  %62 = phi i64 [%57, %$15] ; # X
  %63 = phi i64 [%53, %$15] ; # Y
; # (car Y)
  %64 = inttoptr i64 %63 to i64*
  %65 = load i64, i64* %64
  br label %$7
$9:
  %66 = phi i64 [%28, %$10], [%35, %$12], [%60, %$17] ; # X
  %67 = phi i64 [%29, %$10], [%36, %$12], [%61, %$17] ; # Y
  %68 = phi i64 [%29, %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$12], [%61, %$17] ; # ->
; # (drop *Safe)
  %69 = inttoptr i64 %19 to i64*
  %70 = getelementptr i64, i64* %69, i32 1
  %71 = load i64, i64* %70
  %72 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %71, i64* %72
  ret i64 %68
}

define i64 @_Con(i64) align 8 {
$1:
; # (let X (cdr Exe) (set 2 (save (needPair Exe (eval (++ X)))) (eval...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (set 2 (save (needPair Exe (eval (++ X)))) (eval (car X)))
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (needPair Exe (eval (++ X)))
  %16 = and i64 %15, 15
  %17 = icmp ne i64 %16, 0
  br i1 %17, label %$7, label %$8
$7:
  call void @pairErr(i64 %0, i64 %15)
  unreachable
$8:
; # (save (needPair Exe (eval (++ X))))
  %18 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %19 = load i64, i64* %18
  %20 = alloca i64, i64 2, align 16
  %21 = ptrtoint i64* %20 to i64
  %22 = inttoptr i64 %21 to i64*
  store i64 %15, i64* %22
  %23 = add i64 %21, 8
  %24 = inttoptr i64 %23 to i64*
  store i64 %19, i64* %24
  %25 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %21, i64* %25
; # (car X)
  %26 = inttoptr i64 %7 to i64*
  %27 = load i64, i64* %26
; # (eval (car X))
  %28 = and i64 %27, 6
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %$11, label %$10
$11:
  br label %$9
$10:
  %30 = and i64 %27, 8
  %31 = icmp ne i64 %30, 0
  br i1 %31, label %$13, label %$12
$13:
  %32 = inttoptr i64 %27 to i64*
  %33 = load i64, i64* %32
  br label %$9
$12:
  %34 = call i64 @evList(i64 %27)
  br label %$9
$9:
  %35 = phi i64 [%27, %$11], [%33, %$13], [%34, %$12] ; # ->
  %36 = inttoptr i64 %15 to i64*
  %37 = getelementptr i64, i64* %36, i32 1
  store i64 %35, i64* %37
; # (drop *Safe)
  %38 = inttoptr i64 %21 to i64*
  %39 = getelementptr i64, i64* %38, i32 1
  %40 = load i64, i64* %39
  %41 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %40, i64* %41
  ret i64 %35
}

define i64 @_Cons(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (cons (eval (car X)) $Nil) R (save Y)) (while...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (car X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (car X))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (cons (eval (car X)) $Nil)
  %14 = call i64 @cons(i64 %13, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (save Y)
  %15 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %16 = load i64, i64* %15
  %17 = alloca i64, i64 2, align 16
  %18 = ptrtoint i64* %17 to i64
  %19 = inttoptr i64 %18 to i64*
  store i64 %14, i64* %19
  %20 = add i64 %18, 8
  %21 = inttoptr i64 %20 to i64*
  store i64 %16, i64* %21
  %22 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %18, i64* %22
; # (while (pair (cdr (shift X))) (setq Y (set 2 Y (cons (eval (car X...
  br label %$7
$7:
  %23 = phi i64 [%3, %$2], [%33, %$10] ; # X
  %24 = phi i64 [%14, %$2], [%45, %$10] ; # Y
; # (shift X)
  %25 = inttoptr i64 %23 to i64*
  %26 = getelementptr i64, i64* %25, i32 1
  %27 = load i64, i64* %26
; # (cdr (shift X))
  %28 = inttoptr i64 %27 to i64*
  %29 = getelementptr i64, i64* %28, i32 1
  %30 = load i64, i64* %29
; # (pair (cdr (shift X)))
  %31 = and i64 %30, 15
  %32 = icmp eq i64 %31, 0
  br i1 %32, label %$8, label %$9
$8:
  %33 = phi i64 [%27, %$7] ; # X
  %34 = phi i64 [%24, %$7] ; # Y
; # (set 2 Y (cons (eval (car X)) $Nil))
; # (car X)
  %35 = inttoptr i64 %33 to i64*
  %36 = load i64, i64* %35
; # (eval (car X))
  %37 = and i64 %36, 6
  %38 = icmp ne i64 %37, 0
  br i1 %38, label %$12, label %$11
$12:
  br label %$10
$11:
  %39 = and i64 %36, 8
  %40 = icmp ne i64 %39, 0
  br i1 %40, label %$14, label %$13
$14:
  %41 = inttoptr i64 %36 to i64*
  %42 = load i64, i64* %41
  br label %$10
$13:
  %43 = call i64 @evList(i64 %36)
  br label %$10
$10:
  %44 = phi i64 [%36, %$12], [%42, %$14], [%43, %$13] ; # ->
; # (cons (eval (car X)) $Nil)
  %45 = call i64 @cons(i64 %44, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %46 = inttoptr i64 %34 to i64*
  %47 = getelementptr i64, i64* %46, i32 1
  store i64 %45, i64* %47
  br label %$7
$9:
  %48 = phi i64 [%27, %$7] ; # X
  %49 = phi i64 [%24, %$7] ; # Y
; # (set 2 Y (eval (car X)))
; # (car X)
  %50 = inttoptr i64 %48 to i64*
  %51 = load i64, i64* %50
; # (eval (car X))
  %52 = and i64 %51, 6
  %53 = icmp ne i64 %52, 0
  br i1 %53, label %$17, label %$16
$17:
  br label %$15
$16:
  %54 = and i64 %51, 8
  %55 = icmp ne i64 %54, 0
  br i1 %55, label %$19, label %$18
$19:
  %56 = inttoptr i64 %51 to i64*
  %57 = load i64, i64* %56
  br label %$15
$18:
  %58 = call i64 @evList(i64 %51)
  br label %$15
$15:
  %59 = phi i64 [%51, %$17], [%57, %$19], [%58, %$18] ; # ->
  %60 = inttoptr i64 %49 to i64*
  %61 = getelementptr i64, i64* %60, i32 1
  store i64 %59, i64* %61
; # (drop *Safe)
  %62 = inttoptr i64 %18 to i64*
  %63 = getelementptr i64, i64* %62, i32 1
  %64 = load i64, i64* %63
  %65 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %64, i64* %65
  ret i64 %14
}

define i64 @_Conc(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (eval (car X)) R (save Y)) (while (pair (shif...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (car X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (car X))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (save Y)
  %14 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %15 = load i64, i64* %14
  %16 = alloca i64, i64 2, align 16
  %17 = ptrtoint i64* %16 to i64
  %18 = inttoptr i64 %17 to i64*
  store i64 %13, i64* %18
  %19 = add i64 %17, 8
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %17, i64* %21
; # (while (pair (shift X)) (let Z (eval (car X)) (if (atom Y) (setq ...
  br label %$7
$7:
  %22 = phi i64 [%3, %$2], [%68, %$17] ; # X
  %23 = phi i64 [%13, %$2], [%69, %$17] ; # Y
  %24 = phi i64 [%13, %$2], [%70, %$17] ; # R
; # (shift X)
  %25 = inttoptr i64 %22 to i64*
  %26 = getelementptr i64, i64* %25, i32 1
  %27 = load i64, i64* %26
; # (pair (shift X))
  %28 = and i64 %27, 15
  %29 = icmp eq i64 %28, 0
  br i1 %29, label %$8, label %$9
$8:
  %30 = phi i64 [%27, %$7] ; # X
  %31 = phi i64 [%23, %$7] ; # Y
  %32 = phi i64 [%24, %$7] ; # R
; # (let Z (eval (car X)) (if (atom Y) (setq Y (setq R (safe Z))) (wh...
; # (car X)
  %33 = inttoptr i64 %30 to i64*
  %34 = load i64, i64* %33
; # (eval (car X))
  %35 = and i64 %34, 6
  %36 = icmp ne i64 %35, 0
  br i1 %36, label %$12, label %$11
$12:
  br label %$10
$11:
  %37 = and i64 %34, 8
  %38 = icmp ne i64 %37, 0
  br i1 %38, label %$14, label %$13
$14:
  %39 = inttoptr i64 %34 to i64*
  %40 = load i64, i64* %39
  br label %$10
$13:
  %41 = call i64 @evList(i64 %34)
  br label %$10
$10:
  %42 = phi i64 [%34, %$12], [%40, %$14], [%41, %$13] ; # ->
; # (if (atom Y) (setq Y (setq R (safe Z))) (while (pair (cdr Y)) (se...
; # (atom Y)
  %43 = and i64 %31, 15
  %44 = icmp ne i64 %43, 0
  br i1 %44, label %$15, label %$16
$15:
  %45 = phi i64 [%30, %$10] ; # X
  %46 = phi i64 [%31, %$10] ; # Y
  %47 = phi i64 [%32, %$10] ; # R
; # (safe Z)
  %48 = inttoptr i64 %17 to i64*
  store i64 %42, i64* %48
  br label %$17
$16:
  %49 = phi i64 [%30, %$10] ; # X
  %50 = phi i64 [%31, %$10] ; # Y
  %51 = phi i64 [%32, %$10] ; # R
; # (while (pair (cdr Y)) (setq Y @))
  br label %$18
$18:
  %52 = phi i64 [%49, %$16], [%60, %$19] ; # X
  %53 = phi i64 [%50, %$16], [%57, %$19] ; # Y
  %54 = phi i64 [%51, %$16], [%62, %$19] ; # R
; # (cdr Y)
  %55 = inttoptr i64 %53 to i64*
  %56 = getelementptr i64, i64* %55, i32 1
  %57 = load i64, i64* %56
; # (pair (cdr Y))
  %58 = and i64 %57, 15
  %59 = icmp eq i64 %58, 0
  br i1 %59, label %$19, label %$20
$19:
  %60 = phi i64 [%52, %$18] ; # X
  %61 = phi i64 [%53, %$18] ; # Y
  %62 = phi i64 [%54, %$18] ; # R
  br label %$18
$20:
  %63 = phi i64 [%52, %$18] ; # X
  %64 = phi i64 [%53, %$18] ; # Y
  %65 = phi i64 [%54, %$18] ; # R
; # (set 2 Y Z)
  %66 = inttoptr i64 %64 to i64*
  %67 = getelementptr i64, i64* %66, i32 1
  store i64 %42, i64* %67
  br label %$17
$17:
  %68 = phi i64 [%45, %$15], [%63, %$20] ; # X
  %69 = phi i64 [%42, %$15], [%64, %$20] ; # Y
  %70 = phi i64 [%42, %$15], [%65, %$20] ; # R
  %71 = phi i64 [%42, %$15], [%42, %$20] ; # ->
  br label %$7
$9:
  %72 = phi i64 [%27, %$7] ; # X
  %73 = phi i64 [%23, %$7] ; # Y
  %74 = phi i64 [%24, %$7] ; # R
; # (drop *Safe)
  %75 = inttoptr i64 %17 to i64*
  %76 = getelementptr i64, i64* %75, i32 1
  %77 = load i64, i64* %76
  %78 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %77, i64* %78
  ret i64 %74
}

define i64 @_Circ(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (cons (eval (car X)) $Nil) R (save Y)) (while...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (car X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (car X))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (cons (eval (car X)) $Nil)
  %14 = call i64 @cons(i64 %13, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (save Y)
  %15 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %16 = load i64, i64* %15
  %17 = alloca i64, i64 2, align 16
  %18 = ptrtoint i64* %17 to i64
  %19 = inttoptr i64 %18 to i64*
  store i64 %14, i64* %19
  %20 = add i64 %18, 8
  %21 = inttoptr i64 %20 to i64*
  store i64 %16, i64* %21
  %22 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %18, i64* %22
; # (while (pair (shift X)) (setq Y (set 2 Y (cons (eval (car X)) $Ni...
  br label %$7
$7:
  %23 = phi i64 [%3, %$2], [%30, %$10] ; # X
  %24 = phi i64 [%14, %$2], [%42, %$10] ; # Y
; # (shift X)
  %25 = inttoptr i64 %23 to i64*
  %26 = getelementptr i64, i64* %25, i32 1
  %27 = load i64, i64* %26
; # (pair (shift X))
  %28 = and i64 %27, 15
  %29 = icmp eq i64 %28, 0
  br i1 %29, label %$8, label %$9
$8:
  %30 = phi i64 [%27, %$7] ; # X
  %31 = phi i64 [%24, %$7] ; # Y
; # (set 2 Y (cons (eval (car X)) $Nil))
; # (car X)
  %32 = inttoptr i64 %30 to i64*
  %33 = load i64, i64* %32
; # (eval (car X))
  %34 = and i64 %33, 6
  %35 = icmp ne i64 %34, 0
  br i1 %35, label %$12, label %$11
$12:
  br label %$10
$11:
  %36 = and i64 %33, 8
  %37 = icmp ne i64 %36, 0
  br i1 %37, label %$14, label %$13
$14:
  %38 = inttoptr i64 %33 to i64*
  %39 = load i64, i64* %38
  br label %$10
$13:
  %40 = call i64 @evList(i64 %33)
  br label %$10
$10:
  %41 = phi i64 [%33, %$12], [%39, %$14], [%40, %$13] ; # ->
; # (cons (eval (car X)) $Nil)
  %42 = call i64 @cons(i64 %41, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %43 = inttoptr i64 %31 to i64*
  %44 = getelementptr i64, i64* %43, i32 1
  store i64 %42, i64* %44
  br label %$7
$9:
  %45 = phi i64 [%27, %$7] ; # X
  %46 = phi i64 [%24, %$7] ; # Y
; # (set 2 Y R)
  %47 = inttoptr i64 %46 to i64*
  %48 = getelementptr i64, i64* %47, i32 1
  store i64 %14, i64* %48
; # (drop *Safe)
  %49 = inttoptr i64 %18 to i64*
  %50 = getelementptr i64, i64* %49, i32 1
  %51 = load i64, i64* %50
  %52 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %51, i64* %52
  ret i64 %14
}

define i64 @_Rot(i64) align 8 {
$1:
; # (let (X (cdr Exe) R (eval (car X))) (when (pair R) (let (Y R A (+...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (car X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (car X))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (when (pair R) (let (Y R A (++ Y)) (if (pair (shift X)) (let N (s...
; # (pair R)
  %14 = and i64 %13, 15
  %15 = icmp eq i64 %14, 0
  br i1 %15, label %$7, label %$8
$7:
  %16 = phi i64 [%3, %$2] ; # X
; # (let (Y R A (++ Y)) (if (pair (shift X)) (let N (save R (evCnt Ex...
; # (++ Y)
  %17 = inttoptr i64 %13 to i64*
  %18 = load i64, i64* %17
  %19 = getelementptr i64, i64* %17, i32 1
  %20 = load i64, i64* %19
; # (if (pair (shift X)) (let N (save R (evCnt Exe X)) (while (and (p...
; # (shift X)
  %21 = inttoptr i64 %16 to i64*
  %22 = getelementptr i64, i64* %21, i32 1
  %23 = load i64, i64* %22
; # (pair (shift X))
  %24 = and i64 %23, 15
  %25 = icmp eq i64 %24, 0
  br i1 %25, label %$9, label %$10
$9:
  %26 = phi i64 [%23, %$7] ; # X
  %27 = phi i64 [%20, %$7] ; # Y
  %28 = phi i64 [%18, %$7] ; # A
; # (let N (save R (evCnt Exe X)) (while (and (pair Y) (gt0 (dec 'N))...
; # (save R (evCnt Exe X))
  %29 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %30 = load i64, i64* %29
  %31 = alloca i64, i64 2, align 16
  %32 = ptrtoint i64* %31 to i64
  %33 = inttoptr i64 %32 to i64*
  store i64 %13, i64* %33
  %34 = add i64 %32, 8
  %35 = inttoptr i64 %34 to i64*
  store i64 %30, i64* %35
  %36 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %32, i64* %36
; # (evCnt Exe X)
  %37 = call i64 @evCnt(i64 %0, i64 %26)
; # drop
  %38 = inttoptr i64 %32 to i64*
  %39 = getelementptr i64, i64* %38, i32 1
  %40 = load i64, i64* %39
  %41 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %40, i64* %41
; # (while (and (pair Y) (gt0 (dec 'N))) (let B (car Y) (set Y A) (se...
  br label %$12
$12:
  %42 = phi i64 [%26, %$9], [%70, %$17] ; # X
  %43 = phi i64 [%27, %$9], [%71, %$17] ; # Y
  %44 = phi i64 [%28, %$9], [%72, %$17] ; # A
  %45 = phi i64 [%37, %$9], [%73, %$17] ; # N
; # (and (pair Y) (gt0 (dec 'N)))
; # (pair Y)
  %46 = and i64 %43, 15
  %47 = icmp eq i64 %46, 0
  br i1 %47, label %$14, label %$13
$14:
  %48 = phi i64 [%42, %$12] ; # X
  %49 = phi i64 [%43, %$12] ; # Y
  %50 = phi i64 [%44, %$12] ; # A
  %51 = phi i64 [%45, %$12] ; # N
; # (dec 'N)
  %52 = sub i64 %51, 1
; # (gt0 (dec 'N))
  %53 = icmp sgt i64 %52, 0
  br label %$13
$13:
  %54 = phi i64 [%42, %$12], [%48, %$14] ; # X
  %55 = phi i64 [%43, %$12], [%49, %$14] ; # Y
  %56 = phi i64 [%44, %$12], [%50, %$14] ; # A
  %57 = phi i64 [%45, %$12], [%52, %$14] ; # N
  %58 = phi i1 [0, %$12], [%53, %$14] ; # ->
  br i1 %58, label %$15, label %$16
$15:
  %59 = phi i64 [%54, %$13] ; # X
  %60 = phi i64 [%55, %$13] ; # Y
  %61 = phi i64 [%56, %$13] ; # A
  %62 = phi i64 [%57, %$13] ; # N
; # (let B (car Y) (set Y A) (setq A B))
; # (car Y)
  %63 = inttoptr i64 %60 to i64*
  %64 = load i64, i64* %63
; # (set Y A)
  %65 = inttoptr i64 %60 to i64*
  store i64 %61, i64* %65
; # (? (== R (shift Y)))
; # (shift Y)
  %66 = inttoptr i64 %60 to i64*
  %67 = getelementptr i64, i64* %66, i32 1
  %68 = load i64, i64* %67
; # (== R (shift Y))
  %69 = icmp eq i64 %13, %68
  br i1 %69, label %$16, label %$17
$17:
  %70 = phi i64 [%59, %$15] ; # X
  %71 = phi i64 [%68, %$15] ; # Y
  %72 = phi i64 [%64, %$15] ; # A
  %73 = phi i64 [%62, %$15] ; # N
  br label %$12
$16:
  %74 = phi i64 [%54, %$13], [%59, %$15] ; # X
  %75 = phi i64 [%55, %$13], [%68, %$15] ; # Y
  %76 = phi i64 [%56, %$13], [%64, %$15] ; # A
  %77 = phi i64 [%57, %$13], [%62, %$15] ; # N
; # (set R A)
  %78 = inttoptr i64 %13 to i64*
  store i64 %76, i64* %78
  br label %$11
$10:
  %79 = phi i64 [%23, %$7] ; # X
  %80 = phi i64 [%20, %$7] ; # Y
  %81 = phi i64 [%18, %$7] ; # A
; # (while (pair Y) (let B (car Y) (set Y A) (setq A B)) (? (== R (sh...
  br label %$18
$18:
  %82 = phi i64 [%79, %$10], [%97, %$21] ; # X
  %83 = phi i64 [%80, %$10], [%98, %$21] ; # Y
  %84 = phi i64 [%81, %$10], [%99, %$21] ; # A
; # (pair Y)
  %85 = and i64 %83, 15
  %86 = icmp eq i64 %85, 0
  br i1 %86, label %$19, label %$20
$19:
  %87 = phi i64 [%82, %$18] ; # X
  %88 = phi i64 [%83, %$18] ; # Y
  %89 = phi i64 [%84, %$18] ; # A
; # (let B (car Y) (set Y A) (setq A B))
; # (car Y)
  %90 = inttoptr i64 %88 to i64*
  %91 = load i64, i64* %90
; # (set Y A)
  %92 = inttoptr i64 %88 to i64*
  store i64 %89, i64* %92
; # (? (== R (shift Y)))
; # (shift Y)
  %93 = inttoptr i64 %88 to i64*
  %94 = getelementptr i64, i64* %93, i32 1
  %95 = load i64, i64* %94
; # (== R (shift Y))
  %96 = icmp eq i64 %13, %95
  br i1 %96, label %$20, label %$21
$21:
  %97 = phi i64 [%87, %$19] ; # X
  %98 = phi i64 [%95, %$19] ; # Y
  %99 = phi i64 [%91, %$19] ; # A
  br label %$18
$20:
  %100 = phi i64 [%82, %$18], [%87, %$19] ; # X
  %101 = phi i64 [%83, %$18], [%95, %$19] ; # Y
  %102 = phi i64 [%84, %$18], [%91, %$19] ; # A
; # (set R A)
  %103 = inttoptr i64 %13 to i64*
  store i64 %102, i64* %103
  br label %$11
$11:
  %104 = phi i64 [%74, %$16], [%100, %$20] ; # X
  %105 = phi i64 [%75, %$16], [%101, %$20] ; # Y
  %106 = phi i64 [%76, %$16], [%102, %$20] ; # A
  %107 = phi i64 [%76, %$16], [%102, %$20] ; # ->
  br label %$8
$8:
  %108 = phi i64 [%3, %$2], [%104, %$11] ; # X
  ret i64 %13
}

define i64 @_List(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (cons (eval (car X)) $Nil) R (save Y)) (while...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (car X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (car X))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (cons (eval (car X)) $Nil)
  %14 = call i64 @cons(i64 %13, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (save Y)
  %15 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %16 = load i64, i64* %15
  %17 = alloca i64, i64 2, align 16
  %18 = ptrtoint i64* %17 to i64
  %19 = inttoptr i64 %18 to i64*
  store i64 %14, i64* %19
  %20 = add i64 %18, 8
  %21 = inttoptr i64 %20 to i64*
  store i64 %16, i64* %21
  %22 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %18, i64* %22
; # (while (pair (shift X)) (setq Y (set 2 Y (cons (eval (car X)) $Ni...
  br label %$7
$7:
  %23 = phi i64 [%3, %$2], [%30, %$10] ; # X
  %24 = phi i64 [%14, %$2], [%42, %$10] ; # Y
; # (shift X)
  %25 = inttoptr i64 %23 to i64*
  %26 = getelementptr i64, i64* %25, i32 1
  %27 = load i64, i64* %26
; # (pair (shift X))
  %28 = and i64 %27, 15
  %29 = icmp eq i64 %28, 0
  br i1 %29, label %$8, label %$9
$8:
  %30 = phi i64 [%27, %$7] ; # X
  %31 = phi i64 [%24, %$7] ; # Y
; # (set 2 Y (cons (eval (car X)) $Nil))
; # (car X)
  %32 = inttoptr i64 %30 to i64*
  %33 = load i64, i64* %32
; # (eval (car X))
  %34 = and i64 %33, 6
  %35 = icmp ne i64 %34, 0
  br i1 %35, label %$12, label %$11
$12:
  br label %$10
$11:
  %36 = and i64 %33, 8
  %37 = icmp ne i64 %36, 0
  br i1 %37, label %$14, label %$13
$14:
  %38 = inttoptr i64 %33 to i64*
  %39 = load i64, i64* %38
  br label %$10
$13:
  %40 = call i64 @evList(i64 %33)
  br label %$10
$10:
  %41 = phi i64 [%33, %$12], [%39, %$14], [%40, %$13] ; # ->
; # (cons (eval (car X)) $Nil)
  %42 = call i64 @cons(i64 %41, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %43 = inttoptr i64 %31 to i64*
  %44 = getelementptr i64, i64* %43, i32 1
  store i64 %42, i64* %44
  br label %$7
$9:
  %45 = phi i64 [%27, %$7] ; # X
  %46 = phi i64 [%24, %$7] ; # Y
; # (drop *Safe)
  %47 = inttoptr i64 %18 to i64*
  %48 = getelementptr i64, i64* %47, i32 1
  %49 = load i64, i64* %48
  %50 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %49, i64* %50
  ret i64 %14
}

define i64 @_Need(i64) align 8 {
$1:
; # (let (X (cdr Exe) C (evCnt Exe X) R (save (eval (car (shift X))))...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (evCnt Exe X)
  %4 = call i64 @evCnt(i64 %0, i64 %3)
; # (shift X)
  %5 = inttoptr i64 %3 to i64*
  %6 = getelementptr i64, i64* %5, i32 1
  %7 = load i64, i64* %6
; # (car (shift X))
  %8 = inttoptr i64 %7 to i64*
  %9 = load i64, i64* %8
; # (eval (car (shift X)))
  %10 = and i64 %9, 6
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$4, label %$3
$4:
  br label %$2
$3:
  %12 = and i64 %9, 8
  %13 = icmp ne i64 %12, 0
  br i1 %13, label %$6, label %$5
$6:
  %14 = inttoptr i64 %9 to i64*
  %15 = load i64, i64* %14
  br label %$2
$5:
  %16 = call i64 @evList(i64 %9)
  br label %$2
$2:
  %17 = phi i64 [%9, %$4], [%15, %$6], [%16, %$5] ; # ->
; # (save (eval (car (shift X))))
  %18 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %19 = load i64, i64* %18
  %20 = alloca i64, i64 2, align 16
  %21 = ptrtoint i64* %20 to i64
  %22 = inttoptr i64 %21 to i64*
  store i64 %17, i64* %22
  %23 = add i64 %21, 8
  %24 = inttoptr i64 %23 to i64*
  store i64 %19, i64* %24
  %25 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %21, i64* %25
; # (if (or (pair R) (nil? R)) (eval (cadr X)) (prog1 R (setq R $Nil)...
; # (or (pair R) (nil? R))
; # (pair R)
  %26 = and i64 %17, 15
  %27 = icmp eq i64 %26, 0
  br i1 %27, label %$7, label %$8
$8:
  %28 = phi i64 [%4, %$2] ; # C
  %29 = phi i64 [%17, %$2] ; # R
; # (nil? R)
  %30 = icmp eq i64 %29, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$7
$7:
  %31 = phi i64 [%4, %$2], [%28, %$8] ; # C
  %32 = phi i64 [%17, %$2], [%29, %$8] ; # R
  %33 = phi i1 [1, %$2], [%30, %$8] ; # ->
  br i1 %33, label %$9, label %$10
$9:
  %34 = phi i64 [%31, %$7] ; # C
  %35 = phi i64 [%32, %$7] ; # R
; # (cadr X)
  %36 = inttoptr i64 %7 to i64*
  %37 = getelementptr i64, i64* %36, i32 1
  %38 = load i64, i64* %37
  %39 = inttoptr i64 %38 to i64*
  %40 = load i64, i64* %39
; # (eval (cadr X))
  %41 = and i64 %40, 6
  %42 = icmp ne i64 %41, 0
  br i1 %42, label %$14, label %$13
$14:
  br label %$12
$13:
  %43 = and i64 %40, 8
  %44 = icmp ne i64 %43, 0
  br i1 %44, label %$16, label %$15
$16:
  %45 = inttoptr i64 %40 to i64*
  %46 = load i64, i64* %45
  br label %$12
$15:
  %47 = call i64 @evList(i64 %40)
  br label %$12
$12:
  %48 = phi i64 [%40, %$14], [%46, %$16], [%47, %$15] ; # ->
  br label %$11
$10:
  %49 = phi i64 [%31, %$7] ; # C
  %50 = phi i64 [%32, %$7] ; # R
; # (prog1 R (setq R $Nil))
  br label %$11
$11:
  %51 = phi i64 [%34, %$12], [%49, %$10] ; # C
  %52 = phi i64 [%35, %$12], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$10] ; # R
  %53 = phi i64 [%48, %$12], [%50, %$10] ; # ->
; # (save (if (or (pair R) (nil? R)) (eval (cadr X)) (prog1 R (setq R...
  %54 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %55 = load i64, i64* %54
  %56 = alloca i64, i64 2, align 16
  %57 = ptrtoint i64* %56 to i64
  %58 = inttoptr i64 %57 to i64*
  store i64 %53, i64* %58
  %59 = add i64 %57, 8
  %60 = inttoptr i64 %59 to i64*
  store i64 %55, i64* %60
  %61 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %57, i64* %61
; # (when C (cond ((gt0 C) (while (pair Z) (dec 'C) (shift Z)) (while...
  %62 = icmp ne i64 %51, 0
  br i1 %62, label %$17, label %$18
$17:
  %63 = phi i64 [%51, %$11] ; # C
  %64 = phi i64 [%52, %$11] ; # R
  %65 = phi i64 [%52, %$11] ; # Z
; # (cond ((gt0 C) (while (pair Z) (dec 'C) (shift Z)) (while (ge0 (d...
; # (gt0 C)
  %66 = icmp sgt i64 %63, 0
  br i1 %66, label %$21, label %$20
$21:
  %67 = phi i64 [%63, %$17] ; # C
  %68 = phi i64 [%64, %$17] ; # R
  %69 = phi i64 [%65, %$17] ; # Z
; # (while (pair Z) (dec 'C) (shift Z))
  br label %$22
$22:
  %70 = phi i64 [%67, %$21], [%78, %$23] ; # C
  %71 = phi i64 [%68, %$21], [%76, %$23] ; # R
  %72 = phi i64 [%69, %$21], [%81, %$23] ; # Z
; # (pair Z)
  %73 = and i64 %72, 15
  %74 = icmp eq i64 %73, 0
  br i1 %74, label %$23, label %$24
$23:
  %75 = phi i64 [%70, %$22] ; # C
  %76 = phi i64 [%71, %$22] ; # R
  %77 = phi i64 [%72, %$22] ; # Z
; # (dec 'C)
  %78 = sub i64 %75, 1
; # (shift Z)
  %79 = inttoptr i64 %77 to i64*
  %80 = getelementptr i64, i64* %79, i32 1
  %81 = load i64, i64* %80
  br label %$22
$24:
  %82 = phi i64 [%70, %$22] ; # C
  %83 = phi i64 [%71, %$22] ; # R
  %84 = phi i64 [%72, %$22] ; # Z
; # (while (ge0 (dec 'C)) (setq R (safe (cons Y R))))
  br label %$25
$25:
  %85 = phi i64 [%82, %$24], [%90, %$26] ; # C
  %86 = phi i64 [%83, %$24], [%93, %$26] ; # R
  %87 = phi i64 [%84, %$24], [%92, %$26] ; # Z
; # (dec 'C)
  %88 = sub i64 %85, 1
; # (ge0 (dec 'C))
  %89 = icmp sge i64 %88, 0
  br i1 %89, label %$26, label %$27
$26:
  %90 = phi i64 [%88, %$25] ; # C
  %91 = phi i64 [%86, %$25] ; # R
  %92 = phi i64 [%87, %$25] ; # Z
; # (cons Y R)
  %93 = call i64 @cons(i64 %53, i64 %91)
; # (safe (cons Y R))
  %94 = inttoptr i64 %21 to i64*
  store i64 %93, i64* %94
  br label %$25
$27:
  %95 = phi i64 [%88, %$25] ; # C
  %96 = phi i64 [%86, %$25] ; # R
  %97 = phi i64 [%87, %$25] ; # Z
  br label %$19
$20:
  %98 = phi i64 [%63, %$17] ; # C
  %99 = phi i64 [%64, %$17] ; # R
  %100 = phi i64 [%65, %$17] ; # Z
; # (if (atom R) (setq Z (setq R (safe (cons Y $Nil)))) (while (pair ...
; # (atom R)
  %101 = and i64 %99, 15
  %102 = icmp ne i64 %101, 0
  br i1 %102, label %$28, label %$29
$28:
  %103 = phi i64 [%98, %$20] ; # C
  %104 = phi i64 [%99, %$20] ; # R
  %105 = phi i64 [%100, %$20] ; # Z
; # (cons Y $Nil)
  %106 = call i64 @cons(i64 %53, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (safe (cons Y $Nil))
  %107 = inttoptr i64 %21 to i64*
  store i64 %106, i64* %107
  br label %$30
$29:
  %108 = phi i64 [%98, %$20] ; # C
  %109 = phi i64 [%99, %$20] ; # R
  %110 = phi i64 [%100, %$20] ; # Z
; # (while (pair (cdr Z)) (inc 'C) (shift Z))
  br label %$31
$31:
  %111 = phi i64 [%108, %$29], [%122, %$32] ; # C
  %112 = phi i64 [%109, %$29], [%120, %$32] ; # R
  %113 = phi i64 [%110, %$29], [%125, %$32] ; # Z
; # (cdr Z)
  %114 = inttoptr i64 %113 to i64*
  %115 = getelementptr i64, i64* %114, i32 1
  %116 = load i64, i64* %115
; # (pair (cdr Z))
  %117 = and i64 %116, 15
  %118 = icmp eq i64 %117, 0
  br i1 %118, label %$32, label %$33
$32:
  %119 = phi i64 [%111, %$31] ; # C
  %120 = phi i64 [%112, %$31] ; # R
  %121 = phi i64 [%113, %$31] ; # Z
; # (inc 'C)
  %122 = add i64 %119, 1
; # (shift Z)
  %123 = inttoptr i64 %121 to i64*
  %124 = getelementptr i64, i64* %123, i32 1
  %125 = load i64, i64* %124
  br label %$31
$33:
  %126 = phi i64 [%111, %$31] ; # C
  %127 = phi i64 [%112, %$31] ; # R
  %128 = phi i64 [%113, %$31] ; # Z
  br label %$30
$30:
  %129 = phi i64 [%103, %$28], [%126, %$33] ; # C
  %130 = phi i64 [%106, %$28], [%127, %$33] ; # R
  %131 = phi i64 [%106, %$28], [%128, %$33] ; # Z
; # (while (lt0 (inc 'C)) (setq Z (set 2 Z (cons Y $Nil))))
  br label %$34
$34:
  %132 = phi i64 [%129, %$30], [%137, %$35] ; # C
  %133 = phi i64 [%130, %$30], [%138, %$35] ; # R
  %134 = phi i64 [%131, %$30], [%140, %$35] ; # Z
; # (inc 'C)
  %135 = add i64 %132, 1
; # (lt0 (inc 'C))
  %136 = icmp slt i64 %135, 0
  br i1 %136, label %$35, label %$36
$35:
  %137 = phi i64 [%135, %$34] ; # C
  %138 = phi i64 [%133, %$34] ; # R
  %139 = phi i64 [%134, %$34] ; # Z
; # (set 2 Z (cons Y $Nil))
; # (cons Y $Nil)
  %140 = call i64 @cons(i64 %53, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %141 = inttoptr i64 %139 to i64*
  %142 = getelementptr i64, i64* %141, i32 1
  store i64 %140, i64* %142
  br label %$34
$36:
  %143 = phi i64 [%135, %$34] ; # C
  %144 = phi i64 [%133, %$34] ; # R
  %145 = phi i64 [%134, %$34] ; # Z
  br label %$19
$19:
  %146 = phi i64 [%95, %$27], [%143, %$36] ; # C
  %147 = phi i64 [%96, %$27], [%144, %$36] ; # R
  %148 = phi i64 [%97, %$27], [%145, %$36] ; # Z
  br label %$18
$18:
  %149 = phi i64 [%51, %$11], [%146, %$19] ; # C
  %150 = phi i64 [%52, %$11], [%147, %$19] ; # R
  %151 = phi i64 [%52, %$11], [%148, %$19] ; # Z
; # (drop *Safe)
  %152 = inttoptr i64 %21 to i64*
  %153 = getelementptr i64, i64* %152, i32 1
  %154 = load i64, i64* %153
  %155 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %154, i64* %155
  ret i64 %150
}

define i64 @_Range(i64) align 8 {
$1:
; # (let (X (cdr Exe) N (needNum Exe (eval (++ X))) R (save (cons N $...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (needNum Exe (eval (++ X)))
  %16 = and i64 %15, 6
  %17 = icmp ne i64 %16, 0
  br i1 %17, label %$8, label %$7
$7:
  call void @numErr(i64 %0, i64 %15)
  unreachable
$8:
; # (cons N $Nil)
  %18 = call i64 @cons(i64 %15, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (save (cons N $Nil))
  %19 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %20 = load i64, i64* %19
  %21 = alloca i64, i64 2, align 16
  %22 = ptrtoint i64* %21 to i64
  %23 = inttoptr i64 %22 to i64*
  store i64 %18, i64* %23
  %24 = add i64 %22, 8
  %25 = inttoptr i64 %24 to i64*
  store i64 %20, i64* %25
  %26 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %22, i64* %26
; # (++ X)
  %27 = inttoptr i64 %7 to i64*
  %28 = load i64, i64* %27
  %29 = getelementptr i64, i64* %27, i32 1
  %30 = load i64, i64* %29
; # (eval (++ X))
  %31 = and i64 %28, 6
  %32 = icmp ne i64 %31, 0
  br i1 %32, label %$11, label %$10
$11:
  br label %$9
$10:
  %33 = and i64 %28, 8
  %34 = icmp ne i64 %33, 0
  br i1 %34, label %$13, label %$12
$13:
  %35 = inttoptr i64 %28 to i64*
  %36 = load i64, i64* %35
  br label %$9
$12:
  %37 = call i64 @evList(i64 %28)
  br label %$9
$9:
  %38 = phi i64 [%28, %$11], [%36, %$13], [%37, %$12] ; # ->
; # (needNum Exe (eval (++ X)))
  %39 = and i64 %38, 6
  %40 = icmp ne i64 %39, 0
  br i1 %40, label %$15, label %$14
$14:
  call void @numErr(i64 %0, i64 %38)
  unreachable
$15:
; # (save (needNum Exe (eval (++ X))))
  %41 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %42 = load i64, i64* %41
  %43 = alloca i64, i64 2, align 16
  %44 = ptrtoint i64* %43 to i64
  %45 = inttoptr i64 %44 to i64*
  store i64 %38, i64* %45
  %46 = add i64 %44, 8
  %47 = inttoptr i64 %46 to i64*
  store i64 %42, i64* %47
  %48 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %44, i64* %48
; # (if (nil? (eval (car X))) ONE (save (needNum Exe @)))
; # (car X)
  %49 = inttoptr i64 %30 to i64*
  %50 = load i64, i64* %49
; # (eval (car X))
  %51 = and i64 %50, 6
  %52 = icmp ne i64 %51, 0
  br i1 %52, label %$18, label %$17
$18:
  br label %$16
$17:
  %53 = and i64 %50, 8
  %54 = icmp ne i64 %53, 0
  br i1 %54, label %$20, label %$19
$20:
  %55 = inttoptr i64 %50 to i64*
  %56 = load i64, i64* %55
  br label %$16
$19:
  %57 = call i64 @evList(i64 %50)
  br label %$16
$16:
  %58 = phi i64 [%50, %$18], [%56, %$20], [%57, %$19] ; # ->
; # (nil? (eval (car X)))
  %59 = icmp eq i64 %58, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %59, label %$21, label %$22
$21:
  %60 = phi i64 [%15, %$16] ; # N
  br label %$23
$22:
  %61 = phi i64 [%15, %$16] ; # N
; # (needNum Exe @)
  %62 = and i64 %58, 6
  %63 = icmp ne i64 %62, 0
  br i1 %63, label %$25, label %$24
$24:
  call void @numErr(i64 %0, i64 %58)
  unreachable
$25:
; # (save (needNum Exe @))
  %64 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %65 = load i64, i64* %64
  %66 = alloca i64, i64 2, align 16
  %67 = ptrtoint i64* %66 to i64
  %68 = inttoptr i64 %67 to i64*
  store i64 %58, i64* %68
  %69 = add i64 %67, 8
  %70 = inttoptr i64 %69 to i64*
  store i64 %65, i64* %70
  %71 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %67, i64* %71
  br label %$23
$23:
  %72 = phi i64 [%60, %$21], [%61, %$25] ; # N
  %73 = phi i64 [18, %$21], [%58, %$25] ; # ->
; # (when (or (== Inc ZERO) (sign? Inc)) (argErr Exe Inc))
; # (or (== Inc ZERO) (sign? Inc))
; # (== Inc ZERO)
  %74 = icmp eq i64 %73, 2
  br i1 %74, label %$26, label %$27
$27:
  %75 = phi i64 [%72, %$23] ; # N
; # (sign? Inc)
  %76 = and i64 %73, 8
  %77 = icmp ne i64 %76, 0
  br label %$26
$26:
  %78 = phi i64 [%72, %$23], [%75, %$27] ; # N
  %79 = phi i1 [1, %$23], [%77, %$27] ; # ->
  br i1 %79, label %$28, label %$29
$28:
  %80 = phi i64 [%78, %$26] ; # N
; # (argErr Exe Inc)
  call void @argErr(i64 %0, i64 %73)
  unreachable
$29:
  %81 = phi i64 [%78, %$26] ; # N
; # (let P R (if (le0 (cmpNum N Lim)) (while (le0 (cmpNum (setq N (ad...
; # (if (le0 (cmpNum N Lim)) (while (le0 (cmpNum (setq N (adds N Inc)...
; # (cmpNum N Lim)
  %82 = call i64 @cmpNum(i64 %81, i64 %38)
; # (le0 (cmpNum N Lim))
  %83 = icmp sle i64 %82, 0
  br i1 %83, label %$30, label %$31
$30:
  %84 = phi i64 [%81, %$29] ; # N
  %85 = phi i64 [%18, %$29] ; # P
; # (while (le0 (cmpNum (setq N (adds N Inc)) Lim)) (setq P (set 2 P ...
  br label %$33
$33:
  %86 = phi i64 [%84, %$30], [%91, %$34] ; # N
  %87 = phi i64 [%85, %$30], [%93, %$34] ; # P
; # (adds N Inc)
  %88 = call i64 @adds(i64 %86, i64 %73)
; # (cmpNum (setq N (adds N Inc)) Lim)
  %89 = call i64 @cmpNum(i64 %88, i64 %38)
; # (le0 (cmpNum (setq N (adds N Inc)) Lim))
  %90 = icmp sle i64 %89, 0
  br i1 %90, label %$34, label %$35
$34:
  %91 = phi i64 [%88, %$33] ; # N
  %92 = phi i64 [%87, %$33] ; # P
; # (set 2 P (cons N $Nil))
; # (cons N $Nil)
  %93 = call i64 @cons(i64 %91, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %94 = inttoptr i64 %92 to i64*
  %95 = getelementptr i64, i64* %94, i32 1
  store i64 %93, i64* %95
  br label %$33
$35:
  %96 = phi i64 [%88, %$33] ; # N
  %97 = phi i64 [%87, %$33] ; # P
  br label %$32
$31:
  %98 = phi i64 [%81, %$29] ; # N
  %99 = phi i64 [%18, %$29] ; # P
; # (while (ge0 (cmpNum (setq N (subs N Inc)) Lim)) (setq P (set 2 P ...
  br label %$36
$36:
  %100 = phi i64 [%98, %$31], [%105, %$37] ; # N
  %101 = phi i64 [%99, %$31], [%107, %$37] ; # P
; # (subs N Inc)
  %102 = call i64 @subs(i64 %100, i64 %73)
; # (cmpNum (setq N (subs N Inc)) Lim)
  %103 = call i64 @cmpNum(i64 %102, i64 %38)
; # (ge0 (cmpNum (setq N (subs N Inc)) Lim))
  %104 = icmp sge i64 %103, 0
  br i1 %104, label %$37, label %$38
$37:
  %105 = phi i64 [%102, %$36] ; # N
  %106 = phi i64 [%101, %$36] ; # P
; # (set 2 P (cons N $Nil))
; # (cons N $Nil)
  %107 = call i64 @cons(i64 %105, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %108 = inttoptr i64 %106 to i64*
  %109 = getelementptr i64, i64* %108, i32 1
  store i64 %107, i64* %109
  br label %$36
$38:
  %110 = phi i64 [%102, %$36] ; # N
  %111 = phi i64 [%101, %$36] ; # P
  br label %$32
$32:
  %112 = phi i64 [%96, %$35], [%110, %$38] ; # N
  %113 = phi i64 [%97, %$35], [%111, %$38] ; # P
; # (drop *Safe)
  %114 = inttoptr i64 %22 to i64*
  %115 = getelementptr i64, i64* %114, i32 1
  %116 = load i64, i64* %115
  %117 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %116, i64* %117
  ret i64 %18
}

define i64 @_Full(i64) align 8 {
$1:
; # (let X (eval (cadr Exe)) (loop (? (atom X) $T) (? (nil? (car X)) ...
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (loop (? (atom X) $T) (? (nil? (car X)) $Nil) (shift X))
  br label %$7
$7:
  %14 = phi i64 [%13, %$2], [%26, %$11] ; # X
; # (? (atom X) $T)
; # (atom X)
  %15 = and i64 %14, 15
  %16 = icmp ne i64 %15, 0
  br i1 %16, label %$10, label %$8
$10:
  %17 = phi i64 [%14, %$7] ; # X
  br label %$9
$8:
  %18 = phi i64 [%14, %$7] ; # X
; # (? (nil? (car X)) $Nil)
; # (car X)
  %19 = inttoptr i64 %18 to i64*
  %20 = load i64, i64* %19
; # (nil? (car X))
  %21 = icmp eq i64 %20, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %21, label %$12, label %$11
$12:
  %22 = phi i64 [%18, %$8] ; # X
  br label %$9
$11:
  %23 = phi i64 [%18, %$8] ; # X
; # (shift X)
  %24 = inttoptr i64 %23 to i64*
  %25 = getelementptr i64, i64* %24, i32 1
  %26 = load i64, i64* %25
  br label %$7
$9:
  %27 = phi i64 [%17, %$10], [%22, %$12] ; # X
  %28 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$12] ; # ->
  ret i64 %28
}

define i64 @_Make(i64) align 8 {
$1:
; # (let (Make (val $Make) Yoke (val $Yoke) R (link (push $Nil NIL)))...
; # (val $Make)
  %1 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 152) to i64) to i64*
  %2 = load i64, i64* %1
; # (val $Yoke)
  %3 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 160) to i64) to i64*
  %4 = load i64, i64* %3
; # (push $Nil NIL)
  %5 = alloca i64, i64 2, align 16
  %6 = ptrtoint i64* %5 to i64
  %7 = inttoptr i64 %6 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %7
; # (link (push $Nil NIL))
  %8 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %9 = load i64, i64* %8
  %10 = inttoptr i64 %6 to i64*
  %11 = getelementptr i64, i64* %10, i32 1
  store i64 %9, i64* %11
  %12 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %6, i64* %12
; # (set $Make (set $Yoke R))
; # (set $Yoke R)
  %13 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 160) to i64) to i64*
  store i64 %6, i64* %13
  %14 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 152) to i64) to i64*
  store i64 %6, i64* %14
; # (cdr Exe)
  %15 = inttoptr i64 %0 to i64*
  %16 = getelementptr i64, i64* %15, i32 1
  %17 = load i64, i64* %16
; # (exec (cdr Exe))
  br label %$2
$2:
  %18 = phi i64 [%17, %$1], [%30, %$5] ; # Prg
  %19 = inttoptr i64 %18 to i64*
  %20 = load i64, i64* %19
  %21 = getelementptr i64, i64* %19, i32 1
  %22 = load i64, i64* %21
  %23 = and i64 %20, 15
  %24 = icmp eq i64 %23, 0
  br i1 %24, label %$3, label %$4
$3:
  %25 = phi i64 [%22, %$2] ; # Prg
  %26 = call i64 @evList(i64 %20)
  br label %$4
$4:
  %27 = phi i64 [%22, %$2], [%25, %$3] ; # Prg
  %28 = and i64 %27, 15
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %$6, label %$5
$5:
  %30 = phi i64 [%27, %$4] ; # Prg
  br label %$2
$6:
  %31 = phi i64 [%27, %$4] ; # Prg
  %32 = phi i64 [0, %$4] ; # ->
; # (set $At2 (if (pair (val R)) (ofs (val $Make) -1) $Nil))
; # (if (pair (val R)) (ofs (val $Make) -1) $Nil)
; # (val R)
  %33 = inttoptr i64 %6 to i64*
  %34 = load i64, i64* %33
; # (pair (val R))
  %35 = and i64 %34, 15
  %36 = icmp eq i64 %35, 0
  br i1 %36, label %$7, label %$8
$7:
; # (val $Make)
  %37 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 152) to i64) to i64*
  %38 = load i64, i64* %37
; # (ofs (val $Make) -1)
  %39 = add i64 %38, -8
  br label %$9
$8:
  br label %$9
$9:
  %40 = phi i64 [%39, %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # ->
  %41 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 456) to i64) to i64*
  store i64 %40, i64* %41
; # (set $Make Make $Yoke Yoke)
  %42 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 152) to i64) to i64*
  store i64 %2, i64* %42
  %43 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 160) to i64) to i64*
  store i64 %4, i64* %43
; # (pop R)
  %44 = inttoptr i64 %6 to i64*
  %45 = load i64, i64* %44
  %46 = inttoptr i64 %6 to i64*
  %47 = getelementptr i64, i64* %46, i32 1
  %48 = load i64, i64* %47
  %49 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %48, i64* %49
  ret i64 %45
}

define i64 @_Made(i64) align 8 {
$1:
; # (let X (cdr Exe) (unless (val $Make) (makeErr Exe)) (when (pair X...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (unless (val $Make) (makeErr Exe))
; # (val $Make)
  %4 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 152) to i64) to i64*
  %5 = load i64, i64* %4
  %6 = icmp ne i64 %5, 0
  br i1 %6, label %$3, label %$2
$2:
  %7 = phi i64 [%3, %$1] ; # X
; # (makeErr Exe)
  call void @makeErr(i64 %0)
  unreachable
$3:
  %8 = phi i64 [%3, %$1] ; # X
; # (when (pair X) (if (atom (set (val $Yoke) (eval (++ X)))) (set $M...
; # (pair X)
  %9 = and i64 %8, 15
  %10 = icmp eq i64 %9, 0
  br i1 %10, label %$4, label %$5
$4:
  %11 = phi i64 [%8, %$3] ; # X
; # (if (atom (set (val $Yoke) (eval (++ X)))) (set $Make (val $Yoke)...
; # (set (val $Yoke) (eval (++ X)))
; # (val $Yoke)
  %12 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 160) to i64) to i64*
  %13 = load i64, i64* %12
; # (++ X)
  %14 = inttoptr i64 %11 to i64*
  %15 = load i64, i64* %14
  %16 = getelementptr i64, i64* %14, i32 1
  %17 = load i64, i64* %16
; # (eval (++ X))
  %18 = and i64 %15, 6
  %19 = icmp ne i64 %18, 0
  br i1 %19, label %$8, label %$7
$8:
  br label %$6
$7:
  %20 = and i64 %15, 8
  %21 = icmp ne i64 %20, 0
  br i1 %21, label %$10, label %$9
$10:
  %22 = inttoptr i64 %15 to i64*
  %23 = load i64, i64* %22
  br label %$6
$9:
  %24 = call i64 @evList(i64 %15)
  br label %$6
$6:
  %25 = phi i64 [%15, %$8], [%23, %$10], [%24, %$9] ; # ->
  %26 = inttoptr i64 %13 to i64*
  store i64 %25, i64* %26
; # (atom (set (val $Yoke) (eval (++ X))))
  %27 = and i64 %25, 15
  %28 = icmp ne i64 %27, 0
  br i1 %28, label %$11, label %$12
$11:
  %29 = phi i64 [%17, %$6] ; # X
; # (set $Make (val $Yoke))
; # (val $Yoke)
  %30 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 160) to i64) to i64*
  %31 = load i64, i64* %30
  %32 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 152) to i64) to i64*
  store i64 %31, i64* %32
  br label %$13
$12:
  %33 = phi i64 [%17, %$6] ; # X
; # (let Y (eval (car X)) (when (atom Y) (setq Y (val (val $Yoke))) (...
; # (car X)
  %34 = inttoptr i64 %33 to i64*
  %35 = load i64, i64* %34
; # (eval (car X))
  %36 = and i64 %35, 6
  %37 = icmp ne i64 %36, 0
  br i1 %37, label %$16, label %$15
$16:
  br label %$14
$15:
  %38 = and i64 %35, 8
  %39 = icmp ne i64 %38, 0
  br i1 %39, label %$18, label %$17
$18:
  %40 = inttoptr i64 %35 to i64*
  %41 = load i64, i64* %40
  br label %$14
$17:
  %42 = call i64 @evList(i64 %35)
  br label %$14
$14:
  %43 = phi i64 [%35, %$16], [%41, %$18], [%42, %$17] ; # ->
; # (when (atom Y) (setq Y (val (val $Yoke))) (while (pair (cdr Y)) (...
; # (atom Y)
  %44 = and i64 %43, 15
  %45 = icmp ne i64 %44, 0
  br i1 %45, label %$19, label %$20
$19:
  %46 = phi i64 [%33, %$14] ; # X
  %47 = phi i64 [%43, %$14] ; # Y
; # (val $Yoke)
  %48 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 160) to i64) to i64*
  %49 = load i64, i64* %48
; # (val (val $Yoke))
  %50 = inttoptr i64 %49 to i64*
  %51 = load i64, i64* %50
; # (while (pair (cdr Y)) (setq Y @))
  br label %$21
$21:
  %52 = phi i64 [%46, %$19], [%59, %$22] ; # X
  %53 = phi i64 [%51, %$19], [%56, %$22] ; # Y
; # (cdr Y)
  %54 = inttoptr i64 %53 to i64*
  %55 = getelementptr i64, i64* %54, i32 1
  %56 = load i64, i64* %55
; # (pair (cdr Y))
  %57 = and i64 %56, 15
  %58 = icmp eq i64 %57, 0
  br i1 %58, label %$22, label %$23
$22:
  %59 = phi i64 [%52, %$21] ; # X
  %60 = phi i64 [%53, %$21] ; # Y
  br label %$21
$23:
  %61 = phi i64 [%52, %$21] ; # X
  %62 = phi i64 [%53, %$21] ; # Y
  br label %$20
$20:
  %63 = phi i64 [%33, %$14], [%61, %$23] ; # X
  %64 = phi i64 [%43, %$14], [%62, %$23] ; # Y
; # (set $Make (ofs Y 1))
; # (ofs Y 1)
  %65 = add i64 %64, 8
  %66 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 152) to i64) to i64*
  store i64 %65, i64* %66
  br label %$13
$13:
  %67 = phi i64 [%29, %$11], [%63, %$20] ; # X
  %68 = phi i64 [%31, %$11], [%65, %$20] ; # ->
  br label %$5
$5:
  %69 = phi i64 [%8, %$3], [%67, %$13] ; # X
; # (val $Yoke)
  %70 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 160) to i64) to i64*
  %71 = load i64, i64* %70
; # (val (val $Yoke))
  %72 = inttoptr i64 %71 to i64*
  %73 = load i64, i64* %72
  ret i64 %73
}

define i64 @_Chain(i64) align 8 {
$1:
; # (let X (cdr Exe) (unless (val $Make) (makeErr Exe)) (loop (let Y ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (unless (val $Make) (makeErr Exe))
; # (val $Make)
  %4 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 152) to i64) to i64*
  %5 = load i64, i64* %4
  %6 = icmp ne i64 %5, 0
  br i1 %6, label %$3, label %$2
$2:
  %7 = phi i64 [%3, %$1] ; # X
; # (makeErr Exe)
  call void @makeErr(i64 %0)
  unreachable
$3:
  %8 = phi i64 [%3, %$1] ; # X
; # (loop (let Y (set (val $Make) (eval (++ X))) (when (pair Y) (let ...
  br label %$4
$4:
  %9 = phi i64 [%8, %$3], [%45, %$15] ; # X
; # (let Y (set (val $Make) (eval (++ X))) (when (pair Y) (let Z Y (w...
; # (set (val $Make) (eval (++ X)))
; # (val $Make)
  %10 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 152) to i64) to i64*
  %11 = load i64, i64* %10
; # (++ X)
  %12 = inttoptr i64 %9 to i64*
  %13 = load i64, i64* %12
  %14 = getelementptr i64, i64* %12, i32 1
  %15 = load i64, i64* %14
; # (eval (++ X))
  %16 = and i64 %13, 6
  %17 = icmp ne i64 %16, 0
  br i1 %17, label %$7, label %$6
$7:
  br label %$5
$6:
  %18 = and i64 %13, 8
  %19 = icmp ne i64 %18, 0
  br i1 %19, label %$9, label %$8
$9:
  %20 = inttoptr i64 %13 to i64*
  %21 = load i64, i64* %20
  br label %$5
$8:
  %22 = call i64 @evList(i64 %13)
  br label %$5
$5:
  %23 = phi i64 [%13, %$7], [%21, %$9], [%22, %$8] ; # ->
  %24 = inttoptr i64 %11 to i64*
  store i64 %23, i64* %24
; # (when (pair Y) (let Z Y (while (pair (cdr Z)) (setq Z @)) (set $M...
; # (pair Y)
  %25 = and i64 %23, 15
  %26 = icmp eq i64 %25, 0
  br i1 %26, label %$10, label %$11
$10:
  %27 = phi i64 [%15, %$5] ; # X
; # (let Z Y (while (pair (cdr Z)) (setq Z @)) (set $Make (ofs Z 1)))...
; # (while (pair (cdr Z)) (setq Z @))
  br label %$12
$12:
  %28 = phi i64 [%27, %$10], [%35, %$13] ; # X
  %29 = phi i64 [%23, %$10], [%32, %$13] ; # Z
; # (cdr Z)
  %30 = inttoptr i64 %29 to i64*
  %31 = getelementptr i64, i64* %30, i32 1
  %32 = load i64, i64* %31
; # (pair (cdr Z))
  %33 = and i64 %32, 15
  %34 = icmp eq i64 %33, 0
  br i1 %34, label %$13, label %$14
$13:
  %35 = phi i64 [%28, %$12] ; # X
  %36 = phi i64 [%29, %$12] ; # Z
  br label %$12
$14:
  %37 = phi i64 [%28, %$12] ; # X
  %38 = phi i64 [%29, %$12] ; # Z
; # (set $Make (ofs Z 1))
; # (ofs Z 1)
  %39 = add i64 %38, 8
  %40 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 152) to i64) to i64*
  store i64 %39, i64* %40
  br label %$11
$11:
  %41 = phi i64 [%15, %$5], [%37, %$14] ; # X
; # (? (atom X) Y)
; # (atom X)
  %42 = and i64 %41, 15
  %43 = icmp ne i64 %42, 0
  br i1 %43, label %$17, label %$15
$17:
  %44 = phi i64 [%41, %$11] ; # X
  br label %$16
$15:
  %45 = phi i64 [%41, %$11] ; # X
  br label %$4
$16:
  %46 = phi i64 [%44, %$17] ; # X
  %47 = phi i64 [%23, %$17] ; # ->
  ret i64 %47
}

define i64 @_Link(i64) align 8 {
$1:
; # (let X (cdr Exe) (unless (val $Make) (makeErr Exe)) (loop (let Y ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (unless (val $Make) (makeErr Exe))
; # (val $Make)
  %4 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 152) to i64) to i64*
  %5 = load i64, i64* %4
  %6 = icmp ne i64 %5, 0
  br i1 %6, label %$3, label %$2
$2:
  %7 = phi i64 [%3, %$1] ; # X
; # (makeErr Exe)
  call void @makeErr(i64 %0)
  unreachable
$3:
  %8 = phi i64 [%3, %$1] ; # X
; # (loop (let Y (eval (++ X)) (set $Make (ofs (set (val $Make) (cons...
  br label %$4
$4:
  %9 = phi i64 [%8, %$3], [%31, %$10] ; # X
; # (let Y (eval (++ X)) (set $Make (ofs (set (val $Make) (cons Y $Ni...
; # (++ X)
  %10 = inttoptr i64 %9 to i64*
  %11 = load i64, i64* %10
  %12 = getelementptr i64, i64* %10, i32 1
  %13 = load i64, i64* %12
; # (eval (++ X))
  %14 = and i64 %11, 6
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$7, label %$6
$7:
  br label %$5
$6:
  %16 = and i64 %11, 8
  %17 = icmp ne i64 %16, 0
  br i1 %17, label %$9, label %$8
$9:
  %18 = inttoptr i64 %11 to i64*
  %19 = load i64, i64* %18
  br label %$5
$8:
  %20 = call i64 @evList(i64 %11)
  br label %$5
$5:
  %21 = phi i64 [%11, %$7], [%19, %$9], [%20, %$8] ; # ->
; # (set $Make (ofs (set (val $Make) (cons Y $Nil)) 1))
; # (set (val $Make) (cons Y $Nil))
; # (val $Make)
  %22 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 152) to i64) to i64*
  %23 = load i64, i64* %22
; # (cons Y $Nil)
  %24 = call i64 @cons(i64 %21, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %25 = inttoptr i64 %23 to i64*
  store i64 %24, i64* %25
; # (ofs (set (val $Make) (cons Y $Nil)) 1)
  %26 = add i64 %24, 8
  %27 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 152) to i64) to i64*
  store i64 %26, i64* %27
; # (? (atom X) Y)
; # (atom X)
  %28 = and i64 %13, 15
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %$12, label %$10
$12:
  %30 = phi i64 [%13, %$5] ; # X
  br label %$11
$10:
  %31 = phi i64 [%13, %$5] ; # X
  br label %$4
$11:
  %32 = phi i64 [%30, %$12] ; # X
  %33 = phi i64 [%21, %$12] ; # ->
  ret i64 %33
}

define i64 @_Yoke(i64) align 8 {
$1:
; # (let X (cdr Exe) (unless (val $Make) (makeErr Exe)) (loop (let Y ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (unless (val $Make) (makeErr Exe))
; # (val $Make)
  %4 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 152) to i64) to i64*
  %5 = load i64, i64* %4
  %6 = icmp ne i64 %5, 0
  br i1 %6, label %$3, label %$2
$2:
  %7 = phi i64 [%3, %$1] ; # X
; # (makeErr Exe)
  call void @makeErr(i64 %0)
  unreachable
$3:
  %8 = phi i64 [%3, %$1] ; # X
; # (loop (let Y (eval (++ X)) (let P (val $Yoke) (set P (cons Y (val...
  br label %$4
$4:
  %9 = phi i64 [%8, %$3], [%45, %$10] ; # X
; # (let Y (eval (++ X)) (let P (val $Yoke) (set P (cons Y (val P))))...
; # (++ X)
  %10 = inttoptr i64 %9 to i64*
  %11 = load i64, i64* %10
  %12 = getelementptr i64, i64* %10, i32 1
  %13 = load i64, i64* %12
; # (eval (++ X))
  %14 = and i64 %11, 6
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$7, label %$6
$7:
  br label %$5
$6:
  %16 = and i64 %11, 8
  %17 = icmp ne i64 %16, 0
  br i1 %17, label %$9, label %$8
$9:
  %18 = inttoptr i64 %11 to i64*
  %19 = load i64, i64* %18
  br label %$5
$8:
  %20 = call i64 @evList(i64 %11)
  br label %$5
$5:
  %21 = phi i64 [%11, %$7], [%19, %$9], [%20, %$8] ; # ->
; # (let P (val $Yoke) (set P (cons Y (val P))))
; # (val $Yoke)
  %22 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 160) to i64) to i64*
  %23 = load i64, i64* %22
; # (set P (cons Y (val P)))
; # (val P)
  %24 = inttoptr i64 %23 to i64*
  %25 = load i64, i64* %24
; # (cons Y (val P))
  %26 = call i64 @cons(i64 %21, i64 %25)
  %27 = inttoptr i64 %23 to i64*
  store i64 %26, i64* %27
; # (? (atom X) (let Z (val $Make) (while (pair (val Z)) (setq Z (ofs...
; # (atom X)
  %28 = and i64 %13, 15
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %$12, label %$10
$12:
  %30 = phi i64 [%13, %$5] ; # X
; # (let Z (val $Make) (while (pair (val Z)) (setq Z (ofs @ 1))) (set...
; # (val $Make)
  %31 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 152) to i64) to i64*
  %32 = load i64, i64* %31
; # (while (pair (val Z)) (setq Z (ofs @ 1)))
  br label %$13
$13:
  %33 = phi i64 [%30, %$12], [%39, %$14] ; # X
  %34 = phi i64 [%32, %$12], [%41, %$14] ; # Z
; # (val Z)
  %35 = inttoptr i64 %34 to i64*
  %36 = load i64, i64* %35
; # (pair (val Z))
  %37 = and i64 %36, 15
  %38 = icmp eq i64 %37, 0
  br i1 %38, label %$14, label %$15
$14:
  %39 = phi i64 [%33, %$13] ; # X
  %40 = phi i64 [%34, %$13] ; # Z
; # (ofs @ 1)
  %41 = add i64 %36, 8
  br label %$13
$15:
  %42 = phi i64 [%33, %$13] ; # X
  %43 = phi i64 [%34, %$13] ; # Z
; # (set $Make Z)
  %44 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 152) to i64) to i64*
  store i64 %43, i64* %44
  br label %$11
$10:
  %45 = phi i64 [%13, %$5] ; # X
  br label %$4
$11:
  %46 = phi i64 [%42, %$15] ; # X
  %47 = phi i64 [%21, %$15] ; # ->
  ret i64 %47
}

define i64 @_Copy(i64) align 8 {
$1:
; # (let X (cdr Exe) (if (atom (setq X (eval (car X)))) X (let (Y (co...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (if (atom (setq X (eval (car X)))) X (let (Y (cons (car X) (cdr X...
; # (car X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (car X))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (atom (setq X (eval (car X))))
  %14 = and i64 %13, 15
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$7, label %$8
$7:
  %16 = phi i64 [%13, %$2] ; # X
  br label %$9
$8:
  %17 = phi i64 [%13, %$2] ; # X
; # (let (Y (cons (car X) (cdr X)) R (save Y) Z X) (while (pair (setq...
; # (car X)
  %18 = inttoptr i64 %17 to i64*
  %19 = load i64, i64* %18
; # (cdr X)
  %20 = inttoptr i64 %17 to i64*
  %21 = getelementptr i64, i64* %20, i32 1
  %22 = load i64, i64* %21
; # (cons (car X) (cdr X))
  %23 = call i64 @cons(i64 %19, i64 %22)
; # (save Y)
  %24 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %25 = load i64, i64* %24
  %26 = alloca i64, i64 2, align 16
  %27 = ptrtoint i64* %26 to i64
  %28 = inttoptr i64 %27 to i64*
  store i64 %23, i64* %28
  %29 = add i64 %27, 8
  %30 = inttoptr i64 %29 to i64*
  store i64 %25, i64* %30
  %31 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %27, i64* %31
; # (while (pair (setq X (cdr Y))) (? (== X Z) (set 2 Y R)) (setq Y (...
  br label %$10
$10:
  %32 = phi i64 [%17, %$8], [%46, %$13] ; # X
  %33 = phi i64 [%23, %$8], [%53, %$13] ; # Y
; # (cdr Y)
  %34 = inttoptr i64 %33 to i64*
  %35 = getelementptr i64, i64* %34, i32 1
  %36 = load i64, i64* %35
; # (pair (setq X (cdr Y)))
  %37 = and i64 %36, 15
  %38 = icmp eq i64 %37, 0
  br i1 %38, label %$11, label %$12
$11:
  %39 = phi i64 [%36, %$10] ; # X
  %40 = phi i64 [%33, %$10] ; # Y
; # (? (== X Z) (set 2 Y R))
; # (== X Z)
  %41 = icmp eq i64 %39, %17
  br i1 %41, label %$14, label %$13
$14:
  %42 = phi i64 [%39, %$11] ; # X
  %43 = phi i64 [%40, %$11] ; # Y
; # (set 2 Y R)
  %44 = inttoptr i64 %43 to i64*
  %45 = getelementptr i64, i64* %44, i32 1
  store i64 %23, i64* %45
  br label %$12
$13:
  %46 = phi i64 [%39, %$11] ; # X
  %47 = phi i64 [%40, %$11] ; # Y
; # (set 2 Y (cons (car X) (cdr X)))
; # (car X)
  %48 = inttoptr i64 %46 to i64*
  %49 = load i64, i64* %48
; # (cdr X)
  %50 = inttoptr i64 %46 to i64*
  %51 = getelementptr i64, i64* %50, i32 1
  %52 = load i64, i64* %51
; # (cons (car X) (cdr X))
  %53 = call i64 @cons(i64 %49, i64 %52)
  %54 = inttoptr i64 %47 to i64*
  %55 = getelementptr i64, i64* %54, i32 1
  store i64 %53, i64* %55
  br label %$10
$12:
  %56 = phi i64 [%36, %$10], [%42, %$14] ; # X
  %57 = phi i64 [%33, %$10], [%43, %$14] ; # Y
; # (drop *Safe)
  %58 = inttoptr i64 %27 to i64*
  %59 = getelementptr i64, i64* %58, i32 1
  %60 = load i64, i64* %59
  %61 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %60, i64* %61
  br label %$9
$9:
  %62 = phi i64 [%16, %$7], [%56, %$12] ; # X
  %63 = phi i64 [%16, %$7], [%23, %$12] ; # ->
  ret i64 %63
}

define i64 @_Mix(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (eval (car X))) (nond ((or (pair Y) (nil? Y))...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (car X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (car X))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (nond ((or (pair Y) (nil? Y)) Y) ((pair (shift X)) $Nil) (NIL (sa...
; # (or (pair Y) (nil? Y))
; # (pair Y)
  %14 = and i64 %13, 15
  %15 = icmp eq i64 %14, 0
  br i1 %15, label %$8, label %$9
$9:
  %16 = phi i64 [%3, %$2] ; # X
; # (nil? Y)
  %17 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$8
$8:
  %18 = phi i64 [%3, %$2], [%16, %$9] ; # X
  %19 = phi i1 [1, %$2], [%17, %$9] ; # ->
  br i1 %19, label %$10, label %$11
$11:
  %20 = phi i64 [%18, %$8] ; # X
  br label %$7
$10:
  %21 = phi i64 [%18, %$8] ; # X
; # (shift X)
  %22 = inttoptr i64 %21 to i64*
  %23 = getelementptr i64, i64* %22, i32 1
  %24 = load i64, i64* %23
; # (pair (shift X))
  %25 = and i64 %24, 15
  %26 = icmp eq i64 %25, 0
  br i1 %26, label %$12, label %$13
$13:
  %27 = phi i64 [%24, %$10] ; # X
  br label %$7
$12:
  %28 = phi i64 [%24, %$10] ; # X
; # (save Y (let (Z (cons (if (cnt? (car X)) (nth @ Y) (eval @)) $Nil...
  %29 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %30 = load i64, i64* %29
  %31 = alloca i64, i64 2, align 16
  %32 = ptrtoint i64* %31 to i64
  %33 = inttoptr i64 %32 to i64*
  store i64 %13, i64* %33
  %34 = add i64 %32, 8
  %35 = inttoptr i64 %34 to i64*
  store i64 %30, i64* %35
  %36 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %32, i64* %36
; # (let (Z (cons (if (cnt? (car X)) (nth @ Y) (eval @)) $Nil) R (sav...
; # (if (cnt? (car X)) (nth @ Y) (eval @))
; # (car X)
  %37 = inttoptr i64 %28 to i64*
  %38 = load i64, i64* %37
; # (cnt? (car X))
  %39 = and i64 %38, 2
  %40 = icmp ne i64 %39, 0
  br i1 %40, label %$14, label %$15
$14:
  %41 = phi i64 [%28, %$12] ; # X
; # (nth @ Y)
  %42 = lshr i64 %38, 4
  br label %$17
$17:
  %43 = phi i64 [%13, %$14], [%51, %$18] ; # X
  %44 = phi i64 [%42, %$14], [%48, %$18] ; # C
  %45 = sub i64 %44, 1
  %46 = icmp ne i64 %45, 0
  br i1 %46, label %$18, label %$19
$18:
  %47 = phi i64 [%43, %$17] ; # X
  %48 = phi i64 [%45, %$17] ; # C
  %49 = inttoptr i64 %47 to i64*
  %50 = getelementptr i64, i64* %49, i32 1
  %51 = load i64, i64* %50
  br label %$17
$19:
  %52 = phi i64 [%43, %$17] ; # X
  %53 = phi i64 [%45, %$17] ; # C
  %54 = and i64 %38, 8
  %55 = icmp ne i64 %54, 0
  br i1 %55, label %$20, label %$21
$20:
  %56 = phi i64 [%52, %$19] ; # X
  %57 = phi i64 [%53, %$19] ; # C
  %58 = inttoptr i64 %56 to i64*
  %59 = getelementptr i64, i64* %58, i32 1
  %60 = load i64, i64* %59
  br label %$22
$21:
  %61 = phi i64 [%52, %$19] ; # X
  %62 = phi i64 [%53, %$19] ; # C
  %63 = inttoptr i64 %61 to i64*
  %64 = load i64, i64* %63
  br label %$22
$22:
  %65 = phi i64 [%56, %$20], [%61, %$21] ; # X
  %66 = phi i64 [%57, %$20], [%62, %$21] ; # C
  %67 = phi i64 [%60, %$20], [%64, %$21] ; # ->
  br label %$16
$15:
  %68 = phi i64 [%28, %$12] ; # X
; # (eval @)
  %69 = and i64 %38, 6
  %70 = icmp ne i64 %69, 0
  br i1 %70, label %$25, label %$24
$25:
  br label %$23
$24:
  %71 = and i64 %38, 8
  %72 = icmp ne i64 %71, 0
  br i1 %72, label %$27, label %$26
$27:
  %73 = inttoptr i64 %38 to i64*
  %74 = load i64, i64* %73
  br label %$23
$26:
  %75 = call i64 @evList(i64 %38)
  br label %$23
$23:
  %76 = phi i64 [%38, %$25], [%74, %$27], [%75, %$26] ; # ->
  br label %$16
$16:
  %77 = phi i64 [%41, %$22], [%68, %$23] ; # X
  %78 = phi i64 [%67, %$22], [%76, %$23] ; # ->
; # (cons (if (cnt? (car X)) (nth @ Y) (eval @)) $Nil)
  %79 = call i64 @cons(i64 %78, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (save Z)
  %80 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %81 = load i64, i64* %80
  %82 = alloca i64, i64 2, align 16
  %83 = ptrtoint i64* %82 to i64
  %84 = inttoptr i64 %83 to i64*
  store i64 %79, i64* %84
  %85 = add i64 %83, 8
  %86 = inttoptr i64 %85 to i64*
  store i64 %81, i64* %86
  %87 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %83, i64* %87
; # (while (pair (shift X)) (setq Z (set 2 Z (cons (if (cnt? (car X))...
  br label %$28
$28:
  %88 = phi i64 [%77, %$16], [%139, %$33] ; # X
  %89 = phi i64 [%79, %$16], [%142, %$33] ; # Z
; # (shift X)
  %90 = inttoptr i64 %88 to i64*
  %91 = getelementptr i64, i64* %90, i32 1
  %92 = load i64, i64* %91
; # (pair (shift X))
  %93 = and i64 %92, 15
  %94 = icmp eq i64 %93, 0
  br i1 %94, label %$29, label %$30
$29:
  %95 = phi i64 [%92, %$28] ; # X
  %96 = phi i64 [%89, %$28] ; # Z
; # (set 2 Z (cons (if (cnt? (car X)) (nth @ Y) (eval @)) $Nil))
; # (if (cnt? (car X)) (nth @ Y) (eval @))
; # (car X)
  %97 = inttoptr i64 %95 to i64*
  %98 = load i64, i64* %97
; # (cnt? (car X))
  %99 = and i64 %98, 2
  %100 = icmp ne i64 %99, 0
  br i1 %100, label %$31, label %$32
$31:
  %101 = phi i64 [%95, %$29] ; # X
  %102 = phi i64 [%96, %$29] ; # Z
; # (nth @ Y)
  %103 = lshr i64 %98, 4
  br label %$34
$34:
  %104 = phi i64 [%13, %$31], [%112, %$35] ; # X
  %105 = phi i64 [%103, %$31], [%109, %$35] ; # C
  %106 = sub i64 %105, 1
  %107 = icmp ne i64 %106, 0
  br i1 %107, label %$35, label %$36
$35:
  %108 = phi i64 [%104, %$34] ; # X
  %109 = phi i64 [%106, %$34] ; # C
  %110 = inttoptr i64 %108 to i64*
  %111 = getelementptr i64, i64* %110, i32 1
  %112 = load i64, i64* %111
  br label %$34
$36:
  %113 = phi i64 [%104, %$34] ; # X
  %114 = phi i64 [%106, %$34] ; # C
  %115 = and i64 %98, 8
  %116 = icmp ne i64 %115, 0
  br i1 %116, label %$37, label %$38
$37:
  %117 = phi i64 [%113, %$36] ; # X
  %118 = phi i64 [%114, %$36] ; # C
  %119 = inttoptr i64 %117 to i64*
  %120 = getelementptr i64, i64* %119, i32 1
  %121 = load i64, i64* %120
  br label %$39
$38:
  %122 = phi i64 [%113, %$36] ; # X
  %123 = phi i64 [%114, %$36] ; # C
  %124 = inttoptr i64 %122 to i64*
  %125 = load i64, i64* %124
  br label %$39
$39:
  %126 = phi i64 [%117, %$37], [%122, %$38] ; # X
  %127 = phi i64 [%118, %$37], [%123, %$38] ; # C
  %128 = phi i64 [%121, %$37], [%125, %$38] ; # ->
  br label %$33
$32:
  %129 = phi i64 [%95, %$29] ; # X
  %130 = phi i64 [%96, %$29] ; # Z
; # (eval @)
  %131 = and i64 %98, 6
  %132 = icmp ne i64 %131, 0
  br i1 %132, label %$42, label %$41
$42:
  br label %$40
$41:
  %133 = and i64 %98, 8
  %134 = icmp ne i64 %133, 0
  br i1 %134, label %$44, label %$43
$44:
  %135 = inttoptr i64 %98 to i64*
  %136 = load i64, i64* %135
  br label %$40
$43:
  %137 = call i64 @evList(i64 %98)
  br label %$40
$40:
  %138 = phi i64 [%98, %$42], [%136, %$44], [%137, %$43] ; # ->
  br label %$33
$33:
  %139 = phi i64 [%101, %$39], [%129, %$40] ; # X
  %140 = phi i64 [%102, %$39], [%130, %$40] ; # Z
  %141 = phi i64 [%128, %$39], [%138, %$40] ; # ->
; # (cons (if (cnt? (car X)) (nth @ Y) (eval @)) $Nil)
  %142 = call i64 @cons(i64 %141, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %143 = inttoptr i64 %96 to i64*
  %144 = getelementptr i64, i64* %143, i32 1
  store i64 %142, i64* %144
  br label %$28
$30:
  %145 = phi i64 [%92, %$28] ; # X
  %146 = phi i64 [%89, %$28] ; # Z
; # drop
  %147 = inttoptr i64 %32 to i64*
  %148 = getelementptr i64, i64* %147, i32 1
  %149 = load i64, i64* %148
  %150 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %149, i64* %150
  br label %$7
$7:
  %151 = phi i64 [%20, %$11], [%27, %$13], [%145, %$30] ; # X
  %152 = phi i64 [%13, %$11], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$13], [%79, %$30] ; # ->
  ret i64 %152
}

define i64 @_Append(i64) align 8 {
$1:
; # (let X Exe (loop (? (atom (cdr (shift X))) (eval (car X))) (? (pa...
; # (loop (? (atom (cdr (shift X))) (eval (car X))) (? (pair (eval (c...
  br label %$2
$2:
  %1 = phi i64 [%0, %$1], [%139, %$16] ; # X
; # (? (atom (cdr (shift X))) (eval (car X)))
; # (shift X)
  %2 = inttoptr i64 %1 to i64*
  %3 = getelementptr i64, i64* %2, i32 1
  %4 = load i64, i64* %3
; # (cdr (shift X))
  %5 = inttoptr i64 %4 to i64*
  %6 = getelementptr i64, i64* %5, i32 1
  %7 = load i64, i64* %6
; # (atom (cdr (shift X)))
  %8 = and i64 %7, 15
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$5, label %$3
$5:
  %10 = phi i64 [%4, %$2] ; # X
; # (car X)
  %11 = inttoptr i64 %10 to i64*
  %12 = load i64, i64* %11
; # (eval (car X))
  %13 = and i64 %12, 6
  %14 = icmp ne i64 %13, 0
  br i1 %14, label %$8, label %$7
$8:
  br label %$6
$7:
  %15 = and i64 %12, 8
  %16 = icmp ne i64 %15, 0
  br i1 %16, label %$10, label %$9
$10:
  %17 = inttoptr i64 %12 to i64*
  %18 = load i64, i64* %17
  br label %$6
$9:
  %19 = call i64 @evList(i64 %12)
  br label %$6
$6:
  %20 = phi i64 [%12, %$8], [%18, %$10], [%19, %$9] ; # ->
  br label %$4
$3:
  %21 = phi i64 [%4, %$2] ; # X
; # (? (pair (eval (car X))) (let (Y @ R (save (cons (++ Y) Y)) Z R) ...
; # (car X)
  %22 = inttoptr i64 %21 to i64*
  %23 = load i64, i64* %22
; # (eval (car X))
  %24 = and i64 %23, 6
  %25 = icmp ne i64 %24, 0
  br i1 %25, label %$13, label %$12
$13:
  br label %$11
$12:
  %26 = and i64 %23, 8
  %27 = icmp ne i64 %26, 0
  br i1 %27, label %$15, label %$14
$15:
  %28 = inttoptr i64 %23 to i64*
  %29 = load i64, i64* %28
  br label %$11
$14:
  %30 = call i64 @evList(i64 %23)
  br label %$11
$11:
  %31 = phi i64 [%23, %$13], [%29, %$15], [%30, %$14] ; # ->
; # (pair (eval (car X)))
  %32 = and i64 %31, 15
  %33 = icmp eq i64 %32, 0
  br i1 %33, label %$17, label %$16
$17:
  %34 = phi i64 [%21, %$11] ; # X
; # (let (Y @ R (save (cons (++ Y) Y)) Z R) (while (pair Y) (setq Z (...
; # (++ Y)
  %35 = inttoptr i64 %31 to i64*
  %36 = load i64, i64* %35
  %37 = getelementptr i64, i64* %35, i32 1
  %38 = load i64, i64* %37
; # (cons (++ Y) Y)
  %39 = call i64 @cons(i64 %36, i64 %38)
; # (save (cons (++ Y) Y))
  %40 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %41 = load i64, i64* %40
  %42 = alloca i64, i64 2, align 16
  %43 = ptrtoint i64* %42 to i64
  %44 = inttoptr i64 %43 to i64*
  store i64 %39, i64* %44
  %45 = add i64 %43, 8
  %46 = inttoptr i64 %45 to i64*
  store i64 %41, i64* %46
  %47 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %43, i64* %47
; # (while (pair Y) (setq Z (set 2 Z (cons (++ Y) Y))))
  br label %$18
$18:
  %48 = phi i64 [%34, %$17], [%53, %$19] ; # X
  %49 = phi i64 [%38, %$17], [%59, %$19] ; # Y
  %50 = phi i64 [%39, %$17], [%60, %$19] ; # Z
; # (pair Y)
  %51 = and i64 %49, 15
  %52 = icmp eq i64 %51, 0
  br i1 %52, label %$19, label %$20
$19:
  %53 = phi i64 [%48, %$18] ; # X
  %54 = phi i64 [%49, %$18] ; # Y
  %55 = phi i64 [%50, %$18] ; # Z
; # (set 2 Z (cons (++ Y) Y))
; # (++ Y)
  %56 = inttoptr i64 %54 to i64*
  %57 = load i64, i64* %56
  %58 = getelementptr i64, i64* %56, i32 1
  %59 = load i64, i64* %58
; # (cons (++ Y) Y)
  %60 = call i64 @cons(i64 %57, i64 %59)
  %61 = inttoptr i64 %55 to i64*
  %62 = getelementptr i64, i64* %61, i32 1
  store i64 %60, i64* %62
  br label %$18
$20:
  %63 = phi i64 [%48, %$18] ; # X
  %64 = phi i64 [%49, %$18] ; # Y
  %65 = phi i64 [%50, %$18] ; # Z
; # (while (pair (cdr (shift X))) (save (setq Y (eval (car X))) (whil...
  br label %$21
$21:
  %66 = phi i64 [%63, %$20], [%113, %$31] ; # X
  %67 = phi i64 [%64, %$20], [%114, %$31] ; # Y
  %68 = phi i64 [%65, %$20], [%115, %$31] ; # Z
; # (shift X)
  %69 = inttoptr i64 %66 to i64*
  %70 = getelementptr i64, i64* %69, i32 1
  %71 = load i64, i64* %70
; # (cdr (shift X))
  %72 = inttoptr i64 %71 to i64*
  %73 = getelementptr i64, i64* %72, i32 1
  %74 = load i64, i64* %73
; # (pair (cdr (shift X)))
  %75 = and i64 %74, 15
  %76 = icmp eq i64 %75, 0
  br i1 %76, label %$22, label %$23
$22:
  %77 = phi i64 [%71, %$21] ; # X
  %78 = phi i64 [%67, %$21] ; # Y
  %79 = phi i64 [%68, %$21] ; # Z
; # (car X)
  %80 = inttoptr i64 %77 to i64*
  %81 = load i64, i64* %80
; # (eval (car X))
  %82 = and i64 %81, 6
  %83 = icmp ne i64 %82, 0
  br i1 %83, label %$26, label %$25
$26:
  br label %$24
$25:
  %84 = and i64 %81, 8
  %85 = icmp ne i64 %84, 0
  br i1 %85, label %$28, label %$27
$28:
  %86 = inttoptr i64 %81 to i64*
  %87 = load i64, i64* %86
  br label %$24
$27:
  %88 = call i64 @evList(i64 %81)
  br label %$24
$24:
  %89 = phi i64 [%81, %$26], [%87, %$28], [%88, %$27] ; # ->
; # (save (setq Y (eval (car X))) (while (pair Y) (setq Z (set 2 Z (c...
  %90 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %91 = load i64, i64* %90
  %92 = alloca i64, i64 2, align 16
  %93 = ptrtoint i64* %92 to i64
  %94 = inttoptr i64 %93 to i64*
  store i64 %89, i64* %94
  %95 = add i64 %93, 8
  %96 = inttoptr i64 %95 to i64*
  store i64 %91, i64* %96
  %97 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %93, i64* %97
; # (while (pair Y) (setq Z (set 2 Z (cons (++ Y) Y))))
  br label %$29
$29:
  %98 = phi i64 [%77, %$24], [%103, %$30] ; # X
  %99 = phi i64 [%89, %$24], [%109, %$30] ; # Y
  %100 = phi i64 [%79, %$24], [%110, %$30] ; # Z
; # (pair Y)
  %101 = and i64 %99, 15
  %102 = icmp eq i64 %101, 0
  br i1 %102, label %$30, label %$31
$30:
  %103 = phi i64 [%98, %$29] ; # X
  %104 = phi i64 [%99, %$29] ; # Y
  %105 = phi i64 [%100, %$29] ; # Z
; # (set 2 Z (cons (++ Y) Y))
; # (++ Y)
  %106 = inttoptr i64 %104 to i64*
  %107 = load i64, i64* %106
  %108 = getelementptr i64, i64* %106, i32 1
  %109 = load i64, i64* %108
; # (cons (++ Y) Y)
  %110 = call i64 @cons(i64 %107, i64 %109)
  %111 = inttoptr i64 %105 to i64*
  %112 = getelementptr i64, i64* %111, i32 1
  store i64 %110, i64* %112
  br label %$29
$31:
  %113 = phi i64 [%98, %$29] ; # X
  %114 = phi i64 [%99, %$29] ; # Y
  %115 = phi i64 [%100, %$29] ; # Z
; # drop
  %116 = inttoptr i64 %93 to i64*
  %117 = getelementptr i64, i64* %116, i32 1
  %118 = load i64, i64* %117
  %119 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %118, i64* %119
  br label %$21
$23:
  %120 = phi i64 [%71, %$21] ; # X
  %121 = phi i64 [%67, %$21] ; # Y
  %122 = phi i64 [%68, %$21] ; # Z
; # (set 2 Z (eval (car X)))
; # (car X)
  %123 = inttoptr i64 %120 to i64*
  %124 = load i64, i64* %123
; # (eval (car X))
  %125 = and i64 %124, 6
  %126 = icmp ne i64 %125, 0
  br i1 %126, label %$34, label %$33
$34:
  br label %$32
$33:
  %127 = and i64 %124, 8
  %128 = icmp ne i64 %127, 0
  br i1 %128, label %$36, label %$35
$36:
  %129 = inttoptr i64 %124 to i64*
  %130 = load i64, i64* %129
  br label %$32
$35:
  %131 = call i64 @evList(i64 %124)
  br label %$32
$32:
  %132 = phi i64 [%124, %$34], [%130, %$36], [%131, %$35] ; # ->
  %133 = inttoptr i64 %122 to i64*
  %134 = getelementptr i64, i64* %133, i32 1
  store i64 %132, i64* %134
; # (drop *Safe)
  %135 = inttoptr i64 %43 to i64*
  %136 = getelementptr i64, i64* %135, i32 1
  %137 = load i64, i64* %136
  %138 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %137, i64* %138
  br label %$4
$16:
  %139 = phi i64 [%21, %$11] ; # X
  br label %$2
$4:
  %140 = phi i64 [%10, %$6], [%120, %$32] ; # X
  %141 = phi i64 [%20, %$6], [%39, %$32] ; # ->
  ret i64 %141
}

define i64 @_Delete(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (save (eval (++ X))) L (save (eval (++ X))) F...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (save (eval (++ X)))
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %17 = load i64, i64* %16
  %18 = alloca i64, i64 2, align 16
  %19 = ptrtoint i64* %18 to i64
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = add i64 %19, 8
  %22 = inttoptr i64 %21 to i64*
  store i64 %17, i64* %22
  %23 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %19, i64* %23
; # (++ X)
  %24 = inttoptr i64 %7 to i64*
  %25 = load i64, i64* %24
  %26 = getelementptr i64, i64* %24, i32 1
  %27 = load i64, i64* %26
; # (eval (++ X))
  %28 = and i64 %25, 6
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %$9, label %$8
$9:
  br label %$7
$8:
  %30 = and i64 %25, 8
  %31 = icmp ne i64 %30, 0
  br i1 %31, label %$11, label %$10
$11:
  %32 = inttoptr i64 %25 to i64*
  %33 = load i64, i64* %32
  br label %$7
$10:
  %34 = call i64 @evList(i64 %25)
  br label %$7
$7:
  %35 = phi i64 [%25, %$9], [%33, %$11], [%34, %$10] ; # ->
; # (save (eval (++ X)))
  %36 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %37 = load i64, i64* %36
  %38 = alloca i64, i64 2, align 16
  %39 = ptrtoint i64* %38 to i64
  %40 = inttoptr i64 %39 to i64*
  store i64 %35, i64* %40
  %41 = add i64 %39, 8
  %42 = inttoptr i64 %41 to i64*
  store i64 %37, i64* %42
  %43 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %39, i64* %43
; # (car X)
  %44 = inttoptr i64 %27 to i64*
  %45 = load i64, i64* %44
; # (eval (car X))
  %46 = and i64 %45, 6
  %47 = icmp ne i64 %46, 0
  br i1 %47, label %$14, label %$13
$14:
  br label %$12
$13:
  %48 = and i64 %45, 8
  %49 = icmp ne i64 %48, 0
  br i1 %49, label %$16, label %$15
$16:
  %50 = inttoptr i64 %45 to i64*
  %51 = load i64, i64* %50
  br label %$12
$15:
  %52 = call i64 @evList(i64 %45)
  br label %$12
$12:
  %53 = phi i64 [%45, %$14], [%51, %$16], [%52, %$15] ; # ->
; # (nil? (eval (car X)))
  %54 = icmp eq i64 %53, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
; # (loop (? (atom L) L) (? (not (equal Y (car L))) (let R (save (set...
  br label %$17
$17:
  %55 = phi i64 [%27, %$12], [%126, %$32] ; # X
  %56 = phi i64 [%35, %$12], [%127, %$32] ; # L
; # (? (atom L) L)
; # (atom L)
  %57 = and i64 %56, 15
  %58 = icmp ne i64 %57, 0
  br i1 %58, label %$20, label %$18
$20:
  %59 = phi i64 [%55, %$17] ; # X
  %60 = phi i64 [%56, %$17] ; # L
  br label %$19
$18:
  %61 = phi i64 [%55, %$17] ; # X
  %62 = phi i64 [%56, %$17] ; # L
; # (? (not (equal Y (car L))) (let R (save (setq X (cons (car L) $Ni...
; # (car L)
  %63 = inttoptr i64 %62 to i64*
  %64 = load i64, i64* %63
; # (equal Y (car L))
  %65 = call i1 @equal(i64 %15, i64 %64)
; # (not (equal Y (car L)))
  %66 = icmp eq i1 %65, 0
  br i1 %66, label %$22, label %$21
$22:
  %67 = phi i64 [%61, %$18] ; # X
  %68 = phi i64 [%62, %$18] ; # L
; # (let R (save (setq X (cons (car L) $Nil))) (loop (? (atom (shift ...
; # (car L)
  %69 = inttoptr i64 %68 to i64*
  %70 = load i64, i64* %69
; # (cons (car L) $Nil)
  %71 = call i64 @cons(i64 %70, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (save (setq X (cons (car L) $Nil)))
  %72 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %73 = load i64, i64* %72
  %74 = alloca i64, i64 2, align 16
  %75 = ptrtoint i64* %74 to i64
  %76 = inttoptr i64 %75 to i64*
  store i64 %71, i64* %76
  %77 = add i64 %75, 8
  %78 = inttoptr i64 %77 to i64*
  store i64 %73, i64* %78
  %79 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %75, i64* %79
; # (loop (? (atom (shift L)) (set 2 X L)) (ifn (equal Y (car L)) (se...
  br label %$23
$23:
  %80 = phi i64 [%71, %$22], [%114, %$29] ; # X
  %81 = phi i64 [%68, %$22], [%115, %$29] ; # L
; # (? (atom (shift L)) (set 2 X L))
; # (shift L)
  %82 = inttoptr i64 %81 to i64*
  %83 = getelementptr i64, i64* %82, i32 1
  %84 = load i64, i64* %83
; # (atom (shift L))
  %85 = and i64 %84, 15
  %86 = icmp ne i64 %85, 0
  br i1 %86, label %$26, label %$24
$26:
  %87 = phi i64 [%80, %$23] ; # X
  %88 = phi i64 [%84, %$23] ; # L
; # (set 2 X L)
  %89 = inttoptr i64 %87 to i64*
  %90 = getelementptr i64, i64* %89, i32 1
  store i64 %88, i64* %90
  br label %$25
$24:
  %91 = phi i64 [%80, %$23] ; # X
  %92 = phi i64 [%84, %$23] ; # L
; # (ifn (equal Y (car L)) (setq X (set 2 X (cons (car L) $Nil))) (? ...
; # (car L)
  %93 = inttoptr i64 %92 to i64*
  %94 = load i64, i64* %93
; # (equal Y (car L))
  %95 = call i1 @equal(i64 %15, i64 %94)
  br i1 %95, label %$28, label %$27
$27:
  %96 = phi i64 [%91, %$24] ; # X
  %97 = phi i64 [%92, %$24] ; # L
; # (set 2 X (cons (car L) $Nil))
; # (car L)
  %98 = inttoptr i64 %97 to i64*
  %99 = load i64, i64* %98
; # (cons (car L) $Nil)
  %100 = call i64 @cons(i64 %99, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %101 = inttoptr i64 %96 to i64*
  %102 = getelementptr i64, i64* %101, i32 1
  store i64 %100, i64* %102
  br label %$29
$28:
  %103 = phi i64 [%91, %$24] ; # X
  %104 = phi i64 [%92, %$24] ; # L
; # (? F (set 2 X (cdr L)))
  br i1 %54, label %$31, label %$30
$31:
  %105 = phi i64 [%103, %$28] ; # X
  %106 = phi i64 [%104, %$28] ; # L
; # (set 2 X (cdr L))
; # (cdr L)
  %107 = inttoptr i64 %106 to i64*
  %108 = getelementptr i64, i64* %107, i32 1
  %109 = load i64, i64* %108
  %110 = inttoptr i64 %105 to i64*
  %111 = getelementptr i64, i64* %110, i32 1
  store i64 %109, i64* %111
  br label %$25
$30:
  %112 = phi i64 [%103, %$28] ; # X
  %113 = phi i64 [%104, %$28] ; # L
  br label %$29
$29:
  %114 = phi i64 [%100, %$27], [%112, %$30] ; # X
  %115 = phi i64 [%97, %$27], [%113, %$30] ; # L
  br label %$23
$25:
  %116 = phi i64 [%87, %$26], [%105, %$31] ; # X
  %117 = phi i64 [%88, %$26], [%106, %$31] ; # L
  %118 = phi i64 [%88, %$26], [%109, %$31] ; # ->
  br label %$19
$21:
  %119 = phi i64 [%61, %$18] ; # X
  %120 = phi i64 [%62, %$18] ; # L
; # (shift L)
  %121 = inttoptr i64 %120 to i64*
  %122 = getelementptr i64, i64* %121, i32 1
  %123 = load i64, i64* %122
; # (? F L)
  br i1 %54, label %$33, label %$32
$33:
  %124 = phi i64 [%119, %$21] ; # X
  %125 = phi i64 [%123, %$21] ; # L
  br label %$19
$32:
  %126 = phi i64 [%119, %$21] ; # X
  %127 = phi i64 [%123, %$21] ; # L
  br label %$17
$19:
  %128 = phi i64 [%59, %$20], [%116, %$25], [%124, %$33] ; # X
  %129 = phi i64 [%60, %$20], [%117, %$25], [%125, %$33] ; # L
  %130 = phi i64 [%60, %$20], [%71, %$25], [%125, %$33] ; # ->
; # (drop *Safe)
  %131 = inttoptr i64 %19 to i64*
  %132 = getelementptr i64, i64* %131, i32 1
  %133 = load i64, i64* %132
  %134 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %133, i64* %134
  ret i64 %130
}

define i64 @_Delq(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (save (eval (++ X))) L (save (eval (++ X))) F...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (save (eval (++ X)))
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %17 = load i64, i64* %16
  %18 = alloca i64, i64 2, align 16
  %19 = ptrtoint i64* %18 to i64
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = add i64 %19, 8
  %22 = inttoptr i64 %21 to i64*
  store i64 %17, i64* %22
  %23 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %19, i64* %23
; # (++ X)
  %24 = inttoptr i64 %7 to i64*
  %25 = load i64, i64* %24
  %26 = getelementptr i64, i64* %24, i32 1
  %27 = load i64, i64* %26
; # (eval (++ X))
  %28 = and i64 %25, 6
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %$9, label %$8
$9:
  br label %$7
$8:
  %30 = and i64 %25, 8
  %31 = icmp ne i64 %30, 0
  br i1 %31, label %$11, label %$10
$11:
  %32 = inttoptr i64 %25 to i64*
  %33 = load i64, i64* %32
  br label %$7
$10:
  %34 = call i64 @evList(i64 %25)
  br label %$7
$7:
  %35 = phi i64 [%25, %$9], [%33, %$11], [%34, %$10] ; # ->
; # (save (eval (++ X)))
  %36 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %37 = load i64, i64* %36
  %38 = alloca i64, i64 2, align 16
  %39 = ptrtoint i64* %38 to i64
  %40 = inttoptr i64 %39 to i64*
  store i64 %35, i64* %40
  %41 = add i64 %39, 8
  %42 = inttoptr i64 %41 to i64*
  store i64 %37, i64* %42
  %43 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %39, i64* %43
; # (car X)
  %44 = inttoptr i64 %27 to i64*
  %45 = load i64, i64* %44
; # (eval (car X))
  %46 = and i64 %45, 6
  %47 = icmp ne i64 %46, 0
  br i1 %47, label %$14, label %$13
$14:
  br label %$12
$13:
  %48 = and i64 %45, 8
  %49 = icmp ne i64 %48, 0
  br i1 %49, label %$16, label %$15
$16:
  %50 = inttoptr i64 %45 to i64*
  %51 = load i64, i64* %50
  br label %$12
$15:
  %52 = call i64 @evList(i64 %45)
  br label %$12
$12:
  %53 = phi i64 [%45, %$14], [%51, %$16], [%52, %$15] ; # ->
; # (nil? (eval (car X)))
  %54 = icmp eq i64 %53, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
; # (loop (? (atom L) L) (? (<> Y (car L)) (let R (save (setq X (cons...
  br label %$17
$17:
  %55 = phi i64 [%27, %$12], [%125, %$32] ; # X
  %56 = phi i64 [%35, %$12], [%126, %$32] ; # L
; # (? (atom L) L)
; # (atom L)
  %57 = and i64 %56, 15
  %58 = icmp ne i64 %57, 0
  br i1 %58, label %$20, label %$18
$20:
  %59 = phi i64 [%55, %$17] ; # X
  %60 = phi i64 [%56, %$17] ; # L
  br label %$19
$18:
  %61 = phi i64 [%55, %$17] ; # X
  %62 = phi i64 [%56, %$17] ; # L
; # (? (<> Y (car L)) (let R (save (setq X (cons (car L) $Nil))) (loo...
; # (car L)
  %63 = inttoptr i64 %62 to i64*
  %64 = load i64, i64* %63
; # (<> Y (car L))
  %65 = icmp ne i64 %15, %64
  br i1 %65, label %$22, label %$21
$22:
  %66 = phi i64 [%61, %$18] ; # X
  %67 = phi i64 [%62, %$18] ; # L
; # (let R (save (setq X (cons (car L) $Nil))) (loop (? (atom (shift ...
; # (car L)
  %68 = inttoptr i64 %67 to i64*
  %69 = load i64, i64* %68
; # (cons (car L) $Nil)
  %70 = call i64 @cons(i64 %69, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (save (setq X (cons (car L) $Nil)))
  %71 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %72 = load i64, i64* %71
  %73 = alloca i64, i64 2, align 16
  %74 = ptrtoint i64* %73 to i64
  %75 = inttoptr i64 %74 to i64*
  store i64 %70, i64* %75
  %76 = add i64 %74, 8
  %77 = inttoptr i64 %76 to i64*
  store i64 %72, i64* %77
  %78 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %74, i64* %78
; # (loop (? (atom (shift L)) (set 2 X L)) (if (<> Y (car L)) (setq X...
  br label %$23
$23:
  %79 = phi i64 [%70, %$22], [%113, %$29] ; # X
  %80 = phi i64 [%67, %$22], [%114, %$29] ; # L
; # (? (atom (shift L)) (set 2 X L))
; # (shift L)
  %81 = inttoptr i64 %80 to i64*
  %82 = getelementptr i64, i64* %81, i32 1
  %83 = load i64, i64* %82
; # (atom (shift L))
  %84 = and i64 %83, 15
  %85 = icmp ne i64 %84, 0
  br i1 %85, label %$26, label %$24
$26:
  %86 = phi i64 [%79, %$23] ; # X
  %87 = phi i64 [%83, %$23] ; # L
; # (set 2 X L)
  %88 = inttoptr i64 %86 to i64*
  %89 = getelementptr i64, i64* %88, i32 1
  store i64 %87, i64* %89
  br label %$25
$24:
  %90 = phi i64 [%79, %$23] ; # X
  %91 = phi i64 [%83, %$23] ; # L
; # (if (<> Y (car L)) (setq X (set 2 X (cons (car L) $Nil))) (? F (s...
; # (car L)
  %92 = inttoptr i64 %91 to i64*
  %93 = load i64, i64* %92
; # (<> Y (car L))
  %94 = icmp ne i64 %15, %93
  br i1 %94, label %$27, label %$28
$27:
  %95 = phi i64 [%90, %$24] ; # X
  %96 = phi i64 [%91, %$24] ; # L
; # (set 2 X (cons (car L) $Nil))
; # (car L)
  %97 = inttoptr i64 %96 to i64*
  %98 = load i64, i64* %97
; # (cons (car L) $Nil)
  %99 = call i64 @cons(i64 %98, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %100 = inttoptr i64 %95 to i64*
  %101 = getelementptr i64, i64* %100, i32 1
  store i64 %99, i64* %101
  br label %$29
$28:
  %102 = phi i64 [%90, %$24] ; # X
  %103 = phi i64 [%91, %$24] ; # L
; # (? F (set 2 X (cdr L)))
  br i1 %54, label %$31, label %$30
$31:
  %104 = phi i64 [%102, %$28] ; # X
  %105 = phi i64 [%103, %$28] ; # L
; # (set 2 X (cdr L))
; # (cdr L)
  %106 = inttoptr i64 %105 to i64*
  %107 = getelementptr i64, i64* %106, i32 1
  %108 = load i64, i64* %107
  %109 = inttoptr i64 %104 to i64*
  %110 = getelementptr i64, i64* %109, i32 1
  store i64 %108, i64* %110
  br label %$25
$30:
  %111 = phi i64 [%102, %$28] ; # X
  %112 = phi i64 [%103, %$28] ; # L
  br label %$29
$29:
  %113 = phi i64 [%99, %$27], [%111, %$30] ; # X
  %114 = phi i64 [%96, %$27], [%112, %$30] ; # L
  br label %$23
$25:
  %115 = phi i64 [%86, %$26], [%104, %$31] ; # X
  %116 = phi i64 [%87, %$26], [%105, %$31] ; # L
  %117 = phi i64 [%87, %$26], [%108, %$31] ; # ->
  br label %$19
$21:
  %118 = phi i64 [%61, %$18] ; # X
  %119 = phi i64 [%62, %$18] ; # L
; # (shift L)
  %120 = inttoptr i64 %119 to i64*
  %121 = getelementptr i64, i64* %120, i32 1
  %122 = load i64, i64* %121
; # (? F L)
  br i1 %54, label %$33, label %$32
$33:
  %123 = phi i64 [%118, %$21] ; # X
  %124 = phi i64 [%122, %$21] ; # L
  br label %$19
$32:
  %125 = phi i64 [%118, %$21] ; # X
  %126 = phi i64 [%122, %$21] ; # L
  br label %$17
$19:
  %127 = phi i64 [%59, %$20], [%115, %$25], [%123, %$33] ; # X
  %128 = phi i64 [%60, %$20], [%116, %$25], [%124, %$33] ; # L
  %129 = phi i64 [%60, %$20], [%70, %$25], [%124, %$33] ; # ->
; # (drop *Safe)
  %130 = inttoptr i64 %19 to i64*
  %131 = getelementptr i64, i64* %130, i32 1
  %132 = load i64, i64* %131
  %133 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %132, i64* %133
  ret i64 %129
}

define i64 @_Replace(i64) align 8 {
$1:
; # (let (X (cdr Exe) L (save (eval (car X)))) (if (atom L) @ (let (A...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (car X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (car X))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (save (eval (car X)))
  %14 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %15 = load i64, i64* %14
  %16 = alloca i64, i64 2, align 16
  %17 = ptrtoint i64* %16 to i64
  %18 = inttoptr i64 %17 to i64*
  store i64 %13, i64* %18
  %19 = add i64 %17, 8
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %17, i64* %21
; # (if (atom L) @ (let (A $Nil N 0 R (push NIL NIL)) (while (pair (s...
; # (atom L)
  %22 = and i64 %13, 15
  %23 = icmp ne i64 %22, 0
  br i1 %23, label %$7, label %$8
$7:
  %24 = phi i64 [%3, %$2] ; # X
  %25 = phi i64 [%13, %$2] ; # L
  br label %$9
$8:
  %26 = phi i64 [%3, %$2] ; # X
  %27 = phi i64 [%13, %$2] ; # L
; # (let (A $Nil N 0 R (push NIL NIL)) (while (pair (shift X)) (link ...
; # (push NIL NIL)
  %28 = alloca i64, i64 2, align 16
  %29 = ptrtoint i64* %28 to i64
; # (while (pair (shift X)) (link (push (eval (++ X)) NIL)) (setq A (...
  br label %$10
$10:
  %30 = phi i64 [%26, %$8], [%46, %$18] ; # X
  %31 = phi i64 [%27, %$8], [%40, %$18] ; # L
  %32 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$8], [%74, %$18] ; # A
  %33 = phi i64 [0, %$8], [%81, %$18] ; # N
; # (shift X)
  %34 = inttoptr i64 %30 to i64*
  %35 = getelementptr i64, i64* %34, i32 1
  %36 = load i64, i64* %35
; # (pair (shift X))
  %37 = and i64 %36, 15
  %38 = icmp eq i64 %37, 0
  br i1 %38, label %$11, label %$12
$11:
  %39 = phi i64 [%36, %$10] ; # X
  %40 = phi i64 [%31, %$10] ; # L
  %41 = phi i64 [%32, %$10] ; # A
  %42 = phi i64 [%33, %$10] ; # N
; # (++ X)
  %43 = inttoptr i64 %39 to i64*
  %44 = load i64, i64* %43
  %45 = getelementptr i64, i64* %43, i32 1
  %46 = load i64, i64* %45
; # (eval (++ X))
  %47 = and i64 %44, 6
  %48 = icmp ne i64 %47, 0
  br i1 %48, label %$15, label %$14
$15:
  br label %$13
$14:
  %49 = and i64 %44, 8
  %50 = icmp ne i64 %49, 0
  br i1 %50, label %$17, label %$16
$17:
  %51 = inttoptr i64 %44 to i64*
  %52 = load i64, i64* %51
  br label %$13
$16:
  %53 = call i64 @evList(i64 %44)
  br label %$13
$13:
  %54 = phi i64 [%44, %$15], [%52, %$17], [%53, %$16] ; # ->
; # (push (eval (++ X)) NIL)
  %55 = alloca i64, i64 2, align 16
  %56 = ptrtoint i64* %55 to i64
  %57 = inttoptr i64 %56 to i64*
  store i64 %54, i64* %57
; # (link (push (eval (++ X)) NIL))
  %58 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %59 = load i64, i64* %58
  %60 = inttoptr i64 %56 to i64*
  %61 = getelementptr i64, i64* %60, i32 1
  store i64 %59, i64* %61
  %62 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %56, i64* %62
; # (car X)
  %63 = inttoptr i64 %46 to i64*
  %64 = load i64, i64* %63
; # (eval (car X))
  %65 = and i64 %64, 6
  %66 = icmp ne i64 %65, 0
  br i1 %66, label %$20, label %$19
$20:
  br label %$18
$19:
  %67 = and i64 %64, 8
  %68 = icmp ne i64 %67, 0
  br i1 %68, label %$22, label %$21
$22:
  %69 = inttoptr i64 %64 to i64*
  %70 = load i64, i64* %69
  br label %$18
$21:
  %71 = call i64 @evList(i64 %64)
  br label %$18
$18:
  %72 = phi i64 [%64, %$20], [%70, %$22], [%71, %$21] ; # ->
; # (push (eval (car X)) NIL)
  %73 = alloca i64, i64 2, align 16
  %74 = ptrtoint i64* %73 to i64
  %75 = inttoptr i64 %74 to i64*
  store i64 %72, i64* %75
; # (link (push (eval (car X)) NIL))
  %76 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %77 = load i64, i64* %76
  %78 = inttoptr i64 %74 to i64*
  %79 = getelementptr i64, i64* %78, i32 1
  store i64 %77, i64* %79
  %80 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %74, i64* %80
; # (inc 'N)
  %81 = add i64 %42, 1
  br label %$10
$12:
  %82 = phi i64 [%36, %$10] ; # X
  %83 = phi i64 [%31, %$10] ; # L
  %84 = phi i64 [%32, %$10] ; # A
  %85 = phi i64 [%33, %$10] ; # N
; # (let (Y (++ L) Z A I N) (until (lt0 (dec 'I)) (let (V (++ Z) K (+...
; # (++ L)
  %86 = inttoptr i64 %83 to i64*
  %87 = load i64, i64* %86
  %88 = getelementptr i64, i64* %86, i32 1
  %89 = load i64, i64* %88
; # (until (lt0 (dec 'I)) (let (V (++ Z) K (++ Z)) (? (equal Y K) (se...
  br label %$23
$23:
  %90 = phi i64 [%82, %$12], [%122, %$26] ; # X
  %91 = phi i64 [%89, %$12], [%123, %$26] ; # L
  %92 = phi i64 [%84, %$12], [%124, %$26] ; # A
  %93 = phi i64 [%85, %$12], [%125, %$26] ; # N
  %94 = phi i64 [%87, %$12], [%126, %$26] ; # Y
  %95 = phi i64 [%84, %$12], [%127, %$26] ; # Z
  %96 = phi i64 [%85, %$12], [%128, %$26] ; # I
; # (dec 'I)
  %97 = sub i64 %96, 1
; # (lt0 (dec 'I))
  %98 = icmp slt i64 %97, 0
  br i1 %98, label %$25, label %$24
$24:
  %99 = phi i64 [%90, %$23] ; # X
  %100 = phi i64 [%91, %$23] ; # L
  %101 = phi i64 [%92, %$23] ; # A
  %102 = phi i64 [%93, %$23] ; # N
  %103 = phi i64 [%94, %$23] ; # Y
  %104 = phi i64 [%95, %$23] ; # Z
  %105 = phi i64 [%97, %$23] ; # I
; # (let (V (++ Z) K (++ Z)) (? (equal Y K) (setq Y V)))
; # (++ Z)
  %106 = inttoptr i64 %104 to i64*
  %107 = load i64, i64* %106
  %108 = getelementptr i64, i64* %106, i32 1
  %109 = load i64, i64* %108
; # (++ Z)
  %110 = inttoptr i64 %109 to i64*
  %111 = load i64, i64* %110
  %112 = getelementptr i64, i64* %110, i32 1
  %113 = load i64, i64* %112
; # (? (equal Y K) (setq Y V))
; # (equal Y K)
  %114 = call i1 @equal(i64 %103, i64 %111)
  br i1 %114, label %$27, label %$26
$27:
  %115 = phi i64 [%99, %$24] ; # X
  %116 = phi i64 [%100, %$24] ; # L
  %117 = phi i64 [%101, %$24] ; # A
  %118 = phi i64 [%102, %$24] ; # N
  %119 = phi i64 [%103, %$24] ; # Y
  %120 = phi i64 [%113, %$24] ; # Z
  %121 = phi i64 [%105, %$24] ; # I
  br label %$25
$26:
  %122 = phi i64 [%99, %$24] ; # X
  %123 = phi i64 [%100, %$24] ; # L
  %124 = phi i64 [%101, %$24] ; # A
  %125 = phi i64 [%102, %$24] ; # N
  %126 = phi i64 [%103, %$24] ; # Y
  %127 = phi i64 [%113, %$24] ; # Z
  %128 = phi i64 [%105, %$24] ; # I
  br label %$23
$25:
  %129 = phi i64 [%90, %$23], [%115, %$27] ; # X
  %130 = phi i64 [%91, %$23], [%116, %$27] ; # L
  %131 = phi i64 [%92, %$23], [%117, %$27] ; # A
  %132 = phi i64 [%93, %$23], [%118, %$27] ; # N
  %133 = phi i64 [%94, %$23], [%107, %$27] ; # Y
  %134 = phi i64 [%95, %$23], [%120, %$27] ; # Z
  %135 = phi i64 [%97, %$23], [%121, %$27] ; # I
; # (let P (set (link R) (cons Y $Nil)) (while (pair L) (setq Y (++ L...
; # (set (link R) (cons Y $Nil))
; # (link R)
  %136 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %137 = load i64, i64* %136
  %138 = inttoptr i64 %29 to i64*
  %139 = getelementptr i64, i64* %138, i32 1
  store i64 %137, i64* %139
  %140 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %29, i64* %140
; # (cons Y $Nil)
  %141 = call i64 @cons(i64 %133, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %142 = inttoptr i64 %29 to i64*
  store i64 %141, i64* %142
; # (while (pair L) (setq Y (++ L) Z A I N) (until (lt0 (dec 'I)) (le...
  br label %$28
$28:
  %143 = phi i64 [%129, %$25], [%208, %$33] ; # X
  %144 = phi i64 [%130, %$25], [%209, %$33] ; # L
  %145 = phi i64 [%131, %$25], [%210, %$33] ; # A
  %146 = phi i64 [%132, %$25], [%211, %$33] ; # N
  %147 = phi i64 [%133, %$25], [%212, %$33] ; # Y
  %148 = phi i64 [%134, %$25], [%213, %$33] ; # Z
  %149 = phi i64 [%135, %$25], [%214, %$33] ; # I
  %150 = phi i64 [%141, %$25], [%216, %$33] ; # P
; # (pair L)
  %151 = and i64 %144, 15
  %152 = icmp eq i64 %151, 0
  br i1 %152, label %$29, label %$30
$29:
  %153 = phi i64 [%143, %$28] ; # X
  %154 = phi i64 [%144, %$28] ; # L
  %155 = phi i64 [%145, %$28] ; # A
  %156 = phi i64 [%146, %$28] ; # N
  %157 = phi i64 [%147, %$28] ; # Y
  %158 = phi i64 [%148, %$28] ; # Z
  %159 = phi i64 [%149, %$28] ; # I
  %160 = phi i64 [%150, %$28] ; # P
; # (++ L)
  %161 = inttoptr i64 %154 to i64*
  %162 = load i64, i64* %161
  %163 = getelementptr i64, i64* %161, i32 1
  %164 = load i64, i64* %163
; # (until (lt0 (dec 'I)) (let (V (++ Z) K (++ Z)) (? (equal Y K) (se...
  br label %$31
$31:
  %165 = phi i64 [%153, %$29], [%200, %$34] ; # X
  %166 = phi i64 [%164, %$29], [%201, %$34] ; # L
  %167 = phi i64 [%155, %$29], [%202, %$34] ; # A
  %168 = phi i64 [%156, %$29], [%203, %$34] ; # N
  %169 = phi i64 [%162, %$29], [%204, %$34] ; # Y
  %170 = phi i64 [%155, %$29], [%205, %$34] ; # Z
  %171 = phi i64 [%156, %$29], [%206, %$34] ; # I
  %172 = phi i64 [%160, %$29], [%207, %$34] ; # P
; # (dec 'I)
  %173 = sub i64 %171, 1
; # (lt0 (dec 'I))
  %174 = icmp slt i64 %173, 0
  br i1 %174, label %$33, label %$32
$32:
  %175 = phi i64 [%165, %$31] ; # X
  %176 = phi i64 [%166, %$31] ; # L
  %177 = phi i64 [%167, %$31] ; # A
  %178 = phi i64 [%168, %$31] ; # N
  %179 = phi i64 [%169, %$31] ; # Y
  %180 = phi i64 [%170, %$31] ; # Z
  %181 = phi i64 [%173, %$31] ; # I
  %182 = phi i64 [%172, %$31] ; # P
; # (let (V (++ Z) K (++ Z)) (? (equal Y K) (setq Y V)))
; # (++ Z)
  %183 = inttoptr i64 %180 to i64*
  %184 = load i64, i64* %183
  %185 = getelementptr i64, i64* %183, i32 1
  %186 = load i64, i64* %185
; # (++ Z)
  %187 = inttoptr i64 %186 to i64*
  %188 = load i64, i64* %187
  %189 = getelementptr i64, i64* %187, i32 1
  %190 = load i64, i64* %189
; # (? (equal Y K) (setq Y V))
; # (equal Y K)
  %191 = call i1 @equal(i64 %179, i64 %188)
  br i1 %191, label %$35, label %$34
$35:
  %192 = phi i64 [%175, %$32] ; # X
  %193 = phi i64 [%176, %$32] ; # L
  %194 = phi i64 [%177, %$32] ; # A
  %195 = phi i64 [%178, %$32] ; # N
  %196 = phi i64 [%179, %$32] ; # Y
  %197 = phi i64 [%190, %$32] ; # Z
  %198 = phi i64 [%181, %$32] ; # I
  %199 = phi i64 [%182, %$32] ; # P
  br label %$33
$34:
  %200 = phi i64 [%175, %$32] ; # X
  %201 = phi i64 [%176, %$32] ; # L
  %202 = phi i64 [%177, %$32] ; # A
  %203 = phi i64 [%178, %$32] ; # N
  %204 = phi i64 [%179, %$32] ; # Y
  %205 = phi i64 [%190, %$32] ; # Z
  %206 = phi i64 [%181, %$32] ; # I
  %207 = phi i64 [%182, %$32] ; # P
  br label %$31
$33:
  %208 = phi i64 [%165, %$31], [%192, %$35] ; # X
  %209 = phi i64 [%166, %$31], [%193, %$35] ; # L
  %210 = phi i64 [%167, %$31], [%194, %$35] ; # A
  %211 = phi i64 [%168, %$31], [%195, %$35] ; # N
  %212 = phi i64 [%169, %$31], [%184, %$35] ; # Y
  %213 = phi i64 [%170, %$31], [%197, %$35] ; # Z
  %214 = phi i64 [%173, %$31], [%198, %$35] ; # I
  %215 = phi i64 [%172, %$31], [%199, %$35] ; # P
; # (set 2 P (cons Y $Nil))
; # (cons Y $Nil)
  %216 = call i64 @cons(i64 %212, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %217 = inttoptr i64 %215 to i64*
  %218 = getelementptr i64, i64* %217, i32 1
  store i64 %216, i64* %218
  br label %$28
$30:
  %219 = phi i64 [%143, %$28] ; # X
  %220 = phi i64 [%144, %$28] ; # L
  %221 = phi i64 [%145, %$28] ; # A
  %222 = phi i64 [%146, %$28] ; # N
  %223 = phi i64 [%147, %$28] ; # Y
  %224 = phi i64 [%148, %$28] ; # Z
  %225 = phi i64 [%149, %$28] ; # I
  %226 = phi i64 [%150, %$28] ; # P
; # (val R)
  %227 = inttoptr i64 %29 to i64*
  %228 = load i64, i64* %227
  br label %$9
$9:
  %229 = phi i64 [%24, %$7], [%219, %$30] ; # X
  %230 = phi i64 [%25, %$7], [%220, %$30] ; # L
  %231 = phi i64 [%13, %$7], [%228, %$30] ; # ->
; # (drop *Safe)
  %232 = inttoptr i64 %17 to i64*
  %233 = getelementptr i64, i64* %232, i32 1
  %234 = load i64, i64* %233
  %235 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %234, i64* %235
  ret i64 %231
}

define i64 @_Insert(i64) align 8 {
$1:
; # (let (X (cdr Exe) N (evCnt Exe X) L (save (eval (car (shift X))))...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (evCnt Exe X)
  %4 = call i64 @evCnt(i64 %0, i64 %3)
; # (shift X)
  %5 = inttoptr i64 %3 to i64*
  %6 = getelementptr i64, i64* %5, i32 1
  %7 = load i64, i64* %6
; # (car (shift X))
  %8 = inttoptr i64 %7 to i64*
  %9 = load i64, i64* %8
; # (eval (car (shift X)))
  %10 = and i64 %9, 6
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$4, label %$3
$4:
  br label %$2
$3:
  %12 = and i64 %9, 8
  %13 = icmp ne i64 %12, 0
  br i1 %13, label %$6, label %$5
$6:
  %14 = inttoptr i64 %9 to i64*
  %15 = load i64, i64* %14
  br label %$2
$5:
  %16 = call i64 @evList(i64 %9)
  br label %$2
$2:
  %17 = phi i64 [%9, %$4], [%15, %$6], [%16, %$5] ; # ->
; # (save (eval (car (shift X))))
  %18 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %19 = load i64, i64* %18
  %20 = alloca i64, i64 2, align 16
  %21 = ptrtoint i64* %20 to i64
  %22 = inttoptr i64 %21 to i64*
  store i64 %17, i64* %22
  %23 = add i64 %21, 8
  %24 = inttoptr i64 %23 to i64*
  store i64 %19, i64* %24
  %25 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %21, i64* %25
; # (shift X)
  %26 = inttoptr i64 %7 to i64*
  %27 = getelementptr i64, i64* %26, i32 1
  %28 = load i64, i64* %27
; # (car (shift X))
  %29 = inttoptr i64 %28 to i64*
  %30 = load i64, i64* %29
; # (eval (car (shift X)))
  %31 = and i64 %30, 6
  %32 = icmp ne i64 %31, 0
  br i1 %32, label %$9, label %$8
$9:
  br label %$7
$8:
  %33 = and i64 %30, 8
  %34 = icmp ne i64 %33, 0
  br i1 %34, label %$11, label %$10
$11:
  %35 = inttoptr i64 %30 to i64*
  %36 = load i64, i64* %35
  br label %$7
$10:
  %37 = call i64 @evList(i64 %30)
  br label %$7
$7:
  %38 = phi i64 [%30, %$9], [%36, %$11], [%37, %$10] ; # ->
; # (if (or (atom L) (le0 (dec 'N))) (cons X L) (let (Y (cons (car L)...
; # (or (atom L) (le0 (dec 'N)))
; # (atom L)
  %39 = and i64 %17, 15
  %40 = icmp ne i64 %39, 0
  br i1 %40, label %$12, label %$13
$13:
  %41 = phi i64 [%38, %$7] ; # X
  %42 = phi i64 [%4, %$7] ; # N
  %43 = phi i64 [%17, %$7] ; # L
; # (dec 'N)
  %44 = sub i64 %42, 1
; # (le0 (dec 'N))
  %45 = icmp sle i64 %44, 0
  br label %$12
$12:
  %46 = phi i64 [%38, %$7], [%41, %$13] ; # X
  %47 = phi i64 [%4, %$7], [%44, %$13] ; # N
  %48 = phi i64 [%17, %$7], [%43, %$13] ; # L
  %49 = phi i1 [1, %$7], [%45, %$13] ; # ->
  br i1 %49, label %$14, label %$15
$14:
  %50 = phi i64 [%46, %$12] ; # X
  %51 = phi i64 [%47, %$12] ; # N
  %52 = phi i64 [%48, %$12] ; # L
; # (cons X L)
  %53 = call i64 @cons(i64 %50, i64 %52)
  br label %$16
$15:
  %54 = phi i64 [%46, %$12] ; # X
  %55 = phi i64 [%47, %$12] ; # N
  %56 = phi i64 [%48, %$12] ; # L
; # (let (Y (cons (car L) $Nil) R (save Y)) (while (and (pair (shift ...
; # (car L)
  %57 = inttoptr i64 %56 to i64*
  %58 = load i64, i64* %57
; # (cons (car L) $Nil)
  %59 = call i64 @cons(i64 %58, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (save Y)
  %60 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %61 = load i64, i64* %60
  %62 = alloca i64, i64 2, align 16
  %63 = ptrtoint i64* %62 to i64
  %64 = inttoptr i64 %63 to i64*
  store i64 %59, i64* %64
  %65 = add i64 %63, 8
  %66 = inttoptr i64 %65 to i64*
  store i64 %61, i64* %66
  %67 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %63, i64* %67
; # (while (and (pair (shift L)) (dec 'N)) (setq Y (set 2 Y (cons (ca...
  br label %$17
$17:
  %68 = phi i64 [%54, %$15], [%88, %$20] ; # X
  %69 = phi i64 [%55, %$15], [%89, %$20] ; # N
  %70 = phi i64 [%56, %$15], [%90, %$20] ; # L
  %71 = phi i64 [%59, %$15], [%94, %$20] ; # Y
; # (and (pair (shift L)) (dec 'N))
; # (shift L)
  %72 = inttoptr i64 %70 to i64*
  %73 = getelementptr i64, i64* %72, i32 1
  %74 = load i64, i64* %73
; # (pair (shift L))
  %75 = and i64 %74, 15
  %76 = icmp eq i64 %75, 0
  br i1 %76, label %$19, label %$18
$19:
  %77 = phi i64 [%68, %$17] ; # X
  %78 = phi i64 [%69, %$17] ; # N
  %79 = phi i64 [%74, %$17] ; # L
  %80 = phi i64 [%71, %$17] ; # Y
; # (dec 'N)
  %81 = sub i64 %78, 1
  %82 = icmp ne i64 %81, 0
  br label %$18
$18:
  %83 = phi i64 [%68, %$17], [%77, %$19] ; # X
  %84 = phi i64 [%69, %$17], [%81, %$19] ; # N
  %85 = phi i64 [%74, %$17], [%79, %$19] ; # L
  %86 = phi i64 [%71, %$17], [%80, %$19] ; # Y
  %87 = phi i1 [0, %$17], [%82, %$19] ; # ->
  br i1 %87, label %$20, label %$21
$20:
  %88 = phi i64 [%83, %$18] ; # X
  %89 = phi i64 [%84, %$18] ; # N
  %90 = phi i64 [%85, %$18] ; # L
  %91 = phi i64 [%86, %$18] ; # Y
; # (set 2 Y (cons (car L) $Nil))
; # (car L)
  %92 = inttoptr i64 %90 to i64*
  %93 = load i64, i64* %92
; # (cons (car L) $Nil)
  %94 = call i64 @cons(i64 %93, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %95 = inttoptr i64 %91 to i64*
  %96 = getelementptr i64, i64* %95, i32 1
  store i64 %94, i64* %96
  br label %$17
$21:
  %97 = phi i64 [%83, %$18] ; # X
  %98 = phi i64 [%84, %$18] ; # N
  %99 = phi i64 [%85, %$18] ; # L
  %100 = phi i64 [%86, %$18] ; # Y
; # (set 2 Y (cons X L))
; # (cons X L)
  %101 = call i64 @cons(i64 %97, i64 %99)
  %102 = inttoptr i64 %100 to i64*
  %103 = getelementptr i64, i64* %102, i32 1
  store i64 %101, i64* %103
  br label %$16
$16:
  %104 = phi i64 [%50, %$14], [%97, %$21] ; # X
  %105 = phi i64 [%51, %$14], [%98, %$21] ; # N
  %106 = phi i64 [%52, %$14], [%99, %$21] ; # L
  %107 = phi i64 [%53, %$14], [%59, %$21] ; # ->
; # (drop *Safe)
  %108 = inttoptr i64 %21 to i64*
  %109 = getelementptr i64, i64* %108, i32 1
  %110 = load i64, i64* %109
  %111 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %110, i64* %111
  ret i64 %107
}

define i64 @_Remove(i64) align 8 {
$1:
; # (let (X (cdr Exe) N (evCnt Exe X) L (save (eval (car (shift X))))...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (evCnt Exe X)
  %4 = call i64 @evCnt(i64 %0, i64 %3)
; # (shift X)
  %5 = inttoptr i64 %3 to i64*
  %6 = getelementptr i64, i64* %5, i32 1
  %7 = load i64, i64* %6
; # (car (shift X))
  %8 = inttoptr i64 %7 to i64*
  %9 = load i64, i64* %8
; # (eval (car (shift X)))
  %10 = and i64 %9, 6
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$4, label %$3
$4:
  br label %$2
$3:
  %12 = and i64 %9, 8
  %13 = icmp ne i64 %12, 0
  br i1 %13, label %$6, label %$5
$6:
  %14 = inttoptr i64 %9 to i64*
  %15 = load i64, i64* %14
  br label %$2
$5:
  %16 = call i64 @evList(i64 %9)
  br label %$2
$2:
  %17 = phi i64 [%9, %$4], [%15, %$6], [%16, %$5] ; # ->
; # (save (eval (car (shift X))))
  %18 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %19 = load i64, i64* %18
  %20 = alloca i64, i64 2, align 16
  %21 = ptrtoint i64* %20 to i64
  %22 = inttoptr i64 %21 to i64*
  store i64 %17, i64* %22
  %23 = add i64 %21, 8
  %24 = inttoptr i64 %23 to i64*
  store i64 %19, i64* %24
  %25 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %21, i64* %25
; # (cond ((or (atom L) (lt0 (dec 'N))) L) ((=0 N) (cdr L)) (T (let (...
; # (or (atom L) (lt0 (dec 'N)))
; # (atom L)
  %26 = and i64 %17, 15
  %27 = icmp ne i64 %26, 0
  br i1 %27, label %$8, label %$9
$9:
  %28 = phi i64 [%4, %$2] ; # N
  %29 = phi i64 [%17, %$2] ; # L
; # (dec 'N)
  %30 = sub i64 %28, 1
; # (lt0 (dec 'N))
  %31 = icmp slt i64 %30, 0
  br label %$8
$8:
  %32 = phi i64 [%4, %$2], [%30, %$9] ; # N
  %33 = phi i64 [%17, %$2], [%29, %$9] ; # L
  %34 = phi i1 [1, %$2], [%31, %$9] ; # ->
  br i1 %34, label %$11, label %$10
$11:
  %35 = phi i64 [%32, %$8] ; # N
  %36 = phi i64 [%33, %$8] ; # L
  br label %$7
$10:
  %37 = phi i64 [%32, %$8] ; # N
  %38 = phi i64 [%33, %$8] ; # L
; # (=0 N)
  %39 = icmp eq i64 %37, 0
  br i1 %39, label %$13, label %$12
$13:
  %40 = phi i64 [%37, %$10] ; # N
  %41 = phi i64 [%38, %$10] ; # L
; # (cdr L)
  %42 = inttoptr i64 %41 to i64*
  %43 = getelementptr i64, i64* %42, i32 1
  %44 = load i64, i64* %43
  br label %$7
$12:
  %45 = phi i64 [%37, %$10] ; # N
  %46 = phi i64 [%38, %$10] ; # L
; # (let (Y (cons (car L) $Nil) R (save Y)) (loop (? (atom (shift L))...
; # (car L)
  %47 = inttoptr i64 %46 to i64*
  %48 = load i64, i64* %47
; # (cons (car L) $Nil)
  %49 = call i64 @cons(i64 %48, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (save Y)
  %50 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %51 = load i64, i64* %50
  %52 = alloca i64, i64 2, align 16
  %53 = ptrtoint i64* %52 to i64
  %54 = inttoptr i64 %53 to i64*
  store i64 %49, i64* %54
  %55 = add i64 %53, 8
  %56 = inttoptr i64 %55 to i64*
  store i64 %51, i64* %56
  %57 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %53, i64* %57
; # (loop (? (atom (shift L)) (set 2 Y L)) (? (=0 (dec 'N)) (set 2 Y ...
  br label %$14
$14:
  %58 = phi i64 [%45, %$12], [%84, %$18] ; # N
  %59 = phi i64 [%46, %$12], [%85, %$18] ; # L
  %60 = phi i64 [%49, %$12], [%89, %$18] ; # Y
; # (? (atom (shift L)) (set 2 Y L))
; # (shift L)
  %61 = inttoptr i64 %59 to i64*
  %62 = getelementptr i64, i64* %61, i32 1
  %63 = load i64, i64* %62
; # (atom (shift L))
  %64 = and i64 %63, 15
  %65 = icmp ne i64 %64, 0
  br i1 %65, label %$17, label %$15
$17:
  %66 = phi i64 [%58, %$14] ; # N
  %67 = phi i64 [%63, %$14] ; # L
  %68 = phi i64 [%60, %$14] ; # Y
; # (set 2 Y L)
  %69 = inttoptr i64 %68 to i64*
  %70 = getelementptr i64, i64* %69, i32 1
  store i64 %67, i64* %70
  br label %$16
$15:
  %71 = phi i64 [%58, %$14] ; # N
  %72 = phi i64 [%63, %$14] ; # L
  %73 = phi i64 [%60, %$14] ; # Y
; # (? (=0 (dec 'N)) (set 2 Y (cdr L)))
; # (dec 'N)
  %74 = sub i64 %71, 1
; # (=0 (dec 'N))
  %75 = icmp eq i64 %74, 0
  br i1 %75, label %$19, label %$18
$19:
  %76 = phi i64 [%74, %$15] ; # N
  %77 = phi i64 [%72, %$15] ; # L
  %78 = phi i64 [%73, %$15] ; # Y
; # (set 2 Y (cdr L))
; # (cdr L)
  %79 = inttoptr i64 %77 to i64*
  %80 = getelementptr i64, i64* %79, i32 1
  %81 = load i64, i64* %80
  %82 = inttoptr i64 %78 to i64*
  %83 = getelementptr i64, i64* %82, i32 1
  store i64 %81, i64* %83
  br label %$16
$18:
  %84 = phi i64 [%74, %$15] ; # N
  %85 = phi i64 [%72, %$15] ; # L
  %86 = phi i64 [%73, %$15] ; # Y
; # (set 2 Y (cons (car L) $Nil))
; # (car L)
  %87 = inttoptr i64 %85 to i64*
  %88 = load i64, i64* %87
; # (cons (car L) $Nil)
  %89 = call i64 @cons(i64 %88, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %90 = inttoptr i64 %86 to i64*
  %91 = getelementptr i64, i64* %90, i32 1
  store i64 %89, i64* %91
  br label %$14
$16:
  %92 = phi i64 [%66, %$17], [%76, %$19] ; # N
  %93 = phi i64 [%67, %$17], [%77, %$19] ; # L
  %94 = phi i64 [%68, %$17], [%78, %$19] ; # Y
  %95 = phi i64 [%67, %$17], [%81, %$19] ; # ->
  br label %$7
$7:
  %96 = phi i64 [%35, %$11], [%40, %$13], [%92, %$16] ; # N
  %97 = phi i64 [%36, %$11], [%41, %$13], [%93, %$16] ; # L
  %98 = phi i64 [%36, %$11], [%44, %$13], [%49, %$16] ; # ->
; # (drop *Safe)
  %99 = inttoptr i64 %21 to i64*
  %100 = getelementptr i64, i64* %99, i32 1
  %101 = load i64, i64* %100
  %102 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %101, i64* %102
  ret i64 %98
}

define i64 @_Place(i64) align 8 {
$1:
; # (let (X (cdr Exe) N (evCnt Exe X) L (save (eval (car (shift X))))...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (evCnt Exe X)
  %4 = call i64 @evCnt(i64 %0, i64 %3)
; # (shift X)
  %5 = inttoptr i64 %3 to i64*
  %6 = getelementptr i64, i64* %5, i32 1
  %7 = load i64, i64* %6
; # (car (shift X))
  %8 = inttoptr i64 %7 to i64*
  %9 = load i64, i64* %8
; # (eval (car (shift X)))
  %10 = and i64 %9, 6
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$4, label %$3
$4:
  br label %$2
$3:
  %12 = and i64 %9, 8
  %13 = icmp ne i64 %12, 0
  br i1 %13, label %$6, label %$5
$6:
  %14 = inttoptr i64 %9 to i64*
  %15 = load i64, i64* %14
  br label %$2
$5:
  %16 = call i64 @evList(i64 %9)
  br label %$2
$2:
  %17 = phi i64 [%9, %$4], [%15, %$6], [%16, %$5] ; # ->
; # (save (eval (car (shift X))))
  %18 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %19 = load i64, i64* %18
  %20 = alloca i64, i64 2, align 16
  %21 = ptrtoint i64* %20 to i64
  %22 = inttoptr i64 %21 to i64*
  store i64 %17, i64* %22
  %23 = add i64 %21, 8
  %24 = inttoptr i64 %23 to i64*
  store i64 %19, i64* %24
  %25 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %21, i64* %25
; # (shift X)
  %26 = inttoptr i64 %7 to i64*
  %27 = getelementptr i64, i64* %26, i32 1
  %28 = load i64, i64* %27
; # (car (shift X))
  %29 = inttoptr i64 %28 to i64*
  %30 = load i64, i64* %29
; # (eval (car (shift X)))
  %31 = and i64 %30, 6
  %32 = icmp ne i64 %31, 0
  br i1 %32, label %$9, label %$8
$9:
  br label %$7
$8:
  %33 = and i64 %30, 8
  %34 = icmp ne i64 %33, 0
  br i1 %34, label %$11, label %$10
$11:
  %35 = inttoptr i64 %30 to i64*
  %36 = load i64, i64* %35
  br label %$7
$10:
  %37 = call i64 @evList(i64 %30)
  br label %$7
$7:
  %38 = phi i64 [%30, %$9], [%36, %$11], [%37, %$10] ; # ->
; # (save (eval (car (shift X))))
  %39 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %40 = load i64, i64* %39
  %41 = alloca i64, i64 2, align 16
  %42 = ptrtoint i64* %41 to i64
  %43 = inttoptr i64 %42 to i64*
  store i64 %38, i64* %43
  %44 = add i64 %42, 8
  %45 = inttoptr i64 %44 to i64*
  store i64 %40, i64* %45
  %46 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %42, i64* %46
; # (cond ((atom L) (cons Y $Nil)) ((le0 (dec 'N)) (cons Y (cdr L))) ...
; # (atom L)
  %47 = and i64 %17, 15
  %48 = icmp ne i64 %47, 0
  br i1 %48, label %$14, label %$13
$14:
  %49 = phi i64 [%4, %$7] ; # N
  %50 = phi i64 [%17, %$7] ; # L
; # (cons Y $Nil)
  %51 = call i64 @cons(i64 %38, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  br label %$12
$13:
  %52 = phi i64 [%4, %$7] ; # N
  %53 = phi i64 [%17, %$7] ; # L
; # (dec 'N)
  %54 = sub i64 %52, 1
; # (le0 (dec 'N))
  %55 = icmp sle i64 %54, 0
  br i1 %55, label %$16, label %$15
$16:
  %56 = phi i64 [%54, %$13] ; # N
  %57 = phi i64 [%53, %$13] ; # L
; # (cdr L)
  %58 = inttoptr i64 %57 to i64*
  %59 = getelementptr i64, i64* %58, i32 1
  %60 = load i64, i64* %59
; # (cons Y (cdr L))
  %61 = call i64 @cons(i64 %38, i64 %60)
  br label %$12
$15:
  %62 = phi i64 [%54, %$13] ; # N
  %63 = phi i64 [%53, %$13] ; # L
; # (let (Z (cons (car L) $Nil) R (save Z)) (loop (? (atom (shift L))...
; # (car L)
  %64 = inttoptr i64 %63 to i64*
  %65 = load i64, i64* %64
; # (cons (car L) $Nil)
  %66 = call i64 @cons(i64 %65, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (save Z)
  %67 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %68 = load i64, i64* %67
  %69 = alloca i64, i64 2, align 16
  %70 = ptrtoint i64* %69 to i64
  %71 = inttoptr i64 %70 to i64*
  store i64 %66, i64* %71
  %72 = add i64 %70, 8
  %73 = inttoptr i64 %72 to i64*
  store i64 %68, i64* %73
  %74 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %70, i64* %74
; # (loop (? (atom (shift L)) (set 2 Z (cons Y L))) (? (=0 (dec 'N)) ...
  br label %$17
$17:
  %75 = phi i64 [%62, %$15], [%103, %$21] ; # N
  %76 = phi i64 [%63, %$15], [%104, %$21] ; # L
  %77 = phi i64 [%66, %$15], [%108, %$21] ; # Z
; # (? (atom (shift L)) (set 2 Z (cons Y L)))
; # (shift L)
  %78 = inttoptr i64 %76 to i64*
  %79 = getelementptr i64, i64* %78, i32 1
  %80 = load i64, i64* %79
; # (atom (shift L))
  %81 = and i64 %80, 15
  %82 = icmp ne i64 %81, 0
  br i1 %82, label %$20, label %$18
$20:
  %83 = phi i64 [%75, %$17] ; # N
  %84 = phi i64 [%80, %$17] ; # L
  %85 = phi i64 [%77, %$17] ; # Z
; # (set 2 Z (cons Y L))
; # (cons Y L)
  %86 = call i64 @cons(i64 %38, i64 %84)
  %87 = inttoptr i64 %85 to i64*
  %88 = getelementptr i64, i64* %87, i32 1
  store i64 %86, i64* %88
  br label %$19
$18:
  %89 = phi i64 [%75, %$17] ; # N
  %90 = phi i64 [%80, %$17] ; # L
  %91 = phi i64 [%77, %$17] ; # Z
; # (? (=0 (dec 'N)) (set 2 Z (cons Y (cdr L))))
; # (dec 'N)
  %92 = sub i64 %89, 1
; # (=0 (dec 'N))
  %93 = icmp eq i64 %92, 0
  br i1 %93, label %$22, label %$21
$22:
  %94 = phi i64 [%92, %$18] ; # N
  %95 = phi i64 [%90, %$18] ; # L
  %96 = phi i64 [%91, %$18] ; # Z
; # (set 2 Z (cons Y (cdr L)))
; # (cdr L)
  %97 = inttoptr i64 %95 to i64*
  %98 = getelementptr i64, i64* %97, i32 1
  %99 = load i64, i64* %98
; # (cons Y (cdr L))
  %100 = call i64 @cons(i64 %38, i64 %99)
  %101 = inttoptr i64 %96 to i64*
  %102 = getelementptr i64, i64* %101, i32 1
  store i64 %100, i64* %102
  br label %$19
$21:
  %103 = phi i64 [%92, %$18] ; # N
  %104 = phi i64 [%90, %$18] ; # L
  %105 = phi i64 [%91, %$18] ; # Z
; # (set 2 Z (cons (car L) $Nil))
; # (car L)
  %106 = inttoptr i64 %104 to i64*
  %107 = load i64, i64* %106
; # (cons (car L) $Nil)
  %108 = call i64 @cons(i64 %107, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %109 = inttoptr i64 %105 to i64*
  %110 = getelementptr i64, i64* %109, i32 1
  store i64 %108, i64* %110
  br label %$17
$19:
  %111 = phi i64 [%83, %$20], [%94, %$22] ; # N
  %112 = phi i64 [%84, %$20], [%95, %$22] ; # L
  %113 = phi i64 [%85, %$20], [%96, %$22] ; # Z
  %114 = phi i64 [%86, %$20], [%100, %$22] ; # ->
  br label %$12
$12:
  %115 = phi i64 [%49, %$14], [%56, %$16], [%111, %$19] ; # N
  %116 = phi i64 [%50, %$14], [%57, %$16], [%112, %$19] ; # L
  %117 = phi i64 [%51, %$14], [%61, %$16], [%66, %$19] ; # ->
; # (drop *Safe)
  %118 = inttoptr i64 %21 to i64*
  %119 = getelementptr i64, i64* %118, i32 1
  %120 = load i64, i64* %119
  %121 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %120, i64* %121
  ret i64 %117
}

define i64 @_Strip(i64) align 8 {
$1:
; # (let X (eval (cadr Exe)) (while (and (pair X) (== $Quote (car X))...
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (while (and (pair X) (== $Quote (car X))) (? (== (cdr X) X)) (set...
  br label %$7
$7:
  %14 = phi i64 [%13, %$2], [%26, %$12] ; # X
; # (and (pair X) (== $Quote (car X)))
; # (pair X)
  %15 = and i64 %14, 15
  %16 = icmp eq i64 %15, 0
  br i1 %16, label %$9, label %$8
$9:
  %17 = phi i64 [%14, %$7] ; # X
; # (car X)
  %18 = inttoptr i64 %17 to i64*
  %19 = load i64, i64* %18
; # (== $Quote (car X))
  %20 = icmp eq i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 264) to i64), %19
  br label %$8
$8:
  %21 = phi i64 [%14, %$7], [%17, %$9] ; # X
  %22 = phi i1 [0, %$7], [%20, %$9] ; # ->
  br i1 %22, label %$10, label %$11
$10:
  %23 = phi i64 [%21, %$8] ; # X
; # (? (== (cdr X) X))
; # (cdr X)
  %24 = inttoptr i64 %23 to i64*
  %25 = getelementptr i64, i64* %24, i32 1
  %26 = load i64, i64* %25
; # (== (cdr X) X)
  %27 = icmp eq i64 %26, %23
  br i1 %27, label %$11, label %$12
$12:
  %28 = phi i64 [%23, %$10] ; # X
  br label %$7
$11:
  %29 = phi i64 [%21, %$8], [%23, %$10] ; # X
  ret i64 %29
}

define i64 @_Split(i64) align 8 {
$1:
; # (let (X (cdr Exe) L (save (eval (car X)))) (if (atom L) @ (let (A...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (car X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (car X))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (save (eval (car X)))
  %14 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %15 = load i64, i64* %14
  %16 = alloca i64, i64 2, align 16
  %17 = ptrtoint i64* %16 to i64
  %18 = inttoptr i64 %17 to i64*
  store i64 %13, i64* %18
  %19 = add i64 %17, 8
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %17, i64* %21
; # (if (atom L) @ (let (A $Nil N 0) (while (pair (shift X)) (setq A ...
; # (atom L)
  %22 = and i64 %13, 15
  %23 = icmp ne i64 %22, 0
  br i1 %23, label %$7, label %$8
$7:
  %24 = phi i64 [%3, %$2] ; # X
  %25 = phi i64 [%13, %$2] ; # L
  br label %$9
$8:
  %26 = phi i64 [%3, %$2] ; # X
  %27 = phi i64 [%13, %$2] ; # L
; # (let (A $Nil N 0) (while (pair (shift X)) (setq A (link (push (ev...
; # (while (pair (shift X)) (setq A (link (push (eval (car X)) NIL)))...
  br label %$10
$10:
  %28 = phi i64 [%26, %$8], [%37, %$13] ; # X
  %29 = phi i64 [%27, %$8], [%38, %$13] ; # L
  %30 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$8], [%52, %$13] ; # A
  %31 = phi i64 [0, %$8], [%59, %$13] ; # N
; # (shift X)
  %32 = inttoptr i64 %28 to i64*
  %33 = getelementptr i64, i64* %32, i32 1
  %34 = load i64, i64* %33
; # (pair (shift X))
  %35 = and i64 %34, 15
  %36 = icmp eq i64 %35, 0
  br i1 %36, label %$11, label %$12
$11:
  %37 = phi i64 [%34, %$10] ; # X
  %38 = phi i64 [%29, %$10] ; # L
  %39 = phi i64 [%30, %$10] ; # A
  %40 = phi i64 [%31, %$10] ; # N
; # (car X)
  %41 = inttoptr i64 %37 to i64*
  %42 = load i64, i64* %41
; # (eval (car X))
  %43 = and i64 %42, 6
  %44 = icmp ne i64 %43, 0
  br i1 %44, label %$15, label %$14
$15:
  br label %$13
$14:
  %45 = and i64 %42, 8
  %46 = icmp ne i64 %45, 0
  br i1 %46, label %$17, label %$16
$17:
  %47 = inttoptr i64 %42 to i64*
  %48 = load i64, i64* %47
  br label %$13
$16:
  %49 = call i64 @evList(i64 %42)
  br label %$13
$13:
  %50 = phi i64 [%42, %$15], [%48, %$17], [%49, %$16] ; # ->
; # (push (eval (car X)) NIL)
  %51 = alloca i64, i64 2, align 16
  %52 = ptrtoint i64* %51 to i64
  %53 = inttoptr i64 %52 to i64*
  store i64 %50, i64* %53
; # (link (push (eval (car X)) NIL))
  %54 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %55 = load i64, i64* %54
  %56 = inttoptr i64 %52 to i64*
  %57 = getelementptr i64, i64* %56, i32 1
  store i64 %55, i64* %57
  %58 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %52, i64* %58
; # (inc 'N)
  %59 = add i64 %40, 1
  br label %$10
$12:
  %60 = phi i64 [%34, %$10] ; # X
  %61 = phi i64 [%29, %$10] ; # L
  %62 = phi i64 [%30, %$10] ; # A
  %63 = phi i64 [%31, %$10] ; # N
; # (let (P $Nil R (link (push P NIL)) Q $Nil S (link (push Q NIL))) ...
; # (push P NIL)
  %64 = alloca i64, i64 2, align 16
  %65 = ptrtoint i64* %64 to i64
  %66 = inttoptr i64 %65 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %66
; # (link (push P NIL))
  %67 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %68 = load i64, i64* %67
  %69 = inttoptr i64 %65 to i64*
  %70 = getelementptr i64, i64* %69, i32 1
  store i64 %68, i64* %70
  %71 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %65, i64* %71
; # (push Q NIL)
  %72 = alloca i64, i64 2, align 16
  %73 = ptrtoint i64* %72 to i64
  %74 = inttoptr i64 %73 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %74
; # (link (push Q NIL))
  %75 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %76 = load i64, i64* %75
  %77 = inttoptr i64 %73 to i64*
  %78 = getelementptr i64, i64* %77, i32 1
  store i64 %76, i64* %78
  %79 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %73, i64* %79
; # (loop (let (Y (++ L) Z A I N) (loop (? (lt0 (dec 'I)) (let C (con...
  br label %$18
$18:
  %80 = phi i64 [%60, %$12], [%211, %$31] ; # X
  %81 = phi i64 [%61, %$12], [%212, %$31] ; # L
  %82 = phi i64 [%62, %$12], [%213, %$31] ; # A
  %83 = phi i64 [%63, %$12], [%214, %$31] ; # N
  %84 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$12], [%215, %$31] ; # P
  %85 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$12], [%216, %$31] ; # Q
; # (let (Y (++ L) Z A I N) (loop (? (lt0 (dec 'I)) (let C (cons Y $N...
; # (++ L)
  %86 = inttoptr i64 %81 to i64*
  %87 = load i64, i64* %86
  %88 = getelementptr i64, i64* %86, i32 1
  %89 = load i64, i64* %88
; # (loop (? (lt0 (dec 'I)) (let C (cons Y $Nil) (setq Q (if (nil? Q)...
  br label %$19
$19:
  %90 = phi i64 [%80, %$18], [%192, %$26] ; # X
  %91 = phi i64 [%89, %$18], [%193, %$26] ; # L
  %92 = phi i64 [%82, %$18], [%194, %$26] ; # A
  %93 = phi i64 [%83, %$18], [%195, %$26] ; # N
  %94 = phi i64 [%84, %$18], [%196, %$26] ; # P
  %95 = phi i64 [%85, %$18], [%197, %$26] ; # Q
  %96 = phi i64 [%82, %$18], [%198, %$26] ; # Z
  %97 = phi i64 [%83, %$18], [%199, %$26] ; # I
; # (? (lt0 (dec 'I)) (let C (cons Y $Nil) (setq Q (if (nil? Q) (set ...
; # (dec 'I)
  %98 = sub i64 %97, 1
; # (lt0 (dec 'I))
  %99 = icmp slt i64 %98, 0
  br i1 %99, label %$22, label %$20
$22:
  %100 = phi i64 [%90, %$19] ; # X
  %101 = phi i64 [%91, %$19] ; # L
  %102 = phi i64 [%92, %$19] ; # A
  %103 = phi i64 [%93, %$19] ; # N
  %104 = phi i64 [%94, %$19] ; # P
  %105 = phi i64 [%95, %$19] ; # Q
  %106 = phi i64 [%96, %$19] ; # Z
  %107 = phi i64 [%98, %$19] ; # I
; # (let C (cons Y $Nil) (setq Q (if (nil? Q) (set S C) (set 2 Q C)))...
; # (cons Y $Nil)
  %108 = call i64 @cons(i64 %87, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (if (nil? Q) (set S C) (set 2 Q C))
; # (nil? Q)
  %109 = icmp eq i64 %105, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %109, label %$23, label %$24
$23:
  %110 = phi i64 [%100, %$22] ; # X
  %111 = phi i64 [%101, %$22] ; # L
  %112 = phi i64 [%102, %$22] ; # A
  %113 = phi i64 [%103, %$22] ; # N
  %114 = phi i64 [%104, %$22] ; # P
  %115 = phi i64 [%105, %$22] ; # Q
  %116 = phi i64 [%106, %$22] ; # Z
  %117 = phi i64 [%107, %$22] ; # I
; # (set S C)
  %118 = inttoptr i64 %73 to i64*
  store i64 %108, i64* %118
  br label %$25
$24:
  %119 = phi i64 [%100, %$22] ; # X
  %120 = phi i64 [%101, %$22] ; # L
  %121 = phi i64 [%102, %$22] ; # A
  %122 = phi i64 [%103, %$22] ; # N
  %123 = phi i64 [%104, %$22] ; # P
  %124 = phi i64 [%105, %$22] ; # Q
  %125 = phi i64 [%106, %$22] ; # Z
  %126 = phi i64 [%107, %$22] ; # I
; # (set 2 Q C)
  %127 = inttoptr i64 %124 to i64*
  %128 = getelementptr i64, i64* %127, i32 1
  store i64 %108, i64* %128
  br label %$25
$25:
  %129 = phi i64 [%110, %$23], [%119, %$24] ; # X
  %130 = phi i64 [%111, %$23], [%120, %$24] ; # L
  %131 = phi i64 [%112, %$23], [%121, %$24] ; # A
  %132 = phi i64 [%113, %$23], [%122, %$24] ; # N
  %133 = phi i64 [%114, %$23], [%123, %$24] ; # P
  %134 = phi i64 [%115, %$23], [%124, %$24] ; # Q
  %135 = phi i64 [%116, %$23], [%125, %$24] ; # Z
  %136 = phi i64 [%117, %$23], [%126, %$24] ; # I
  %137 = phi i64 [%108, %$23], [%108, %$24] ; # ->
  br label %$21
$20:
  %138 = phi i64 [%90, %$19] ; # X
  %139 = phi i64 [%91, %$19] ; # L
  %140 = phi i64 [%92, %$19] ; # A
  %141 = phi i64 [%93, %$19] ; # N
  %142 = phi i64 [%94, %$19] ; # P
  %143 = phi i64 [%95, %$19] ; # Q
  %144 = phi i64 [%96, %$19] ; # Z
  %145 = phi i64 [%98, %$19] ; # I
; # (? (equal Y (++ Z)) (let C (cons (val S) $Nil) (setq P (if (nil? ...
; # (++ Z)
  %146 = inttoptr i64 %144 to i64*
  %147 = load i64, i64* %146
  %148 = getelementptr i64, i64* %146, i32 1
  %149 = load i64, i64* %148
; # (equal Y (++ Z))
  %150 = call i1 @equal(i64 %87, i64 %147)
  br i1 %150, label %$27, label %$26
$27:
  %151 = phi i64 [%138, %$20] ; # X
  %152 = phi i64 [%139, %$20] ; # L
  %153 = phi i64 [%140, %$20] ; # A
  %154 = phi i64 [%141, %$20] ; # N
  %155 = phi i64 [%142, %$20] ; # P
  %156 = phi i64 [%143, %$20] ; # Q
  %157 = phi i64 [%149, %$20] ; # Z
  %158 = phi i64 [%145, %$20] ; # I
; # (let C (cons (val S) $Nil) (setq P (if (nil? P) (set R C) (set 2 ...
; # (val S)
  %159 = inttoptr i64 %73 to i64*
  %160 = load i64, i64* %159
; # (cons (val S) $Nil)
  %161 = call i64 @cons(i64 %160, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (if (nil? P) (set R C) (set 2 P C))
; # (nil? P)
  %162 = icmp eq i64 %155, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %162, label %$28, label %$29
$28:
  %163 = phi i64 [%151, %$27] ; # X
  %164 = phi i64 [%152, %$27] ; # L
  %165 = phi i64 [%153, %$27] ; # A
  %166 = phi i64 [%154, %$27] ; # N
  %167 = phi i64 [%155, %$27] ; # P
  %168 = phi i64 [%156, %$27] ; # Q
  %169 = phi i64 [%157, %$27] ; # Z
  %170 = phi i64 [%158, %$27] ; # I
; # (set R C)
  %171 = inttoptr i64 %65 to i64*
  store i64 %161, i64* %171
  br label %$30
$29:
  %172 = phi i64 [%151, %$27] ; # X
  %173 = phi i64 [%152, %$27] ; # L
  %174 = phi i64 [%153, %$27] ; # A
  %175 = phi i64 [%154, %$27] ; # N
  %176 = phi i64 [%155, %$27] ; # P
  %177 = phi i64 [%156, %$27] ; # Q
  %178 = phi i64 [%157, %$27] ; # Z
  %179 = phi i64 [%158, %$27] ; # I
; # (set 2 P C)
  %180 = inttoptr i64 %176 to i64*
  %181 = getelementptr i64, i64* %180, i32 1
  store i64 %161, i64* %181
  br label %$30
$30:
  %182 = phi i64 [%163, %$28], [%172, %$29] ; # X
  %183 = phi i64 [%164, %$28], [%173, %$29] ; # L
  %184 = phi i64 [%165, %$28], [%174, %$29] ; # A
  %185 = phi i64 [%166, %$28], [%175, %$29] ; # N
  %186 = phi i64 [%167, %$28], [%176, %$29] ; # P
  %187 = phi i64 [%168, %$28], [%177, %$29] ; # Q
  %188 = phi i64 [%169, %$28], [%178, %$29] ; # Z
  %189 = phi i64 [%170, %$28], [%179, %$29] ; # I
  %190 = phi i64 [%161, %$28], [%161, %$29] ; # ->
; # (set S $Nil)
  %191 = inttoptr i64 %73 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %191
  br label %$21
$26:
  %192 = phi i64 [%138, %$20] ; # X
  %193 = phi i64 [%139, %$20] ; # L
  %194 = phi i64 [%140, %$20] ; # A
  %195 = phi i64 [%141, %$20] ; # N
  %196 = phi i64 [%142, %$20] ; # P
  %197 = phi i64 [%143, %$20] ; # Q
  %198 = phi i64 [%149, %$20] ; # Z
  %199 = phi i64 [%145, %$20] ; # I
  br label %$19
$21:
  %200 = phi i64 [%129, %$25], [%182, %$30] ; # X
  %201 = phi i64 [%130, %$25], [%183, %$30] ; # L
  %202 = phi i64 [%131, %$25], [%184, %$30] ; # A
  %203 = phi i64 [%132, %$25], [%185, %$30] ; # N
  %204 = phi i64 [%133, %$25], [%190, %$30] ; # P
  %205 = phi i64 [%137, %$25], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$30] ; # Q
  %206 = phi i64 [%135, %$25], [%188, %$30] ; # Z
  %207 = phi i64 [%136, %$25], [%189, %$30] ; # I
  %208 = phi i64 [%137, %$25], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$30] ; # ->
; # (? (atom L))
; # (atom L)
  %209 = and i64 %201, 15
  %210 = icmp ne i64 %209, 0
  br i1 %210, label %$32, label %$31
$31:
  %211 = phi i64 [%200, %$21] ; # X
  %212 = phi i64 [%201, %$21] ; # L
  %213 = phi i64 [%202, %$21] ; # A
  %214 = phi i64 [%203, %$21] ; # N
  %215 = phi i64 [%204, %$21] ; # P
  %216 = phi i64 [%205, %$21] ; # Q
  br label %$18
$32:
  %217 = phi i64 [%200, %$21] ; # X
  %218 = phi i64 [%201, %$21] ; # L
  %219 = phi i64 [%202, %$21] ; # A
  %220 = phi i64 [%203, %$21] ; # N
  %221 = phi i64 [%204, %$21] ; # P
  %222 = phi i64 [%205, %$21] ; # Q
  %223 = phi i64 [0, %$21] ; # ->
; # (let C (cons (val S) $Nil) (if (nil? P) C (set 2 P C) (val R)))
; # (val S)
  %224 = inttoptr i64 %73 to i64*
  %225 = load i64, i64* %224
; # (cons (val S) $Nil)
  %226 = call i64 @cons(i64 %225, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (if (nil? P) C (set 2 P C) (val R))
; # (nil? P)
  %227 = icmp eq i64 %221, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %227, label %$33, label %$34
$33:
  %228 = phi i64 [%217, %$32] ; # X
  %229 = phi i64 [%218, %$32] ; # L
  %230 = phi i64 [%219, %$32] ; # A
  %231 = phi i64 [%220, %$32] ; # N
  %232 = phi i64 [%221, %$32] ; # P
  %233 = phi i64 [%222, %$32] ; # Q
  br label %$35
$34:
  %234 = phi i64 [%217, %$32] ; # X
  %235 = phi i64 [%218, %$32] ; # L
  %236 = phi i64 [%219, %$32] ; # A
  %237 = phi i64 [%220, %$32] ; # N
  %238 = phi i64 [%221, %$32] ; # P
  %239 = phi i64 [%222, %$32] ; # Q
; # (set 2 P C)
  %240 = inttoptr i64 %238 to i64*
  %241 = getelementptr i64, i64* %240, i32 1
  store i64 %226, i64* %241
; # (val R)
  %242 = inttoptr i64 %65 to i64*
  %243 = load i64, i64* %242
  br label %$35
$35:
  %244 = phi i64 [%228, %$33], [%234, %$34] ; # X
  %245 = phi i64 [%229, %$33], [%235, %$34] ; # L
  %246 = phi i64 [%230, %$33], [%236, %$34] ; # A
  %247 = phi i64 [%231, %$33], [%237, %$34] ; # N
  %248 = phi i64 [%232, %$33], [%238, %$34] ; # P
  %249 = phi i64 [%233, %$33], [%239, %$34] ; # Q
  %250 = phi i64 [%226, %$33], [%243, %$34] ; # ->
  br label %$9
$9:
  %251 = phi i64 [%24, %$7], [%244, %$35] ; # X
  %252 = phi i64 [%25, %$7], [%245, %$35] ; # L
  %253 = phi i64 [%13, %$7], [%250, %$35] ; # ->
; # (drop *Safe)
  %254 = inttoptr i64 %17 to i64*
  %255 = getelementptr i64, i64* %254, i32 1
  %256 = load i64, i64* %255
  %257 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %256, i64* %257
  ret i64 %253
}

define i64 @_Reverse(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (save (eval (car X))) Z $Nil) (while (pair Y)...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (car X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (car X))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (save (eval (car X)))
  %14 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %15 = load i64, i64* %14
  %16 = alloca i64, i64 2, align 16
  %17 = ptrtoint i64* %16 to i64
  %18 = inttoptr i64 %17 to i64*
  store i64 %13, i64* %18
  %19 = add i64 %17, 8
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %17, i64* %21
; # (while (pair Y) (setq Z (cons (++ Y) Z)))
  br label %$7
$7:
  %22 = phi i64 [%13, %$2], [%31, %$8] ; # Y
  %23 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%32, %$8] ; # Z
; # (pair Y)
  %24 = and i64 %22, 15
  %25 = icmp eq i64 %24, 0
  br i1 %25, label %$8, label %$9
$8:
  %26 = phi i64 [%22, %$7] ; # Y
  %27 = phi i64 [%23, %$7] ; # Z
; # (++ Y)
  %28 = inttoptr i64 %26 to i64*
  %29 = load i64, i64* %28
  %30 = getelementptr i64, i64* %28, i32 1
  %31 = load i64, i64* %30
; # (cons (++ Y) Z)
  %32 = call i64 @cons(i64 %29, i64 %27)
  br label %$7
$9:
  %33 = phi i64 [%22, %$7] ; # Y
  %34 = phi i64 [%23, %$7] ; # Z
; # (drop *Safe)
  %35 = inttoptr i64 %17 to i64*
  %36 = getelementptr i64, i64* %35, i32 1
  %37 = load i64, i64* %36
  %38 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %37, i64* %38
  ret i64 %34
}

define i64 @_Flip(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (eval (car X))) (if (atom Y) Y (let Z (cdr Y)...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (car X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (car X))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (if (atom Y) Y (let Z (cdr Y) (cond ((atom Z) Y) ((atom (shift X)...
; # (atom Y)
  %14 = and i64 %13, 15
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$7, label %$8
$7:
  %16 = phi i64 [%3, %$2] ; # X
  %17 = phi i64 [%13, %$2] ; # Y
  br label %$9
$8:
  %18 = phi i64 [%3, %$2] ; # X
  %19 = phi i64 [%13, %$2] ; # Y
; # (let Z (cdr Y) (cond ((atom Z) Y) ((atom (shift X)) (set 2 Y $Nil...
; # (cdr Y)
  %20 = inttoptr i64 %19 to i64*
  %21 = getelementptr i64, i64* %20, i32 1
  %22 = load i64, i64* %21
; # (cond ((atom Z) Y) ((atom (shift X)) (set 2 Y $Nil) (loop (setq X...
; # (atom Z)
  %23 = and i64 %22, 15
  %24 = icmp ne i64 %23, 0
  br i1 %24, label %$12, label %$11
$12:
  %25 = phi i64 [%18, %$8] ; # X
  %26 = phi i64 [%19, %$8] ; # Y
  %27 = phi i64 [%22, %$8] ; # Z
  br label %$10
$11:
  %28 = phi i64 [%18, %$8] ; # X
  %29 = phi i64 [%19, %$8] ; # Y
  %30 = phi i64 [%22, %$8] ; # Z
; # (shift X)
  %31 = inttoptr i64 %28 to i64*
  %32 = getelementptr i64, i64* %31, i32 1
  %33 = load i64, i64* %32
; # (atom (shift X))
  %34 = and i64 %33, 15
  %35 = icmp ne i64 %34, 0
  br i1 %35, label %$14, label %$13
$14:
  %36 = phi i64 [%33, %$11] ; # X
  %37 = phi i64 [%29, %$11] ; # Y
  %38 = phi i64 [%30, %$11] ; # Z
; # (set 2 Y $Nil)
  %39 = inttoptr i64 %37 to i64*
  %40 = getelementptr i64, i64* %39, i32 1
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %40
; # (loop (setq X (cdr Z)) (set 2 Z Y) (? (atom X) Z) (setq Y Z Z X))...
  br label %$15
$15:
  %41 = phi i64 [%36, %$14], [%54, %$16] ; # X
  %42 = phi i64 [%37, %$14], [%56, %$16] ; # Y
  %43 = phi i64 [%38, %$14], [%54, %$16] ; # Z
; # (cdr Z)
  %44 = inttoptr i64 %43 to i64*
  %45 = getelementptr i64, i64* %44, i32 1
  %46 = load i64, i64* %45
; # (set 2 Z Y)
  %47 = inttoptr i64 %43 to i64*
  %48 = getelementptr i64, i64* %47, i32 1
  store i64 %42, i64* %48
; # (? (atom X) Z)
; # (atom X)
  %49 = and i64 %46, 15
  %50 = icmp ne i64 %49, 0
  br i1 %50, label %$18, label %$16
$18:
  %51 = phi i64 [%46, %$15] ; # X
  %52 = phi i64 [%42, %$15] ; # Y
  %53 = phi i64 [%43, %$15] ; # Z
  br label %$17
$16:
  %54 = phi i64 [%46, %$15] ; # X
  %55 = phi i64 [%42, %$15] ; # Y
  %56 = phi i64 [%43, %$15] ; # Z
  br label %$15
$17:
  %57 = phi i64 [%51, %$18] ; # X
  %58 = phi i64 [%52, %$18] ; # Y
  %59 = phi i64 [%53, %$18] ; # Z
  %60 = phi i64 [%53, %$18] ; # ->
  br label %$10
$13:
  %61 = phi i64 [%33, %$11] ; # X
  %62 = phi i64 [%29, %$11] ; # Y
  %63 = phi i64 [%30, %$11] ; # Z
; # (let N (save Y (evCnt Exe X)) (if (le0 (dec 'N)) Y (set 2 Y (cdr ...
; # (save Y (evCnt Exe X))
  %64 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %65 = load i64, i64* %64
  %66 = alloca i64, i64 2, align 16
  %67 = ptrtoint i64* %66 to i64
  %68 = inttoptr i64 %67 to i64*
  store i64 %62, i64* %68
  %69 = add i64 %67, 8
  %70 = inttoptr i64 %69 to i64*
  store i64 %65, i64* %70
  %71 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %67, i64* %71
; # (evCnt Exe X)
  %72 = call i64 @evCnt(i64 %0, i64 %61)
; # drop
  %73 = inttoptr i64 %67 to i64*
  %74 = getelementptr i64, i64* %73, i32 1
  %75 = load i64, i64* %74
  %76 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %75, i64* %76
; # (if (le0 (dec 'N)) Y (set 2 Y (cdr Z) 2 Z Y) (until (or (=0 (dec ...
; # (dec 'N)
  %77 = sub i64 %72, 1
; # (le0 (dec 'N))
  %78 = icmp sle i64 %77, 0
  br i1 %78, label %$19, label %$20
$19:
  %79 = phi i64 [%61, %$13] ; # X
  %80 = phi i64 [%62, %$13] ; # Y
  %81 = phi i64 [%63, %$13] ; # Z
  %82 = phi i64 [%77, %$13] ; # N
  br label %$21
$20:
  %83 = phi i64 [%61, %$13] ; # X
  %84 = phi i64 [%62, %$13] ; # Y
  %85 = phi i64 [%63, %$13] ; # Z
  %86 = phi i64 [%77, %$13] ; # N
; # (set 2 Y (cdr Z) 2 Z Y)
; # (cdr Z)
  %87 = inttoptr i64 %85 to i64*
  %88 = getelementptr i64, i64* %87, i32 1
  %89 = load i64, i64* %88
  %90 = inttoptr i64 %84 to i64*
  %91 = getelementptr i64, i64* %90, i32 1
  store i64 %89, i64* %91
  %92 = inttoptr i64 %85 to i64*
  %93 = getelementptr i64, i64* %92, i32 1
  store i64 %84, i64* %93
; # (until (or (=0 (dec 'N)) (atom (setq X (cdr Y)))) (set 2 Y (cdr X...
  br label %$22
$22:
  %94 = phi i64 [%83, %$20], [%114, %$25] ; # X
  %95 = phi i64 [%84, %$20], [%115, %$25] ; # Y
  %96 = phi i64 [%85, %$20], [%114, %$25] ; # Z
  %97 = phi i64 [%86, %$20], [%117, %$25] ; # N
; # (or (=0 (dec 'N)) (atom (setq X (cdr Y))))
; # (dec 'N)
  %98 = sub i64 %97, 1
; # (=0 (dec 'N))
  %99 = icmp eq i64 %98, 0
  br i1 %99, label %$23, label %$24
$24:
  %100 = phi i64 [%94, %$22] ; # X
  %101 = phi i64 [%95, %$22] ; # Y
  %102 = phi i64 [%96, %$22] ; # Z
  %103 = phi i64 [%98, %$22] ; # N
; # (cdr Y)
  %104 = inttoptr i64 %101 to i64*
  %105 = getelementptr i64, i64* %104, i32 1
  %106 = load i64, i64* %105
; # (atom (setq X (cdr Y)))
  %107 = and i64 %106, 15
  %108 = icmp ne i64 %107, 0
  br label %$23
$23:
  %109 = phi i64 [%94, %$22], [%106, %$24] ; # X
  %110 = phi i64 [%95, %$22], [%101, %$24] ; # Y
  %111 = phi i64 [%96, %$22], [%102, %$24] ; # Z
  %112 = phi i64 [%98, %$22], [%103, %$24] ; # N
  %113 = phi i1 [1, %$22], [%108, %$24] ; # ->
  br i1 %113, label %$26, label %$25
$25:
  %114 = phi i64 [%109, %$23] ; # X
  %115 = phi i64 [%110, %$23] ; # Y
  %116 = phi i64 [%111, %$23] ; # Z
  %117 = phi i64 [%112, %$23] ; # N
; # (set 2 Y (cdr X) 2 X Z)
; # (cdr X)
  %118 = inttoptr i64 %114 to i64*
  %119 = getelementptr i64, i64* %118, i32 1
  %120 = load i64, i64* %119
  %121 = inttoptr i64 %115 to i64*
  %122 = getelementptr i64, i64* %121, i32 1
  store i64 %120, i64* %122
  %123 = inttoptr i64 %114 to i64*
  %124 = getelementptr i64, i64* %123, i32 1
  store i64 %116, i64* %124
  br label %$22
$26:
  %125 = phi i64 [%109, %$23] ; # X
  %126 = phi i64 [%110, %$23] ; # Y
  %127 = phi i64 [%111, %$23] ; # Z
  %128 = phi i64 [%112, %$23] ; # N
  br label %$21
$21:
  %129 = phi i64 [%79, %$19], [%125, %$26] ; # X
  %130 = phi i64 [%80, %$19], [%126, %$26] ; # Y
  %131 = phi i64 [%81, %$19], [%127, %$26] ; # Z
  %132 = phi i64 [%82, %$19], [%128, %$26] ; # N
  %133 = phi i64 [%80, %$19], [%127, %$26] ; # ->
  br label %$10
$10:
  %134 = phi i64 [%25, %$12], [%57, %$17], [%129, %$21] ; # X
  %135 = phi i64 [%26, %$12], [%58, %$17], [%130, %$21] ; # Y
  %136 = phi i64 [%27, %$12], [%59, %$17], [%131, %$21] ; # Z
  %137 = phi i64 [%26, %$12], [%60, %$17], [%133, %$21] ; # ->
  br label %$9
$9:
  %138 = phi i64 [%16, %$7], [%134, %$10] ; # X
  %139 = phi i64 [%17, %$7], [%135, %$10] ; # Y
  %140 = phi i64 [%17, %$7], [%137, %$10] ; # ->
  ret i64 %140
}

define i64 @trim(i64) align 8 {
$1:
; # (if (atom X) X (stkChk 0) (let Y (trim (cdr X)) (if (and (nil? Y)...
; # (atom X)
  %1 = and i64 %0, 15
  %2 = icmp ne i64 %1, 0
  br i1 %2, label %$2, label %$3
$2:
  br label %$4
$3:
; # (stkChk 0)
  %3 = load i8*, i8** @$StkLimit
  %4 = call i8* @llvm.stacksave()
  %5 = icmp ugt i8* %3, %4
  br i1 %5, label %$5, label %$6
$5:
  call void @stkErr(i64 0)
  unreachable
$6:
; # (let Y (trim (cdr X)) (if (and (nil? Y) (isBlank (car X))) $Nil (...
; # (cdr X)
  %6 = inttoptr i64 %0 to i64*
  %7 = getelementptr i64, i64* %6, i32 1
  %8 = load i64, i64* %7
; # (trim (cdr X))
  %9 = call i64 @trim(i64 %8)
; # (if (and (nil? Y) (isBlank (car X))) $Nil (cons (car X) Y))
; # (and (nil? Y) (isBlank (car X)))
; # (nil? Y)
  %10 = icmp eq i64 %9, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %10, label %$8, label %$7
$8:
; # (car X)
  %11 = inttoptr i64 %0 to i64*
  %12 = load i64, i64* %11
; # (isBlank (car X))
  %13 = call i1 @isBlank(i64 %12)
  br label %$7
$7:
  %14 = phi i1 [0, %$6], [%13, %$8] ; # ->
  br i1 %14, label %$9, label %$10
$9:
  br label %$11
$10:
; # (car X)
  %15 = inttoptr i64 %0 to i64*
  %16 = load i64, i64* %15
; # (cons (car X) Y)
  %17 = call i64 @cons(i64 %16, i64 %9)
  br label %$11
$11:
  %18 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$9], [%17, %$10] ; # ->
  br label %$4
$4:
  %19 = phi i64 [%0, %$2], [%18, %$11] ; # ->
  ret i64 %19
}

define i64 @_Trim(i64) align 8 {
$1:
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (save (eval (cadr Exe)))
  %14 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %15 = load i64, i64* %14
  %16 = alloca i64, i64 2, align 16
  %17 = ptrtoint i64* %16 to i64
  %18 = inttoptr i64 %17 to i64*
  store i64 %13, i64* %18
  %19 = add i64 %17, 8
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %17, i64* %21
; # (trim (save (eval (cadr Exe))))
  %22 = call i64 @trim(i64 %13)
; # (drop *Safe)
  %23 = inttoptr i64 %17 to i64*
  %24 = getelementptr i64, i64* %23, i32 1
  %25 = load i64, i64* %24
  %26 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %25, i64* %26
  ret i64 %22
}

define i64 @_Clip(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (eval (car X))) (while (and (pair Y) (isBlank...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (car X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (car X))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (while (and (pair Y) (isBlank (car Y))) (shift Y))
  br label %$7
$7:
  %14 = phi i64 [%13, %$2], [%26, %$10] ; # Y
; # (and (pair Y) (isBlank (car Y)))
; # (pair Y)
  %15 = and i64 %14, 15
  %16 = icmp eq i64 %15, 0
  br i1 %16, label %$9, label %$8
$9:
  %17 = phi i64 [%14, %$7] ; # Y
; # (car Y)
  %18 = inttoptr i64 %17 to i64*
  %19 = load i64, i64* %18
; # (isBlank (car Y))
  %20 = call i1 @isBlank(i64 %19)
  br label %$8
$8:
  %21 = phi i64 [%14, %$7], [%17, %$9] ; # Y
  %22 = phi i1 [0, %$7], [%20, %$9] ; # ->
  br i1 %22, label %$10, label %$11
$10:
  %23 = phi i64 [%21, %$8] ; # Y
; # (shift Y)
  %24 = inttoptr i64 %23 to i64*
  %25 = getelementptr i64, i64* %24, i32 1
  %26 = load i64, i64* %25
  br label %$7
$11:
  %27 = phi i64 [%21, %$8] ; # Y
; # (save Y)
  %28 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %29 = load i64, i64* %28
  %30 = alloca i64, i64 2, align 16
  %31 = ptrtoint i64* %30 to i64
  %32 = inttoptr i64 %31 to i64*
  store i64 %27, i64* %32
  %33 = add i64 %31, 8
  %34 = inttoptr i64 %33 to i64*
  store i64 %29, i64* %34
  %35 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %31, i64* %35
; # (trim (save Y))
  %36 = call i64 @trim(i64 %27)
; # (drop *Safe)
  %37 = inttoptr i64 %31 to i64*
  %38 = getelementptr i64, i64* %37, i32 1
  %39 = load i64, i64* %38
  %40 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %39, i64* %40
  ret i64 %36
}

define i64 @_Head(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (eval (++ X))) (cond ((nil? Y) Y) ((pair Y) (...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (cond ((nil? Y) Y) ((pair Y) (save Y (let (Z Y L (eval (car X))) ...
; # (nil? Y)
  %16 = icmp eq i64 %15, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %16, label %$9, label %$8
$9:
  br label %$7
$8:
; # (pair Y)
  %17 = and i64 %15, 15
  %18 = icmp eq i64 %17, 0
  br i1 %18, label %$11, label %$10
$11:
; # (save Y (let (Z Y L (eval (car X))) (loop (? (or (atom L) (not (e...
  %19 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %20 = load i64, i64* %19
  %21 = alloca i64, i64 2, align 16
  %22 = ptrtoint i64* %21 to i64
  %23 = inttoptr i64 %22 to i64*
  store i64 %15, i64* %23
  %24 = add i64 %22, 8
  %25 = inttoptr i64 %24 to i64*
  store i64 %20, i64* %25
  %26 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %22, i64* %26
; # (let (Z Y L (eval (car X))) (loop (? (or (atom L) (not (equal (ca...
; # (car X)
  %27 = inttoptr i64 %7 to i64*
  %28 = load i64, i64* %27
; # (eval (car X))
  %29 = and i64 %28, 6
  %30 = icmp ne i64 %29, 0
  br i1 %30, label %$14, label %$13
$14:
  br label %$12
$13:
  %31 = and i64 %28, 8
  %32 = icmp ne i64 %31, 0
  br i1 %32, label %$16, label %$15
$16:
  %33 = inttoptr i64 %28 to i64*
  %34 = load i64, i64* %33
  br label %$12
$15:
  %35 = call i64 @evList(i64 %28)
  br label %$12
$12:
  %36 = phi i64 [%28, %$14], [%34, %$16], [%35, %$15] ; # ->
; # (loop (? (or (atom L) (not (equal (car Z) (car L)))) $Nil) (? (at...
  br label %$17
$17:
  %37 = phi i64 [%15, %$12], [%63, %$23] ; # Z
  %38 = phi i64 [%36, %$12], [%67, %$23] ; # L
; # (? (or (atom L) (not (equal (car Z) (car L)))) $Nil)
; # (or (atom L) (not (equal (car Z) (car L))))
; # (atom L)
  %39 = and i64 %38, 15
  %40 = icmp ne i64 %39, 0
  br i1 %40, label %$18, label %$19
$19:
  %41 = phi i64 [%37, %$17] ; # Z
  %42 = phi i64 [%38, %$17] ; # L
; # (car Z)
  %43 = inttoptr i64 %41 to i64*
  %44 = load i64, i64* %43
; # (car L)
  %45 = inttoptr i64 %42 to i64*
  %46 = load i64, i64* %45
; # (equal (car Z) (car L))
  %47 = call i1 @equal(i64 %44, i64 %46)
; # (not (equal (car Z) (car L)))
  %48 = icmp eq i1 %47, 0
  br label %$18
$18:
  %49 = phi i64 [%37, %$17], [%41, %$19] ; # Z
  %50 = phi i64 [%38, %$17], [%42, %$19] ; # L
  %51 = phi i1 [1, %$17], [%48, %$19] ; # ->
  br i1 %51, label %$22, label %$20
$22:
  %52 = phi i64 [%49, %$18] ; # Z
  %53 = phi i64 [%50, %$18] ; # L
  br label %$21
$20:
  %54 = phi i64 [%49, %$18] ; # Z
  %55 = phi i64 [%50, %$18] ; # L
; # (? (atom (shift Z)) Y)
; # (shift Z)
  %56 = inttoptr i64 %54 to i64*
  %57 = getelementptr i64, i64* %56, i32 1
  %58 = load i64, i64* %57
; # (atom (shift Z))
  %59 = and i64 %58, 15
  %60 = icmp ne i64 %59, 0
  br i1 %60, label %$24, label %$23
$24:
  %61 = phi i64 [%58, %$20] ; # Z
  %62 = phi i64 [%55, %$20] ; # L
  br label %$21
$23:
  %63 = phi i64 [%58, %$20] ; # Z
  %64 = phi i64 [%55, %$20] ; # L
; # (shift L)
  %65 = inttoptr i64 %64 to i64*
  %66 = getelementptr i64, i64* %65, i32 1
  %67 = load i64, i64* %66
  br label %$17
$21:
  %68 = phi i64 [%52, %$22], [%61, %$24] ; # Z
  %69 = phi i64 [%53, %$22], [%62, %$24] ; # L
  %70 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$22], [%15, %$24] ; # ->
; # drop
  %71 = inttoptr i64 %22 to i64*
  %72 = getelementptr i64, i64* %71, i32 1
  %73 = load i64, i64* %72
  %74 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %73, i64* %74
  br label %$7
$10:
; # (xCnt Exe Y)
  %75 = call i64 @xCnt(i64 %0, i64 %15)
; # (=0 (xCnt Exe Y))
  %76 = icmp eq i64 %75, 0
  br i1 %76, label %$26, label %$25
$26:
  br label %$7
$25:
; # (let (N @ L (eval (car X))) (cond ((atom L) L) ((and (lt0 N) (le0...
; # (car X)
  %77 = inttoptr i64 %7 to i64*
  %78 = load i64, i64* %77
; # (eval (car X))
  %79 = and i64 %78, 6
  %80 = icmp ne i64 %79, 0
  br i1 %80, label %$29, label %$28
$29:
  br label %$27
$28:
  %81 = and i64 %78, 8
  %82 = icmp ne i64 %81, 0
  br i1 %82, label %$31, label %$30
$31:
  %83 = inttoptr i64 %78 to i64*
  %84 = load i64, i64* %83
  br label %$27
$30:
  %85 = call i64 @evList(i64 %78)
  br label %$27
$27:
  %86 = phi i64 [%78, %$29], [%84, %$31], [%85, %$30] ; # ->
; # (cond ((atom L) L) ((and (lt0 N) (le0 (inc 'N (length L)))) $Nil)...
; # (atom L)
  %87 = and i64 %86, 15
  %88 = icmp ne i64 %87, 0
  br i1 %88, label %$34, label %$33
$34:
  %89 = phi i64 [%75, %$27] ; # N
  %90 = phi i64 [%86, %$27] ; # L
  br label %$32
$33:
  %91 = phi i64 [%75, %$27] ; # N
  %92 = phi i64 [%86, %$27] ; # L
; # (and (lt0 N) (le0 (inc 'N (length L))))
; # (lt0 N)
  %93 = icmp slt i64 %91, 0
  br i1 %93, label %$36, label %$35
$36:
  %94 = phi i64 [%91, %$33] ; # N
  %95 = phi i64 [%92, %$33] ; # L
; # (length L)
  br label %$37
$37:
  %96 = phi i64 [%95, %$36], [%105, %$38] ; # X
  %97 = phi i64 [0, %$36], [%102, %$38] ; # N
  %98 = and i64 %96, 15
  %99 = icmp eq i64 %98, 0
  br i1 %99, label %$38, label %$39
$38:
  %100 = phi i64 [%96, %$37] ; # X
  %101 = phi i64 [%97, %$37] ; # N
  %102 = add i64 %101, 1
  %103 = inttoptr i64 %100 to i64*
  %104 = getelementptr i64, i64* %103, i32 1
  %105 = load i64, i64* %104
  br label %$37
$39:
  %106 = phi i64 [%96, %$37] ; # X
  %107 = phi i64 [%97, %$37] ; # N
; # (inc 'N (length L))
  %108 = add i64 %94, %107
; # (le0 (inc 'N (length L)))
  %109 = icmp sle i64 %108, 0
  br label %$35
$35:
  %110 = phi i64 [%91, %$33], [%108, %$39] ; # N
  %111 = phi i64 [%92, %$33], [%95, %$39] ; # L
  %112 = phi i1 [0, %$33], [%109, %$39] ; # ->
  br i1 %112, label %$41, label %$40
$41:
  %113 = phi i64 [%110, %$35] ; # N
  %114 = phi i64 [%111, %$35] ; # L
  br label %$32
$40:
  %115 = phi i64 [%110, %$35] ; # N
  %116 = phi i64 [%111, %$35] ; # L
; # (save L (let (Z (cons (car L) $Nil) R (save Z)) (while (and (dec ...
  %117 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %118 = load i64, i64* %117
  %119 = alloca i64, i64 2, align 16
  %120 = ptrtoint i64* %119 to i64
  %121 = inttoptr i64 %120 to i64*
  store i64 %116, i64* %121
  %122 = add i64 %120, 8
  %123 = inttoptr i64 %122 to i64*
  store i64 %118, i64* %123
  %124 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %120, i64* %124
; # (let (Z (cons (car L) $Nil) R (save Z)) (while (and (dec 'N) (pai...
; # (car L)
  %125 = inttoptr i64 %116 to i64*
  %126 = load i64, i64* %125
; # (cons (car L) $Nil)
  %127 = call i64 @cons(i64 %126, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (save Z)
  %128 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %129 = load i64, i64* %128
  %130 = alloca i64, i64 2, align 16
  %131 = ptrtoint i64* %130 to i64
  %132 = inttoptr i64 %131 to i64*
  store i64 %127, i64* %132
  %133 = add i64 %131, 8
  %134 = inttoptr i64 %133 to i64*
  store i64 %129, i64* %134
  %135 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %131, i64* %135
; # (while (and (dec 'N) (pair (shift L))) (setq Z (set 2 Z (cons (ca...
  br label %$42
$42:
  %136 = phi i64 [%115, %$40], [%153, %$45] ; # N
  %137 = phi i64 [%116, %$40], [%154, %$45] ; # L
  %138 = phi i64 [%127, %$40], [%158, %$45] ; # Z
; # (and (dec 'N) (pair (shift L)))
; # (dec 'N)
  %139 = sub i64 %136, 1
  %140 = icmp ne i64 %139, 0
  br i1 %140, label %$44, label %$43
$44:
  %141 = phi i64 [%139, %$42] ; # N
  %142 = phi i64 [%137, %$42] ; # L
  %143 = phi i64 [%138, %$42] ; # Z
; # (shift L)
  %144 = inttoptr i64 %142 to i64*
  %145 = getelementptr i64, i64* %144, i32 1
  %146 = load i64, i64* %145
; # (pair (shift L))
  %147 = and i64 %146, 15
  %148 = icmp eq i64 %147, 0
  br label %$43
$43:
  %149 = phi i64 [%139, %$42], [%141, %$44] ; # N
  %150 = phi i64 [%137, %$42], [%146, %$44] ; # L
  %151 = phi i64 [%138, %$42], [%143, %$44] ; # Z
  %152 = phi i1 [0, %$42], [%148, %$44] ; # ->
  br i1 %152, label %$45, label %$46
$45:
  %153 = phi i64 [%149, %$43] ; # N
  %154 = phi i64 [%150, %$43] ; # L
  %155 = phi i64 [%151, %$43] ; # Z
; # (set 2 Z (cons (car L) $Nil))
; # (car L)
  %156 = inttoptr i64 %154 to i64*
  %157 = load i64, i64* %156
; # (cons (car L) $Nil)
  %158 = call i64 @cons(i64 %157, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %159 = inttoptr i64 %155 to i64*
  %160 = getelementptr i64, i64* %159, i32 1
  store i64 %158, i64* %160
  br label %$42
$46:
  %161 = phi i64 [%149, %$43] ; # N
  %162 = phi i64 [%150, %$43] ; # L
  %163 = phi i64 [%151, %$43] ; # Z
; # drop
  %164 = inttoptr i64 %120 to i64*
  %165 = getelementptr i64, i64* %164, i32 1
  %166 = load i64, i64* %165
  %167 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %166, i64* %167
  br label %$32
$32:
  %168 = phi i64 [%89, %$34], [%113, %$41], [%161, %$46] ; # N
  %169 = phi i64 [%90, %$34], [%114, %$41], [%162, %$46] ; # L
  %170 = phi i64 [%90, %$34], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$41], [%127, %$46] ; # ->
  br label %$7
$7:
  %171 = phi i64 [%15, %$9], [%70, %$21], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$26], [%170, %$32] ; # ->
  ret i64 %171
}

define i64 @_Tail(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (eval (++ X))) (cond ((nil? Y) Y) ((pair Y) (...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (cond ((nil? Y) Y) ((pair Y) (save Y (let L (eval (car X)) (loop ...
; # (nil? Y)
  %16 = icmp eq i64 %15, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %16, label %$9, label %$8
$9:
  br label %$7
$8:
; # (pair Y)
  %17 = and i64 %15, 15
  %18 = icmp eq i64 %17, 0
  br i1 %18, label %$11, label %$10
$11:
; # (save Y (let L (eval (car X)) (loop (? (atom L) $Nil) (? (equal L...
  %19 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %20 = load i64, i64* %19
  %21 = alloca i64, i64 2, align 16
  %22 = ptrtoint i64* %21 to i64
  %23 = inttoptr i64 %22 to i64*
  store i64 %15, i64* %23
  %24 = add i64 %22, 8
  %25 = inttoptr i64 %24 to i64*
  store i64 %20, i64* %25
  %26 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %22, i64* %26
; # (let L (eval (car X)) (loop (? (atom L) $Nil) (? (equal L Y) Y) (...
; # (car X)
  %27 = inttoptr i64 %7 to i64*
  %28 = load i64, i64* %27
; # (eval (car X))
  %29 = and i64 %28, 6
  %30 = icmp ne i64 %29, 0
  br i1 %30, label %$14, label %$13
$14:
  br label %$12
$13:
  %31 = and i64 %28, 8
  %32 = icmp ne i64 %31, 0
  br i1 %32, label %$16, label %$15
$16:
  %33 = inttoptr i64 %28 to i64*
  %34 = load i64, i64* %33
  br label %$12
$15:
  %35 = call i64 @evList(i64 %28)
  br label %$12
$12:
  %36 = phi i64 [%28, %$14], [%34, %$16], [%35, %$15] ; # ->
; # (loop (? (atom L) $Nil) (? (equal L Y) Y) (? (atom (shift L)) $Ni...
  br label %$17
$17:
  %37 = phi i64 [%36, %$12], [%51, %$23] ; # L
; # (? (atom L) $Nil)
; # (atom L)
  %38 = and i64 %37, 15
  %39 = icmp ne i64 %38, 0
  br i1 %39, label %$20, label %$18
$20:
  %40 = phi i64 [%37, %$17] ; # L
  br label %$19
$18:
  %41 = phi i64 [%37, %$17] ; # L
; # (? (equal L Y) Y)
; # (equal L Y)
  %42 = call i1 @equal(i64 %41, i64 %15)
  br i1 %42, label %$22, label %$21
$22:
  %43 = phi i64 [%41, %$18] ; # L
  br label %$19
$21:
  %44 = phi i64 [%41, %$18] ; # L
; # (? (atom (shift L)) $Nil)
; # (shift L)
  %45 = inttoptr i64 %44 to i64*
  %46 = getelementptr i64, i64* %45, i32 1
  %47 = load i64, i64* %46
; # (atom (shift L))
  %48 = and i64 %47, 15
  %49 = icmp ne i64 %48, 0
  br i1 %49, label %$24, label %$23
$24:
  %50 = phi i64 [%47, %$21] ; # L
  br label %$19
$23:
  %51 = phi i64 [%47, %$21] ; # L
  br label %$17
$19:
  %52 = phi i64 [%40, %$20], [%43, %$22], [%50, %$24] ; # L
  %53 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$20], [%15, %$22], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$24] ; # ->
; # drop
  %54 = inttoptr i64 %22 to i64*
  %55 = getelementptr i64, i64* %54, i32 1
  %56 = load i64, i64* %55
  %57 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %56, i64* %57
  br label %$7
$10:
; # (xCnt Exe Y)
  %58 = call i64 @xCnt(i64 %0, i64 %15)
; # (=0 (xCnt Exe Y))
  %59 = icmp eq i64 %58, 0
  br i1 %59, label %$26, label %$25
$26:
  br label %$7
$25:
; # (let (N @ L (eval (car X))) (cond ((atom L) L) ((lt0 N) (loop (sh...
; # (car X)
  %60 = inttoptr i64 %7 to i64*
  %61 = load i64, i64* %60
; # (eval (car X))
  %62 = and i64 %61, 6
  %63 = icmp ne i64 %62, 0
  br i1 %63, label %$29, label %$28
$29:
  br label %$27
$28:
  %64 = and i64 %61, 8
  %65 = icmp ne i64 %64, 0
  br i1 %65, label %$31, label %$30
$31:
  %66 = inttoptr i64 %61 to i64*
  %67 = load i64, i64* %66
  br label %$27
$30:
  %68 = call i64 @evList(i64 %61)
  br label %$27
$27:
  %69 = phi i64 [%61, %$29], [%67, %$31], [%68, %$30] ; # ->
; # (cond ((atom L) L) ((lt0 N) (loop (shift L) (? (=0 (inc 'N)) L)))...
; # (atom L)
  %70 = and i64 %69, 15
  %71 = icmp ne i64 %70, 0
  br i1 %71, label %$34, label %$33
$34:
  %72 = phi i64 [%58, %$27] ; # N
  %73 = phi i64 [%69, %$27] ; # L
  br label %$32
$33:
  %74 = phi i64 [%58, %$27] ; # N
  %75 = phi i64 [%69, %$27] ; # L
; # (lt0 N)
  %76 = icmp slt i64 %74, 0
  br i1 %76, label %$36, label %$35
$36:
  %77 = phi i64 [%74, %$33] ; # N
  %78 = phi i64 [%75, %$33] ; # L
; # (loop (shift L) (? (=0 (inc 'N)) L))
  br label %$37
$37:
  %79 = phi i64 [%77, %$36], [%88, %$38] ; # N
  %80 = phi i64 [%78, %$36], [%89, %$38] ; # L
; # (shift L)
  %81 = inttoptr i64 %80 to i64*
  %82 = getelementptr i64, i64* %81, i32 1
  %83 = load i64, i64* %82
; # (? (=0 (inc 'N)) L)
; # (inc 'N)
  %84 = add i64 %79, 1
; # (=0 (inc 'N))
  %85 = icmp eq i64 %84, 0
  br i1 %85, label %$40, label %$38
$40:
  %86 = phi i64 [%84, %$37] ; # N
  %87 = phi i64 [%83, %$37] ; # L
  br label %$39
$38:
  %88 = phi i64 [%84, %$37] ; # N
  %89 = phi i64 [%83, %$37] ; # L
  br label %$37
$39:
  %90 = phi i64 [%86, %$40] ; # N
  %91 = phi i64 [%87, %$40] ; # L
  %92 = phi i64 [%87, %$40] ; # ->
  br label %$32
$35:
  %93 = phi i64 [%74, %$33] ; # N
  %94 = phi i64 [%75, %$33] ; # L
; # (let Z L (loop (? (=0 (dec 'N))) (? (atom (shift Z)))) (while (pa...
; # (loop (? (=0 (dec 'N))) (? (atom (shift Z))))
  br label %$41
$41:
  %95 = phi i64 [%93, %$35], [%108, %$44] ; # N
  %96 = phi i64 [%94, %$35], [%109, %$44] ; # L
  %97 = phi i64 [%94, %$35], [%110, %$44] ; # Z
; # (? (=0 (dec 'N)))
; # (dec 'N)
  %98 = sub i64 %95, 1
; # (=0 (dec 'N))
  %99 = icmp eq i64 %98, 0
  br i1 %99, label %$43, label %$42
$42:
  %100 = phi i64 [%98, %$41] ; # N
  %101 = phi i64 [%96, %$41] ; # L
  %102 = phi i64 [%97, %$41] ; # Z
; # (? (atom (shift Z)))
; # (shift Z)
  %103 = inttoptr i64 %102 to i64*
  %104 = getelementptr i64, i64* %103, i32 1
  %105 = load i64, i64* %104
; # (atom (shift Z))
  %106 = and i64 %105, 15
  %107 = icmp ne i64 %106, 0
  br i1 %107, label %$43, label %$44
$44:
  %108 = phi i64 [%100, %$42] ; # N
  %109 = phi i64 [%101, %$42] ; # L
  %110 = phi i64 [%105, %$42] ; # Z
  br label %$41
$43:
  %111 = phi i64 [%98, %$41], [%100, %$42] ; # N
  %112 = phi i64 [%96, %$41], [%101, %$42] ; # L
  %113 = phi i64 [%97, %$41], [%105, %$42] ; # Z
  %114 = phi i64 [0, %$41], [0, %$42] ; # ->
; # (while (pair (shift Z)) (shift L))
  br label %$45
$45:
  %115 = phi i64 [%111, %$43], [%123, %$46] ; # N
  %116 = phi i64 [%112, %$43], [%128, %$46] ; # L
  %117 = phi i64 [%113, %$43], [%125, %$46] ; # Z
; # (shift Z)
  %118 = inttoptr i64 %117 to i64*
  %119 = getelementptr i64, i64* %118, i32 1
  %120 = load i64, i64* %119
; # (pair (shift Z))
  %121 = and i64 %120, 15
  %122 = icmp eq i64 %121, 0
  br i1 %122, label %$46, label %$47
$46:
  %123 = phi i64 [%115, %$45] ; # N
  %124 = phi i64 [%116, %$45] ; # L
  %125 = phi i64 [%120, %$45] ; # Z
; # (shift L)
  %126 = inttoptr i64 %124 to i64*
  %127 = getelementptr i64, i64* %126, i32 1
  %128 = load i64, i64* %127
  br label %$45
$47:
  %129 = phi i64 [%115, %$45] ; # N
  %130 = phi i64 [%116, %$45] ; # L
  %131 = phi i64 [%120, %$45] ; # Z
  br label %$32
$32:
  %132 = phi i64 [%72, %$34], [%90, %$39], [%129, %$47] ; # N
  %133 = phi i64 [%73, %$34], [%91, %$39], [%130, %$47] ; # L
  %134 = phi i64 [%73, %$34], [%92, %$39], [%130, %$47] ; # ->
  br label %$7
$7:
  %135 = phi i64 [%15, %$9], [%53, %$19], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$26], [%134, %$32] ; # ->
  ret i64 %135
}

define i64 @_Stem(i64) align 8 {
$1:
; # (let (X (cdr Exe) L (save (eval (++ X)))) (if (atom X) L (let (R ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (save (eval (++ X)))
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %17 = load i64, i64* %16
  %18 = alloca i64, i64 2, align 16
  %19 = ptrtoint i64* %18 to i64
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = add i64 %19, 8
  %22 = inttoptr i64 %21 to i64*
  store i64 %17, i64* %22
  %23 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %19, i64* %23
; # (if (atom X) L (let (R L N 1 A T) (loop (setq A (link (push (eval...
; # (atom X)
  %24 = and i64 %7, 15
  %25 = icmp ne i64 %24, 0
  br i1 %25, label %$7, label %$8
$7:
  %26 = phi i64 [%7, %$2] ; # X
  %27 = phi i64 [%15, %$2] ; # L
  br label %$9
$8:
  %28 = phi i64 [%7, %$2] ; # X
  %29 = phi i64 [%15, %$2] ; # L
; # (let (R L N 1 A T) (loop (setq A (link (push (eval (car X)) NIL))...
; # (loop (setq A (link (push (eval (car X)) NIL))) (? (atom (shift X...
  br label %$10
$10:
  %30 = phi i64 [%28, %$8], [%57, %$16] ; # X
  %31 = phi i64 [%29, %$8], [%58, %$16] ; # L
  %32 = phi i64 [%29, %$8], [%59, %$16] ; # R
  %33 = phi i64 [1, %$8], [%62, %$16] ; # N
; # (car X)
  %34 = inttoptr i64 %30 to i64*
  %35 = load i64, i64* %34
; # (eval (car X))
  %36 = and i64 %35, 6
  %37 = icmp ne i64 %36, 0
  br i1 %37, label %$13, label %$12
$13:
  br label %$11
$12:
  %38 = and i64 %35, 8
  %39 = icmp ne i64 %38, 0
  br i1 %39, label %$15, label %$14
$15:
  %40 = inttoptr i64 %35 to i64*
  %41 = load i64, i64* %40
  br label %$11
$14:
  %42 = call i64 @evList(i64 %35)
  br label %$11
$11:
  %43 = phi i64 [%35, %$13], [%41, %$15], [%42, %$14] ; # ->
; # (push (eval (car X)) NIL)
  %44 = alloca i64, i64 2, align 16
  %45 = ptrtoint i64* %44 to i64
  %46 = inttoptr i64 %45 to i64*
  store i64 %43, i64* %46
; # (link (push (eval (car X)) NIL))
  %47 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %48 = load i64, i64* %47
  %49 = inttoptr i64 %45 to i64*
  %50 = getelementptr i64, i64* %49, i32 1
  store i64 %48, i64* %50
  %51 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %45, i64* %51
; # (? (atom (shift X)))
; # (shift X)
  %52 = inttoptr i64 %30 to i64*
  %53 = getelementptr i64, i64* %52, i32 1
  %54 = load i64, i64* %53
; # (atom (shift X))
  %55 = and i64 %54, 15
  %56 = icmp ne i64 %55, 0
  br i1 %56, label %$17, label %$16
$16:
  %57 = phi i64 [%54, %$11] ; # X
  %58 = phi i64 [%31, %$11] ; # L
  %59 = phi i64 [%32, %$11] ; # R
  %60 = phi i64 [%33, %$11] ; # N
  %61 = phi i64 [%45, %$11] ; # A
; # (inc 'N)
  %62 = add i64 %60, 1
  br label %$10
$17:
  %63 = phi i64 [%54, %$11] ; # X
  %64 = phi i64 [%31, %$11] ; # L
  %65 = phi i64 [%32, %$11] ; # R
  %66 = phi i64 [%33, %$11] ; # N
  %67 = phi i64 [%45, %$11] ; # A
  %68 = phi i64 [0, %$11] ; # ->
; # (loop (let (P A I N) (loop (? (equal (car L) (car P)) (setq R (cd...
  br label %$18
$18:
  %69 = phi i64 [%63, %$17], [%128, %$24] ; # X
  %70 = phi i64 [%64, %$17], [%129, %$24] ; # L
  %71 = phi i64 [%65, %$17], [%130, %$24] ; # R
  %72 = phi i64 [%66, %$17], [%131, %$24] ; # N
  %73 = phi i64 [%67, %$17], [%132, %$24] ; # A
; # (let (P A I N) (loop (? (equal (car L) (car P)) (setq R (cdr L)))...
; # (loop (? (equal (car L) (car P)) (setq R (cdr L))) (? (=0 (dec 'I...
  br label %$19
$19:
  %74 = phi i64 [%69, %$18], [%105, %$23] ; # X
  %75 = phi i64 [%70, %$18], [%106, %$23] ; # L
  %76 = phi i64 [%71, %$18], [%107, %$23] ; # R
  %77 = phi i64 [%72, %$18], [%108, %$23] ; # N
  %78 = phi i64 [%73, %$18], [%109, %$23] ; # A
  %79 = phi i64 [%73, %$18], [%114, %$23] ; # P
  %80 = phi i64 [%72, %$18], [%111, %$23] ; # I
; # (? (equal (car L) (car P)) (setq R (cdr L)))
; # (car L)
  %81 = inttoptr i64 %75 to i64*
  %82 = load i64, i64* %81
; # (car P)
  %83 = inttoptr i64 %79 to i64*
  %84 = load i64, i64* %83
; # (equal (car L) (car P))
  %85 = call i1 @equal(i64 %82, i64 %84)
  br i1 %85, label %$22, label %$20
$22:
  %86 = phi i64 [%74, %$19] ; # X
  %87 = phi i64 [%75, %$19] ; # L
  %88 = phi i64 [%76, %$19] ; # R
  %89 = phi i64 [%77, %$19] ; # N
  %90 = phi i64 [%78, %$19] ; # A
  %91 = phi i64 [%79, %$19] ; # P
  %92 = phi i64 [%80, %$19] ; # I
; # (cdr L)
  %93 = inttoptr i64 %87 to i64*
  %94 = getelementptr i64, i64* %93, i32 1
  %95 = load i64, i64* %94
  br label %$21
$20:
  %96 = phi i64 [%74, %$19] ; # X
  %97 = phi i64 [%75, %$19] ; # L
  %98 = phi i64 [%76, %$19] ; # R
  %99 = phi i64 [%77, %$19] ; # N
  %100 = phi i64 [%78, %$19] ; # A
  %101 = phi i64 [%79, %$19] ; # P
  %102 = phi i64 [%80, %$19] ; # I
; # (? (=0 (dec 'I)))
; # (dec 'I)
  %103 = sub i64 %102, 1
; # (=0 (dec 'I))
  %104 = icmp eq i64 %103, 0
  br i1 %104, label %$21, label %$23
$23:
  %105 = phi i64 [%96, %$20] ; # X
  %106 = phi i64 [%97, %$20] ; # L
  %107 = phi i64 [%98, %$20] ; # R
  %108 = phi i64 [%99, %$20] ; # N
  %109 = phi i64 [%100, %$20] ; # A
  %110 = phi i64 [%101, %$20] ; # P
  %111 = phi i64 [%103, %$20] ; # I
; # (shift P)
  %112 = inttoptr i64 %110 to i64*
  %113 = getelementptr i64, i64* %112, i32 1
  %114 = load i64, i64* %113
  br label %$19
$21:
  %115 = phi i64 [%86, %$22], [%96, %$20] ; # X
  %116 = phi i64 [%87, %$22], [%97, %$20] ; # L
  %117 = phi i64 [%95, %$22], [%98, %$20] ; # R
  %118 = phi i64 [%89, %$22], [%99, %$20] ; # N
  %119 = phi i64 [%90, %$22], [%100, %$20] ; # A
  %120 = phi i64 [%91, %$22], [%101, %$20] ; # P
  %121 = phi i64 [%92, %$22], [%103, %$20] ; # I
  %122 = phi i64 [%95, %$22], [0, %$20] ; # ->
; # (? (atom (shift L)))
; # (shift L)
  %123 = inttoptr i64 %116 to i64*
  %124 = getelementptr i64, i64* %123, i32 1
  %125 = load i64, i64* %124
; # (atom (shift L))
  %126 = and i64 %125, 15
  %127 = icmp ne i64 %126, 0
  br i1 %127, label %$25, label %$24
$24:
  %128 = phi i64 [%115, %$21] ; # X
  %129 = phi i64 [%125, %$21] ; # L
  %130 = phi i64 [%117, %$21] ; # R
  %131 = phi i64 [%118, %$21] ; # N
  %132 = phi i64 [%119, %$21] ; # A
  br label %$18
$25:
  %133 = phi i64 [%115, %$21] ; # X
  %134 = phi i64 [%125, %$21] ; # L
  %135 = phi i64 [%117, %$21] ; # R
  %136 = phi i64 [%118, %$21] ; # N
  %137 = phi i64 [%119, %$21] ; # A
  %138 = phi i64 [0, %$21] ; # ->
  br label %$9
$9:
  %139 = phi i64 [%26, %$7], [%133, %$25] ; # X
  %140 = phi i64 [%27, %$7], [%134, %$25] ; # L
  %141 = phi i64 [%27, %$7], [%135, %$25] ; # ->
; # (drop *Safe)
  %142 = inttoptr i64 %19 to i64*
  %143 = getelementptr i64, i64* %142, i32 1
  %144 = load i64, i64* %143
  %145 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %144, i64* %145
  ret i64 %141
}

define i64 @_Fin(i64) align 8 {
$1:
; # (let X (eval (cadr Exe)) (while (pair X) (shift X)) X)
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (while (pair X) (shift X))
  br label %$7
$7:
  %14 = phi i64 [%13, %$2], [%20, %$8] ; # X
; # (pair X)
  %15 = and i64 %14, 15
  %16 = icmp eq i64 %15, 0
  br i1 %16, label %$8, label %$9
$8:
  %17 = phi i64 [%14, %$7] ; # X
; # (shift X)
  %18 = inttoptr i64 %17 to i64*
  %19 = getelementptr i64, i64* %18, i32 1
  %20 = load i64, i64* %19
  br label %$7
$9:
  %21 = phi i64 [%14, %$7] ; # X
  ret i64 %21
}

define i64 @_Last(i64) align 8 {
$1:
; # (let X (eval (cadr Exe)) (if (atom X) X (while (pair (cdr X)) (se...
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (if (atom X) X (while (pair (cdr X)) (setq X @)) (car X))
; # (atom X)
  %14 = and i64 %13, 15
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$7, label %$8
$7:
  %16 = phi i64 [%13, %$2] ; # X
  br label %$9
$8:
  %17 = phi i64 [%13, %$2] ; # X
; # (while (pair (cdr X)) (setq X @))
  br label %$10
$10:
  %18 = phi i64 [%17, %$8], [%21, %$11] ; # X
; # (cdr X)
  %19 = inttoptr i64 %18 to i64*
  %20 = getelementptr i64, i64* %19, i32 1
  %21 = load i64, i64* %20
; # (pair (cdr X))
  %22 = and i64 %21, 15
  %23 = icmp eq i64 %22, 0
  br i1 %23, label %$11, label %$12
$11:
  %24 = phi i64 [%18, %$10] ; # X
  br label %$10
$12:
  %25 = phi i64 [%18, %$10] ; # X
; # (car X)
  %26 = inttoptr i64 %25 to i64*
  %27 = load i64, i64* %26
  br label %$9
$9:
  %28 = phi i64 [%16, %$7], [%25, %$12] ; # X
  %29 = phi i64 [%16, %$7], [%27, %$12] ; # ->
  ret i64 %29
}

define i64 @_Eq(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (save (eval (car X)))) (loop (? (atom (shift ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (car X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (car X))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (save (eval (car X)))
  %14 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %15 = load i64, i64* %14
  %16 = alloca i64, i64 2, align 16
  %17 = ptrtoint i64* %16 to i64
  %18 = inttoptr i64 %17 to i64*
  store i64 %13, i64* %18
  %19 = add i64 %17, 8
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %17, i64* %21
; # (loop (? (atom (shift X)) $T) (? (<> Y (eval (car X))) $Nil))
  br label %$7
$7:
  %22 = phi i64 [%3, %$2], [%42, %$16] ; # X
; # (? (atom (shift X)) $T)
; # (shift X)
  %23 = inttoptr i64 %22 to i64*
  %24 = getelementptr i64, i64* %23, i32 1
  %25 = load i64, i64* %24
; # (atom (shift X))
  %26 = and i64 %25, 15
  %27 = icmp ne i64 %26, 0
  br i1 %27, label %$10, label %$8
$10:
  %28 = phi i64 [%25, %$7] ; # X
  br label %$9
$8:
  %29 = phi i64 [%25, %$7] ; # X
; # (? (<> Y (eval (car X))) $Nil)
; # (car X)
  %30 = inttoptr i64 %29 to i64*
  %31 = load i64, i64* %30
; # (eval (car X))
  %32 = and i64 %31, 6
  %33 = icmp ne i64 %32, 0
  br i1 %33, label %$13, label %$12
$13:
  br label %$11
$12:
  %34 = and i64 %31, 8
  %35 = icmp ne i64 %34, 0
  br i1 %35, label %$15, label %$14
$15:
  %36 = inttoptr i64 %31 to i64*
  %37 = load i64, i64* %36
  br label %$11
$14:
  %38 = call i64 @evList(i64 %31)
  br label %$11
$11:
  %39 = phi i64 [%31, %$13], [%37, %$15], [%38, %$14] ; # ->
; # (<> Y (eval (car X)))
  %40 = icmp ne i64 %13, %39
  br i1 %40, label %$17, label %$16
$17:
  %41 = phi i64 [%29, %$11] ; # X
  br label %$9
$16:
  %42 = phi i64 [%29, %$11] ; # X
  br label %$7
$9:
  %43 = phi i64 [%28, %$10], [%41, %$17] ; # X
  %44 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$17] ; # ->
; # (drop *Safe)
  %45 = inttoptr i64 %17 to i64*
  %46 = getelementptr i64, i64* %45, i32 1
  %47 = load i64, i64* %46
  %48 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %47, i64* %48
  ret i64 %44
}

define i64 @_Neq(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (save (eval (car X)))) (loop (? (atom (shift ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (car X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (car X))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (save (eval (car X)))
  %14 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %15 = load i64, i64* %14
  %16 = alloca i64, i64 2, align 16
  %17 = ptrtoint i64* %16 to i64
  %18 = inttoptr i64 %17 to i64*
  store i64 %13, i64* %18
  %19 = add i64 %17, 8
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %17, i64* %21
; # (loop (? (atom (shift X)) $Nil) (? (<> Y (eval (car X))) $T))
  br label %$7
$7:
  %22 = phi i64 [%3, %$2], [%42, %$16] ; # X
; # (? (atom (shift X)) $Nil)
; # (shift X)
  %23 = inttoptr i64 %22 to i64*
  %24 = getelementptr i64, i64* %23, i32 1
  %25 = load i64, i64* %24
; # (atom (shift X))
  %26 = and i64 %25, 15
  %27 = icmp ne i64 %26, 0
  br i1 %27, label %$10, label %$8
$10:
  %28 = phi i64 [%25, %$7] ; # X
  br label %$9
$8:
  %29 = phi i64 [%25, %$7] ; # X
; # (? (<> Y (eval (car X))) $T)
; # (car X)
  %30 = inttoptr i64 %29 to i64*
  %31 = load i64, i64* %30
; # (eval (car X))
  %32 = and i64 %31, 6
  %33 = icmp ne i64 %32, 0
  br i1 %33, label %$13, label %$12
$13:
  br label %$11
$12:
  %34 = and i64 %31, 8
  %35 = icmp ne i64 %34, 0
  br i1 %35, label %$15, label %$14
$15:
  %36 = inttoptr i64 %31 to i64*
  %37 = load i64, i64* %36
  br label %$11
$14:
  %38 = call i64 @evList(i64 %31)
  br label %$11
$11:
  %39 = phi i64 [%31, %$13], [%37, %$15], [%38, %$14] ; # ->
; # (<> Y (eval (car X)))
  %40 = icmp ne i64 %13, %39
  br i1 %40, label %$17, label %$16
$17:
  %41 = phi i64 [%29, %$11] ; # X
  br label %$9
$16:
  %42 = phi i64 [%29, %$11] ; # X
  br label %$7
$9:
  %43 = phi i64 [%28, %$10], [%41, %$17] ; # X
  %44 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$17] ; # ->
; # (drop *Safe)
  %45 = inttoptr i64 %17 to i64*
  %46 = getelementptr i64, i64* %45, i32 1
  %47 = load i64, i64* %46
  %48 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %47, i64* %48
  ret i64 %44
}

define i64 @_Equal(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (save (eval (car X)))) (loop (? (atom (shift ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (car X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (car X))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (save (eval (car X)))
  %14 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %15 = load i64, i64* %14
  %16 = alloca i64, i64 2, align 16
  %17 = ptrtoint i64* %16 to i64
  %18 = inttoptr i64 %17 to i64*
  store i64 %13, i64* %18
  %19 = add i64 %17, 8
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %17, i64* %21
; # (loop (? (atom (shift X)) $T) (? (not (equal Y (eval (car X)))) $...
  br label %$7
$7:
  %22 = phi i64 [%3, %$2], [%43, %$16] ; # X
; # (? (atom (shift X)) $T)
; # (shift X)
  %23 = inttoptr i64 %22 to i64*
  %24 = getelementptr i64, i64* %23, i32 1
  %25 = load i64, i64* %24
; # (atom (shift X))
  %26 = and i64 %25, 15
  %27 = icmp ne i64 %26, 0
  br i1 %27, label %$10, label %$8
$10:
  %28 = phi i64 [%25, %$7] ; # X
  br label %$9
$8:
  %29 = phi i64 [%25, %$7] ; # X
; # (? (not (equal Y (eval (car X)))) $Nil)
; # (car X)
  %30 = inttoptr i64 %29 to i64*
  %31 = load i64, i64* %30
; # (eval (car X))
  %32 = and i64 %31, 6
  %33 = icmp ne i64 %32, 0
  br i1 %33, label %$13, label %$12
$13:
  br label %$11
$12:
  %34 = and i64 %31, 8
  %35 = icmp ne i64 %34, 0
  br i1 %35, label %$15, label %$14
$15:
  %36 = inttoptr i64 %31 to i64*
  %37 = load i64, i64* %36
  br label %$11
$14:
  %38 = call i64 @evList(i64 %31)
  br label %$11
$11:
  %39 = phi i64 [%31, %$13], [%37, %$15], [%38, %$14] ; # ->
; # (equal Y (eval (car X)))
  %40 = call i1 @equal(i64 %13, i64 %39)
; # (not (equal Y (eval (car X))))
  %41 = icmp eq i1 %40, 0
  br i1 %41, label %$17, label %$16
$17:
  %42 = phi i64 [%29, %$11] ; # X
  br label %$9
$16:
  %43 = phi i64 [%29, %$11] ; # X
  br label %$7
$9:
  %44 = phi i64 [%28, %$10], [%42, %$17] ; # X
  %45 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$17] ; # ->
; # (drop *Safe)
  %46 = inttoptr i64 %17 to i64*
  %47 = getelementptr i64, i64* %46, i32 1
  %48 = load i64, i64* %47
  %49 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %48, i64* %49
  ret i64 %45
}

define i64 @_Nequal(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (save (eval (car X)))) (loop (? (atom (shift ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (car X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (car X))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (save (eval (car X)))
  %14 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %15 = load i64, i64* %14
  %16 = alloca i64, i64 2, align 16
  %17 = ptrtoint i64* %16 to i64
  %18 = inttoptr i64 %17 to i64*
  store i64 %13, i64* %18
  %19 = add i64 %17, 8
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %17, i64* %21
; # (loop (? (atom (shift X)) $Nil) (? (not (equal Y (eval (car X))))...
  br label %$7
$7:
  %22 = phi i64 [%3, %$2], [%43, %$16] ; # X
; # (? (atom (shift X)) $Nil)
; # (shift X)
  %23 = inttoptr i64 %22 to i64*
  %24 = getelementptr i64, i64* %23, i32 1
  %25 = load i64, i64* %24
; # (atom (shift X))
  %26 = and i64 %25, 15
  %27 = icmp ne i64 %26, 0
  br i1 %27, label %$10, label %$8
$10:
  %28 = phi i64 [%25, %$7] ; # X
  br label %$9
$8:
  %29 = phi i64 [%25, %$7] ; # X
; # (? (not (equal Y (eval (car X)))) $T)
; # (car X)
  %30 = inttoptr i64 %29 to i64*
  %31 = load i64, i64* %30
; # (eval (car X))
  %32 = and i64 %31, 6
  %33 = icmp ne i64 %32, 0
  br i1 %33, label %$13, label %$12
$13:
  br label %$11
$12:
  %34 = and i64 %31, 8
  %35 = icmp ne i64 %34, 0
  br i1 %35, label %$15, label %$14
$15:
  %36 = inttoptr i64 %31 to i64*
  %37 = load i64, i64* %36
  br label %$11
$14:
  %38 = call i64 @evList(i64 %31)
  br label %$11
$11:
  %39 = phi i64 [%31, %$13], [%37, %$15], [%38, %$14] ; # ->
; # (equal Y (eval (car X)))
  %40 = call i1 @equal(i64 %13, i64 %39)
; # (not (equal Y (eval (car X))))
  %41 = icmp eq i1 %40, 0
  br i1 %41, label %$17, label %$16
$17:
  %42 = phi i64 [%29, %$11] ; # X
  br label %$9
$16:
  %43 = phi i64 [%29, %$11] ; # X
  br label %$7
$9:
  %44 = phi i64 [%28, %$10], [%42, %$17] ; # X
  %45 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$17] ; # ->
; # (drop *Safe)
  %46 = inttoptr i64 %17 to i64*
  %47 = getelementptr i64, i64* %46, i32 1
  %48 = load i64, i64* %47
  %49 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %48, i64* %49
  ret i64 %45
}

define i64 @_Eq0(i64) align 8 {
$1:
; # (if (== (eval (cadr Exe)) ZERO) @ $Nil)
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (== (eval (cadr Exe)) ZERO)
  %14 = icmp eq i64 %13, 2
  br i1 %14, label %$7, label %$8
$7:
  br label %$9
$8:
  br label %$9
$9:
  %15 = phi i64 [%13, %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # ->
  ret i64 %15
}

define i64 @_Eq1(i64) align 8 {
$1:
; # (if (== (eval (cadr Exe)) ONE) @ $Nil)
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (== (eval (cadr Exe)) ONE)
  %14 = icmp eq i64 %13, 18
  br i1 %14, label %$7, label %$8
$7:
  br label %$9
$8:
  br label %$9
$9:
  %15 = phi i64 [%13, %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # ->
  ret i64 %15
}

define i64 @_EqT(i64) align 8 {
$1:
; # (if (t? (eval (cadr Exe))) @ $Nil)
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (t? (eval (cadr Exe)))
  %14 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %14, label %$7, label %$8
$7:
  br label %$9
$8:
  br label %$9
$9:
  %15 = phi i64 [%13, %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # ->
  ret i64 %15
}

define i64 @_Neq0(i64) align 8 {
$1:
; # (if (== (eval (cadr Exe)) ZERO) $Nil $T)
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (== (eval (cadr Exe)) ZERO)
  %14 = icmp eq i64 %13, 2
  br i1 %14, label %$7, label %$8
$7:
  br label %$9
$8:
  br label %$9
$9:
  %15 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$8] ; # ->
  ret i64 %15
}

define i64 @_NeqT(i64) align 8 {
$1:
; # (if (t? (eval (cadr Exe))) $Nil $T)
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (t? (eval (cadr Exe)))
  %14 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %14, label %$7, label %$8
$7:
  br label %$9
$8:
  br label %$9
$9:
  %15 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$8] ; # ->
  ret i64 %15
}

define i64 @_Lt(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (save (eval (car X)))) (loop (? (atom (shift ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (car X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (car X))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (save (eval (car X)))
  %14 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %15 = load i64, i64* %14
  %16 = alloca i64, i64 2, align 16
  %17 = ptrtoint i64* %16 to i64
  %18 = inttoptr i64 %17 to i64*
  store i64 %13, i64* %18
  %19 = add i64 %17, 8
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %17, i64* %21
; # (loop (? (atom (shift X)) $T) (let Z (eval (car X)) (? (ge0 (comp...
  br label %$7
$7:
  %22 = phi i64 [%3, %$2], [%47, %$16] ; # X
  %23 = phi i64 [%13, %$2], [%42, %$16] ; # Y
; # (? (atom (shift X)) $T)
; # (shift X)
  %24 = inttoptr i64 %22 to i64*
  %25 = getelementptr i64, i64* %24, i32 1
  %26 = load i64, i64* %25
; # (atom (shift X))
  %27 = and i64 %26, 15
  %28 = icmp ne i64 %27, 0
  br i1 %28, label %$10, label %$8
$10:
  %29 = phi i64 [%26, %$7] ; # X
  %30 = phi i64 [%23, %$7] ; # Y
  br label %$9
$8:
  %31 = phi i64 [%26, %$7] ; # X
  %32 = phi i64 [%23, %$7] ; # Y
; # (let Z (eval (car X)) (? (ge0 (compare Y Z)) $Nil) (setq Y (safe ...
; # (car X)
  %33 = inttoptr i64 %31 to i64*
  %34 = load i64, i64* %33
; # (eval (car X))
  %35 = and i64 %34, 6
  %36 = icmp ne i64 %35, 0
  br i1 %36, label %$13, label %$12
$13:
  br label %$11
$12:
  %37 = and i64 %34, 8
  %38 = icmp ne i64 %37, 0
  br i1 %38, label %$15, label %$14
$15:
  %39 = inttoptr i64 %34 to i64*
  %40 = load i64, i64* %39
  br label %$11
$14:
  %41 = call i64 @evList(i64 %34)
  br label %$11
$11:
  %42 = phi i64 [%34, %$13], [%40, %$15], [%41, %$14] ; # ->
; # (? (ge0 (compare Y Z)) $Nil)
; # (compare Y Z)
  %43 = call i64 @compare(i64 %32, i64 %42)
; # (ge0 (compare Y Z))
  %44 = icmp sge i64 %43, 0
  br i1 %44, label %$17, label %$16
$17:
  %45 = phi i64 [%31, %$11] ; # X
  %46 = phi i64 [%32, %$11] ; # Y
  br label %$9
$16:
  %47 = phi i64 [%31, %$11] ; # X
  %48 = phi i64 [%32, %$11] ; # Y
; # (safe Z)
  %49 = inttoptr i64 %17 to i64*
  store i64 %42, i64* %49
  br label %$7
$9:
  %50 = phi i64 [%29, %$10], [%45, %$17] ; # X
  %51 = phi i64 [%30, %$10], [%46, %$17] ; # Y
  %52 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$17] ; # ->
; # (drop *Safe)
  %53 = inttoptr i64 %17 to i64*
  %54 = getelementptr i64, i64* %53, i32 1
  %55 = load i64, i64* %54
  %56 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %55, i64* %56
  ret i64 %52
}

define i64 @_Le(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (save (eval (car X)))) (loop (? (atom (shift ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (car X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (car X))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (save (eval (car X)))
  %14 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %15 = load i64, i64* %14
  %16 = alloca i64, i64 2, align 16
  %17 = ptrtoint i64* %16 to i64
  %18 = inttoptr i64 %17 to i64*
  store i64 %13, i64* %18
  %19 = add i64 %17, 8
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %17, i64* %21
; # (loop (? (atom (shift X)) $T) (let Z (eval (car X)) (? (gt0 (comp...
  br label %$7
$7:
  %22 = phi i64 [%3, %$2], [%47, %$16] ; # X
  %23 = phi i64 [%13, %$2], [%42, %$16] ; # Y
; # (? (atom (shift X)) $T)
; # (shift X)
  %24 = inttoptr i64 %22 to i64*
  %25 = getelementptr i64, i64* %24, i32 1
  %26 = load i64, i64* %25
; # (atom (shift X))
  %27 = and i64 %26, 15
  %28 = icmp ne i64 %27, 0
  br i1 %28, label %$10, label %$8
$10:
  %29 = phi i64 [%26, %$7] ; # X
  %30 = phi i64 [%23, %$7] ; # Y
  br label %$9
$8:
  %31 = phi i64 [%26, %$7] ; # X
  %32 = phi i64 [%23, %$7] ; # Y
; # (let Z (eval (car X)) (? (gt0 (compare Y Z)) $Nil) (setq Y (safe ...
; # (car X)
  %33 = inttoptr i64 %31 to i64*
  %34 = load i64, i64* %33
; # (eval (car X))
  %35 = and i64 %34, 6
  %36 = icmp ne i64 %35, 0
  br i1 %36, label %$13, label %$12
$13:
  br label %$11
$12:
  %37 = and i64 %34, 8
  %38 = icmp ne i64 %37, 0
  br i1 %38, label %$15, label %$14
$15:
  %39 = inttoptr i64 %34 to i64*
  %40 = load i64, i64* %39
  br label %$11
$14:
  %41 = call i64 @evList(i64 %34)
  br label %$11
$11:
  %42 = phi i64 [%34, %$13], [%40, %$15], [%41, %$14] ; # ->
; # (? (gt0 (compare Y Z)) $Nil)
; # (compare Y Z)
  %43 = call i64 @compare(i64 %32, i64 %42)
; # (gt0 (compare Y Z))
  %44 = icmp sgt i64 %43, 0
  br i1 %44, label %$17, label %$16
$17:
  %45 = phi i64 [%31, %$11] ; # X
  %46 = phi i64 [%32, %$11] ; # Y
  br label %$9
$16:
  %47 = phi i64 [%31, %$11] ; # X
  %48 = phi i64 [%32, %$11] ; # Y
; # (safe Z)
  %49 = inttoptr i64 %17 to i64*
  store i64 %42, i64* %49
  br label %$7
$9:
  %50 = phi i64 [%29, %$10], [%45, %$17] ; # X
  %51 = phi i64 [%30, %$10], [%46, %$17] ; # Y
  %52 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$17] ; # ->
; # (drop *Safe)
  %53 = inttoptr i64 %17 to i64*
  %54 = getelementptr i64, i64* %53, i32 1
  %55 = load i64, i64* %54
  %56 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %55, i64* %56
  ret i64 %52
}

define i64 @_Gt(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (save (eval (car X)))) (loop (? (atom (shift ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (car X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (car X))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (save (eval (car X)))
  %14 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %15 = load i64, i64* %14
  %16 = alloca i64, i64 2, align 16
  %17 = ptrtoint i64* %16 to i64
  %18 = inttoptr i64 %17 to i64*
  store i64 %13, i64* %18
  %19 = add i64 %17, 8
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %17, i64* %21
; # (loop (? (atom (shift X)) $T) (let Z (eval (car X)) (? (le0 (comp...
  br label %$7
$7:
  %22 = phi i64 [%3, %$2], [%47, %$16] ; # X
  %23 = phi i64 [%13, %$2], [%42, %$16] ; # Y
; # (? (atom (shift X)) $T)
; # (shift X)
  %24 = inttoptr i64 %22 to i64*
  %25 = getelementptr i64, i64* %24, i32 1
  %26 = load i64, i64* %25
; # (atom (shift X))
  %27 = and i64 %26, 15
  %28 = icmp ne i64 %27, 0
  br i1 %28, label %$10, label %$8
$10:
  %29 = phi i64 [%26, %$7] ; # X
  %30 = phi i64 [%23, %$7] ; # Y
  br label %$9
$8:
  %31 = phi i64 [%26, %$7] ; # X
  %32 = phi i64 [%23, %$7] ; # Y
; # (let Z (eval (car X)) (? (le0 (compare Y Z)) $Nil) (setq Y (safe ...
; # (car X)
  %33 = inttoptr i64 %31 to i64*
  %34 = load i64, i64* %33
; # (eval (car X))
  %35 = and i64 %34, 6
  %36 = icmp ne i64 %35, 0
  br i1 %36, label %$13, label %$12
$13:
  br label %$11
$12:
  %37 = and i64 %34, 8
  %38 = icmp ne i64 %37, 0
  br i1 %38, label %$15, label %$14
$15:
  %39 = inttoptr i64 %34 to i64*
  %40 = load i64, i64* %39
  br label %$11
$14:
  %41 = call i64 @evList(i64 %34)
  br label %$11
$11:
  %42 = phi i64 [%34, %$13], [%40, %$15], [%41, %$14] ; # ->
; # (? (le0 (compare Y Z)) $Nil)
; # (compare Y Z)
  %43 = call i64 @compare(i64 %32, i64 %42)
; # (le0 (compare Y Z))
  %44 = icmp sle i64 %43, 0
  br i1 %44, label %$17, label %$16
$17:
  %45 = phi i64 [%31, %$11] ; # X
  %46 = phi i64 [%32, %$11] ; # Y
  br label %$9
$16:
  %47 = phi i64 [%31, %$11] ; # X
  %48 = phi i64 [%32, %$11] ; # Y
; # (safe Z)
  %49 = inttoptr i64 %17 to i64*
  store i64 %42, i64* %49
  br label %$7
$9:
  %50 = phi i64 [%29, %$10], [%45, %$17] ; # X
  %51 = phi i64 [%30, %$10], [%46, %$17] ; # Y
  %52 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$17] ; # ->
; # (drop *Safe)
  %53 = inttoptr i64 %17 to i64*
  %54 = getelementptr i64, i64* %53, i32 1
  %55 = load i64, i64* %54
  %56 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %55, i64* %56
  ret i64 %52
}

define i64 @_Ge(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (save (eval (car X)))) (loop (? (atom (shift ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (car X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (car X))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (save (eval (car X)))
  %14 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %15 = load i64, i64* %14
  %16 = alloca i64, i64 2, align 16
  %17 = ptrtoint i64* %16 to i64
  %18 = inttoptr i64 %17 to i64*
  store i64 %13, i64* %18
  %19 = add i64 %17, 8
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %17, i64* %21
; # (loop (? (atom (shift X)) $T) (let Z (eval (car X)) (? (lt0 (comp...
  br label %$7
$7:
  %22 = phi i64 [%3, %$2], [%47, %$16] ; # X
  %23 = phi i64 [%13, %$2], [%42, %$16] ; # Y
; # (? (atom (shift X)) $T)
; # (shift X)
  %24 = inttoptr i64 %22 to i64*
  %25 = getelementptr i64, i64* %24, i32 1
  %26 = load i64, i64* %25
; # (atom (shift X))
  %27 = and i64 %26, 15
  %28 = icmp ne i64 %27, 0
  br i1 %28, label %$10, label %$8
$10:
  %29 = phi i64 [%26, %$7] ; # X
  %30 = phi i64 [%23, %$7] ; # Y
  br label %$9
$8:
  %31 = phi i64 [%26, %$7] ; # X
  %32 = phi i64 [%23, %$7] ; # Y
; # (let Z (eval (car X)) (? (lt0 (compare Y Z)) $Nil) (setq Y (safe ...
; # (car X)
  %33 = inttoptr i64 %31 to i64*
  %34 = load i64, i64* %33
; # (eval (car X))
  %35 = and i64 %34, 6
  %36 = icmp ne i64 %35, 0
  br i1 %36, label %$13, label %$12
$13:
  br label %$11
$12:
  %37 = and i64 %34, 8
  %38 = icmp ne i64 %37, 0
  br i1 %38, label %$15, label %$14
$15:
  %39 = inttoptr i64 %34 to i64*
  %40 = load i64, i64* %39
  br label %$11
$14:
  %41 = call i64 @evList(i64 %34)
  br label %$11
$11:
  %42 = phi i64 [%34, %$13], [%40, %$15], [%41, %$14] ; # ->
; # (? (lt0 (compare Y Z)) $Nil)
; # (compare Y Z)
  %43 = call i64 @compare(i64 %32, i64 %42)
; # (lt0 (compare Y Z))
  %44 = icmp slt i64 %43, 0
  br i1 %44, label %$17, label %$16
$17:
  %45 = phi i64 [%31, %$11] ; # X
  %46 = phi i64 [%32, %$11] ; # Y
  br label %$9
$16:
  %47 = phi i64 [%31, %$11] ; # X
  %48 = phi i64 [%32, %$11] ; # Y
; # (safe Z)
  %49 = inttoptr i64 %17 to i64*
  store i64 %42, i64* %49
  br label %$7
$9:
  %50 = phi i64 [%29, %$10], [%45, %$17] ; # X
  %51 = phi i64 [%30, %$10], [%46, %$17] ; # Y
  %52 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$17] ; # ->
; # (drop *Safe)
  %53 = inttoptr i64 %17 to i64*
  %54 = getelementptr i64, i64* %53, i32 1
  %55 = load i64, i64* %54
  %56 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %55, i64* %56
  ret i64 %52
}

define i64 @_Max(i64) align 8 {
$1:
; # (let (X (cdr Exe) R (save (eval (car X)))) (while (pair (shift X)...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (car X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (car X))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (save (eval (car X)))
  %14 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %15 = load i64, i64* %14
  %16 = alloca i64, i64 2, align 16
  %17 = ptrtoint i64* %16 to i64
  %18 = inttoptr i64 %17 to i64*
  store i64 %13, i64* %18
  %19 = add i64 %17, 8
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %17, i64* %21
; # (while (pair (shift X)) (let Z (eval (car X)) (when (gt0 (compare...
  br label %$7
$7:
  %22 = phi i64 [%3, %$2], [%46, %$16] ; # X
  %23 = phi i64 [%13, %$2], [%47, %$16] ; # R
; # (shift X)
  %24 = inttoptr i64 %22 to i64*
  %25 = getelementptr i64, i64* %24, i32 1
  %26 = load i64, i64* %25
; # (pair (shift X))
  %27 = and i64 %26, 15
  %28 = icmp eq i64 %27, 0
  br i1 %28, label %$8, label %$9
$8:
  %29 = phi i64 [%26, %$7] ; # X
  %30 = phi i64 [%23, %$7] ; # R
; # (let Z (eval (car X)) (when (gt0 (compare Z R)) (setq R (safe Z))...
; # (car X)
  %31 = inttoptr i64 %29 to i64*
  %32 = load i64, i64* %31
; # (eval (car X))
  %33 = and i64 %32, 6
  %34 = icmp ne i64 %33, 0
  br i1 %34, label %$12, label %$11
$12:
  br label %$10
$11:
  %35 = and i64 %32, 8
  %36 = icmp ne i64 %35, 0
  br i1 %36, label %$14, label %$13
$14:
  %37 = inttoptr i64 %32 to i64*
  %38 = load i64, i64* %37
  br label %$10
$13:
  %39 = call i64 @evList(i64 %32)
  br label %$10
$10:
  %40 = phi i64 [%32, %$12], [%38, %$14], [%39, %$13] ; # ->
; # (when (gt0 (compare Z R)) (setq R (safe Z)))
; # (compare Z R)
  %41 = call i64 @compare(i64 %40, i64 %30)
; # (gt0 (compare Z R))
  %42 = icmp sgt i64 %41, 0
  br i1 %42, label %$15, label %$16
$15:
  %43 = phi i64 [%29, %$10] ; # X
  %44 = phi i64 [%30, %$10] ; # R
; # (safe Z)
  %45 = inttoptr i64 %17 to i64*
  store i64 %40, i64* %45
  br label %$16
$16:
  %46 = phi i64 [%29, %$10], [%43, %$15] ; # X
  %47 = phi i64 [%30, %$10], [%40, %$15] ; # R
  br label %$7
$9:
  %48 = phi i64 [%26, %$7] ; # X
  %49 = phi i64 [%23, %$7] ; # R
; # (drop *Safe)
  %50 = inttoptr i64 %17 to i64*
  %51 = getelementptr i64, i64* %50, i32 1
  %52 = load i64, i64* %51
  %53 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %52, i64* %53
  ret i64 %49
}

define i64 @_Min(i64) align 8 {
$1:
; # (let (X (cdr Exe) R (save (eval (car X)))) (while (pair (shift X)...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (car X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (car X))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (save (eval (car X)))
  %14 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %15 = load i64, i64* %14
  %16 = alloca i64, i64 2, align 16
  %17 = ptrtoint i64* %16 to i64
  %18 = inttoptr i64 %17 to i64*
  store i64 %13, i64* %18
  %19 = add i64 %17, 8
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %17, i64* %21
; # (while (pair (shift X)) (let Z (eval (car X)) (when (lt0 (compare...
  br label %$7
$7:
  %22 = phi i64 [%3, %$2], [%46, %$16] ; # X
  %23 = phi i64 [%13, %$2], [%47, %$16] ; # R
; # (shift X)
  %24 = inttoptr i64 %22 to i64*
  %25 = getelementptr i64, i64* %24, i32 1
  %26 = load i64, i64* %25
; # (pair (shift X))
  %27 = and i64 %26, 15
  %28 = icmp eq i64 %27, 0
  br i1 %28, label %$8, label %$9
$8:
  %29 = phi i64 [%26, %$7] ; # X
  %30 = phi i64 [%23, %$7] ; # R
; # (let Z (eval (car X)) (when (lt0 (compare Z R)) (setq R (safe Z))...
; # (car X)
  %31 = inttoptr i64 %29 to i64*
  %32 = load i64, i64* %31
; # (eval (car X))
  %33 = and i64 %32, 6
  %34 = icmp ne i64 %33, 0
  br i1 %34, label %$12, label %$11
$12:
  br label %$10
$11:
  %35 = and i64 %32, 8
  %36 = icmp ne i64 %35, 0
  br i1 %36, label %$14, label %$13
$14:
  %37 = inttoptr i64 %32 to i64*
  %38 = load i64, i64* %37
  br label %$10
$13:
  %39 = call i64 @evList(i64 %32)
  br label %$10
$10:
  %40 = phi i64 [%32, %$12], [%38, %$14], [%39, %$13] ; # ->
; # (when (lt0 (compare Z R)) (setq R (safe Z)))
; # (compare Z R)
  %41 = call i64 @compare(i64 %40, i64 %30)
; # (lt0 (compare Z R))
  %42 = icmp slt i64 %41, 0
  br i1 %42, label %$15, label %$16
$15:
  %43 = phi i64 [%29, %$10] ; # X
  %44 = phi i64 [%30, %$10] ; # R
; # (safe Z)
  %45 = inttoptr i64 %17 to i64*
  store i64 %40, i64* %45
  br label %$16
$16:
  %46 = phi i64 [%29, %$10], [%43, %$15] ; # X
  %47 = phi i64 [%30, %$10], [%40, %$15] ; # R
  br label %$7
$9:
  %48 = phi i64 [%26, %$7] ; # X
  %49 = phi i64 [%23, %$7] ; # R
; # (drop *Safe)
  %50 = inttoptr i64 %17 to i64*
  %51 = getelementptr i64, i64* %50, i32 1
  %52 = load i64, i64* %51
  %53 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %52, i64* %53
  ret i64 %49
}

define i64 @_Atom(i64) align 8 {
$1:
; # (if (atom (eval (cadr Exe))) $T $Nil)
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (atom (eval (cadr Exe)))
  %14 = and i64 %13, 15
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$7, label %$8
$7:
  br label %$9
$8:
  br label %$9
$9:
  %16 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # ->
  ret i64 %16
}

define i64 @_Pair(i64) align 8 {
$1:
; # (if (pair (eval (cadr Exe))) @ $Nil)
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (pair (eval (cadr Exe)))
  %14 = and i64 %13, 15
  %15 = icmp eq i64 %14, 0
  br i1 %15, label %$7, label %$8
$7:
  br label %$9
$8:
  br label %$9
$9:
  %16 = phi i64 [%13, %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # ->
  ret i64 %16
}

define i64 @_CircQ(i64) align 8 {
$1:
; # (if (circ (eval (cadr Exe))) @ $Nil)
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (circ (eval (cadr Exe)))
  %14 = call i64 @circ(i64 %13)
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$7, label %$8
$7:
  br label %$9
$8:
  br label %$9
$9:
  %16 = phi i64 [%14, %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # ->
  ret i64 %16
}

define i64 @_LstQ(i64) align 8 {
$1:
; # (if (or (pair (eval (cadr Exe))) (nil? @)) $T $Nil)
; # (or (pair (eval (cadr Exe))) (nil? @))
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$5, label %$4
$5:
  br label %$3
$4:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$7, label %$6
$7:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$3
$6:
  %12 = call i64 @evList(i64 %5)
  br label %$3
$3:
  %13 = phi i64 [%5, %$5], [%11, %$7], [%12, %$6] ; # ->
; # (pair (eval (cadr Exe)))
  %14 = and i64 %13, 15
  %15 = icmp eq i64 %14, 0
  br i1 %15, label %$2, label %$8
$8:
; # (nil? @)
  %16 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$2
$2:
  %17 = phi i1 [1, %$3], [%16, %$8] ; # ->
  br i1 %17, label %$9, label %$10
$9:
  br label %$11
$10:
  br label %$11
$11:
  %18 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$9], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$10] ; # ->
  ret i64 %18
}

define i64 @_NumQ(i64) align 8 {
$1:
; # (if (num? (eval (cadr Exe))) @ $Nil)
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (num? (eval (cadr Exe)))
  %14 = and i64 %13, 6
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$7, label %$8
$7:
  br label %$9
$8:
  br label %$9
$9:
  %16 = phi i64 [%13, %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # ->
  ret i64 %16
}

define i64 @_SymQ(i64) align 8 {
$1:
; # (if (symb? (eval (cadr Exe))) $T $Nil)
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (symb? (eval (cadr Exe)))
  %14 = xor i64 %13, 8
  %15 = and i64 %14, 14
  %16 = icmp eq i64 %15, 0
  br i1 %16, label %$7, label %$8
$7:
  br label %$9
$8:
  br label %$9
$9:
  %17 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # ->
  ret i64 %17
}

define i64 @_FlgQ(i64) align 8 {
$1:
; # (if (or (t? (eval (cadr Exe))) (nil? @)) $T $Nil)
; # (or (t? (eval (cadr Exe))) (nil? @))
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$5, label %$4
$5:
  br label %$3
$4:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$7, label %$6
$7:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$3
$6:
  %12 = call i64 @evList(i64 %5)
  br label %$3
$3:
  %13 = phi i64 [%5, %$5], [%11, %$7], [%12, %$6] ; # ->
; # (t? (eval (cadr Exe)))
  %14 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %14, label %$2, label %$8
$8:
; # (nil? @)
  %15 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$2
$2:
  %16 = phi i1 [1, %$3], [%15, %$8] ; # ->
  br i1 %16, label %$9, label %$10
$9:
  br label %$11
$10:
  br label %$11
$11:
  %17 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$9], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$10] ; # ->
  ret i64 %17
}

define i64 @_Member(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (save (eval (++ X))) Z (eval (car X)) H Z) (l...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (save (eval (++ X)))
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %17 = load i64, i64* %16
  %18 = alloca i64, i64 2, align 16
  %19 = ptrtoint i64* %18 to i64
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = add i64 %19, 8
  %22 = inttoptr i64 %21 to i64*
  store i64 %17, i64* %22
  %23 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %19, i64* %23
; # (car X)
  %24 = inttoptr i64 %7 to i64*
  %25 = load i64, i64* %24
; # (eval (car X))
  %26 = and i64 %25, 6
  %27 = icmp ne i64 %26, 0
  br i1 %27, label %$9, label %$8
$9:
  br label %$7
$8:
  %28 = and i64 %25, 8
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %$11, label %$10
$11:
  %30 = inttoptr i64 %25 to i64*
  %31 = load i64, i64* %30
  br label %$7
$10:
  %32 = call i64 @evList(i64 %25)
  br label %$7
$7:
  %33 = phi i64 [%25, %$9], [%31, %$11], [%32, %$10] ; # ->
; # (loop (? (atom Z) (if (equal Y Z) Z $Nil)) (? (equal Y (car Z)) Z...
  br label %$12
$12:
  %34 = phi i64 [%33, %$7], [%54, %$21] ; # Z
; # (? (atom Z) (if (equal Y Z) Z $Nil))
; # (atom Z)
  %35 = and i64 %34, 15
  %36 = icmp ne i64 %35, 0
  br i1 %36, label %$15, label %$13
$15:
  %37 = phi i64 [%34, %$12] ; # Z
; # (if (equal Y Z) Z $Nil)
; # (equal Y Z)
  %38 = call i1 @equal(i64 %15, i64 %37)
  br i1 %38, label %$16, label %$17
$16:
  %39 = phi i64 [%37, %$15] ; # Z
  br label %$18
$17:
  %40 = phi i64 [%37, %$15] ; # Z
  br label %$18
$18:
  %41 = phi i64 [%39, %$16], [%40, %$17] ; # Z
  %42 = phi i64 [%39, %$16], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$17] ; # ->
  br label %$14
$13:
  %43 = phi i64 [%34, %$12] ; # Z
; # (? (equal Y (car Z)) Z)
; # (car Z)
  %44 = inttoptr i64 %43 to i64*
  %45 = load i64, i64* %44
; # (equal Y (car Z))
  %46 = call i1 @equal(i64 %15, i64 %45)
  br i1 %46, label %$20, label %$19
$20:
  %47 = phi i64 [%43, %$13] ; # Z
  br label %$14
$19:
  %48 = phi i64 [%43, %$13] ; # Z
; # (? (== H (shift Z)) $Nil)
; # (shift Z)
  %49 = inttoptr i64 %48 to i64*
  %50 = getelementptr i64, i64* %49, i32 1
  %51 = load i64, i64* %50
; # (== H (shift Z))
  %52 = icmp eq i64 %33, %51
  br i1 %52, label %$22, label %$21
$22:
  %53 = phi i64 [%51, %$19] ; # Z
  br label %$14
$21:
  %54 = phi i64 [%51, %$19] ; # Z
  br label %$12
$14:
  %55 = phi i64 [%41, %$18], [%47, %$20], [%53, %$22] ; # Z
  %56 = phi i64 [%42, %$18], [%47, %$20], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$22] ; # ->
; # (drop *Safe)
  %57 = inttoptr i64 %19 to i64*
  %58 = getelementptr i64, i64* %57, i32 1
  %59 = load i64, i64* %58
  %60 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %59, i64* %60
  ret i64 %56
}

define i64 @_Memq(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (save (eval (++ X))) Z (eval (car X)) H Z) (l...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (save (eval (++ X)))
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %17 = load i64, i64* %16
  %18 = alloca i64, i64 2, align 16
  %19 = ptrtoint i64* %18 to i64
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = add i64 %19, 8
  %22 = inttoptr i64 %21 to i64*
  store i64 %17, i64* %22
  %23 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %19, i64* %23
; # (car X)
  %24 = inttoptr i64 %7 to i64*
  %25 = load i64, i64* %24
; # (eval (car X))
  %26 = and i64 %25, 6
  %27 = icmp ne i64 %26, 0
  br i1 %27, label %$9, label %$8
$9:
  br label %$7
$8:
  %28 = and i64 %25, 8
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %$11, label %$10
$11:
  %30 = inttoptr i64 %25 to i64*
  %31 = load i64, i64* %30
  br label %$7
$10:
  %32 = call i64 @evList(i64 %25)
  br label %$7
$7:
  %33 = phi i64 [%25, %$9], [%31, %$11], [%32, %$10] ; # ->
; # (loop (? (atom Z) (if (== Y Z) Z $Nil)) (? (== Y (car Z)) Z) (? (...
  br label %$12
$12:
  %34 = phi i64 [%33, %$7], [%54, %$21] ; # Z
; # (? (atom Z) (if (== Y Z) Z $Nil))
; # (atom Z)
  %35 = and i64 %34, 15
  %36 = icmp ne i64 %35, 0
  br i1 %36, label %$15, label %$13
$15:
  %37 = phi i64 [%34, %$12] ; # Z
; # (if (== Y Z) Z $Nil)
; # (== Y Z)
  %38 = icmp eq i64 %15, %37
  br i1 %38, label %$16, label %$17
$16:
  %39 = phi i64 [%37, %$15] ; # Z
  br label %$18
$17:
  %40 = phi i64 [%37, %$15] ; # Z
  br label %$18
$18:
  %41 = phi i64 [%39, %$16], [%40, %$17] ; # Z
  %42 = phi i64 [%39, %$16], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$17] ; # ->
  br label %$14
$13:
  %43 = phi i64 [%34, %$12] ; # Z
; # (? (== Y (car Z)) Z)
; # (car Z)
  %44 = inttoptr i64 %43 to i64*
  %45 = load i64, i64* %44
; # (== Y (car Z))
  %46 = icmp eq i64 %15, %45
  br i1 %46, label %$20, label %$19
$20:
  %47 = phi i64 [%43, %$13] ; # Z
  br label %$14
$19:
  %48 = phi i64 [%43, %$13] ; # Z
; # (? (== H (shift Z)) $Nil)
; # (shift Z)
  %49 = inttoptr i64 %48 to i64*
  %50 = getelementptr i64, i64* %49, i32 1
  %51 = load i64, i64* %50
; # (== H (shift Z))
  %52 = icmp eq i64 %33, %51
  br i1 %52, label %$22, label %$21
$22:
  %53 = phi i64 [%51, %$19] ; # Z
  br label %$14
$21:
  %54 = phi i64 [%51, %$19] ; # Z
  br label %$12
$14:
  %55 = phi i64 [%41, %$18], [%47, %$20], [%53, %$22] ; # Z
  %56 = phi i64 [%42, %$18], [%47, %$20], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$22] ; # ->
; # (drop *Safe)
  %57 = inttoptr i64 %19 to i64*
  %58 = getelementptr i64, i64* %57, i32 1
  %59 = load i64, i64* %58
  %60 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %59, i64* %60
  ret i64 %56
}

define i64 @_Mmeq(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (save (eval (++ X))) Z (eval (car X))) (while...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (save (eval (++ X)))
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %17 = load i64, i64* %16
  %18 = alloca i64, i64 2, align 16
  %19 = ptrtoint i64* %18 to i64
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = add i64 %19, 8
  %22 = inttoptr i64 %21 to i64*
  store i64 %17, i64* %22
  %23 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %19, i64* %23
; # (car X)
  %24 = inttoptr i64 %7 to i64*
  %25 = load i64, i64* %24
; # (eval (car X))
  %26 = and i64 %25, 6
  %27 = icmp ne i64 %26, 0
  br i1 %27, label %$9, label %$8
$9:
  br label %$7
$8:
  %28 = and i64 %25, 8
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %$11, label %$10
$11:
  %30 = inttoptr i64 %25 to i64*
  %31 = load i64, i64* %30
  br label %$7
$10:
  %32 = call i64 @evList(i64 %25)
  br label %$7
$7:
  %33 = phi i64 [%25, %$9], [%31, %$11], [%32, %$10] ; # ->
; # (while (pair Y) (let (U (++ Y) V Z) (while (pair V) (when (== U (...
  br label %$12
$12:
  %34 = phi i64 [%15, %$7], [%76, %$22] ; # Y
; # (pair Y)
  %35 = and i64 %34, 15
  %36 = icmp eq i64 %35, 0
  br i1 %36, label %$13, label %$14
$13:
  %37 = phi i64 [%34, %$12] ; # Y
; # (let (U (++ Y) V Z) (while (pair V) (when (== U (car V)) (ret V))...
; # (++ Y)
  %38 = inttoptr i64 %37 to i64*
  %39 = load i64, i64* %38
  %40 = getelementptr i64, i64* %38, i32 1
  %41 = load i64, i64* %40
; # (while (pair V) (when (== U (car V)) (ret V)) (when (== Z (shift ...
  br label %$15
$15:
  %42 = phi i64 [%41, %$13], [%69, %$21] ; # Y
  %43 = phi i64 [%33, %$13], [%70, %$21] ; # V
; # (pair V)
  %44 = and i64 %43, 15
  %45 = icmp eq i64 %44, 0
  br i1 %45, label %$16, label %$17
$16:
  %46 = phi i64 [%42, %$15] ; # Y
  %47 = phi i64 [%43, %$15] ; # V
; # (when (== U (car V)) (ret V))
; # (car V)
  %48 = inttoptr i64 %47 to i64*
  %49 = load i64, i64* %48
; # (== U (car V))
  %50 = icmp eq i64 %39, %49
  br i1 %50, label %$18, label %$19
$18:
  %51 = phi i64 [%46, %$16] ; # Y
  %52 = phi i64 [%47, %$16] ; # V
; # (ret V)
; # (drop *Safe)
  %53 = inttoptr i64 %19 to i64*
  %54 = getelementptr i64, i64* %53, i32 1
  %55 = load i64, i64* %54
  %56 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %55, i64* %56
  ret i64 %52
$19:
  %57 = phi i64 [%46, %$16] ; # Y
  %58 = phi i64 [%47, %$16] ; # V
; # (when (== Z (shift V)) (ret $Nil))
; # (shift V)
  %59 = inttoptr i64 %58 to i64*
  %60 = getelementptr i64, i64* %59, i32 1
  %61 = load i64, i64* %60
; # (== Z (shift V))
  %62 = icmp eq i64 %33, %61
  br i1 %62, label %$20, label %$21
$20:
  %63 = phi i64 [%57, %$19] ; # Y
  %64 = phi i64 [%61, %$19] ; # V
; # (ret $Nil)
; # (drop *Safe)
  %65 = inttoptr i64 %19 to i64*
  %66 = getelementptr i64, i64* %65, i32 1
  %67 = load i64, i64* %66
  %68 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %67, i64* %68
  ret i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
$21:
  %69 = phi i64 [%57, %$19] ; # Y
  %70 = phi i64 [%61, %$19] ; # V
  br label %$15
$17:
  %71 = phi i64 [%42, %$15] ; # Y
  %72 = phi i64 [%43, %$15] ; # V
; # (? (== U V) V)
; # (== U V)
  %73 = icmp eq i64 %39, %72
  br i1 %73, label %$23, label %$22
$23:
  %74 = phi i64 [%71, %$17] ; # Y
  %75 = phi i64 [%72, %$17] ; # V
  br label %$14
$22:
  %76 = phi i64 [%71, %$17] ; # Y
  %77 = phi i64 [%72, %$17] ; # V
  br label %$12
$14:
  %78 = phi i64 [%34, %$12], [%74, %$23] ; # Y
; # (drop *Safe)
  %79 = inttoptr i64 %19 to i64*
  %80 = getelementptr i64, i64* %79, i32 1
  %81 = load i64, i64* %80
  %82 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %81, i64* %82
  ret i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
}

define i64 @_Sect(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (save (eval (++ X))) Z (save (eval (car X))) ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (save (eval (++ X)))
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %17 = load i64, i64* %16
  %18 = alloca i64, i64 2, align 16
  %19 = ptrtoint i64* %18 to i64
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = add i64 %19, 8
  %22 = inttoptr i64 %21 to i64*
  store i64 %17, i64* %22
  %23 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %19, i64* %23
; # (car X)
  %24 = inttoptr i64 %7 to i64*
  %25 = load i64, i64* %24
; # (eval (car X))
  %26 = and i64 %25, 6
  %27 = icmp ne i64 %26, 0
  br i1 %27, label %$9, label %$8
$9:
  br label %$7
$8:
  %28 = and i64 %25, 8
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %$11, label %$10
$11:
  %30 = inttoptr i64 %25 to i64*
  %31 = load i64, i64* %30
  br label %$7
$10:
  %32 = call i64 @evList(i64 %25)
  br label %$7
$7:
  %33 = phi i64 [%25, %$9], [%31, %$11], [%32, %$10] ; # ->
; # (save (eval (car X)))
  %34 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %35 = load i64, i64* %34
  %36 = alloca i64, i64 2, align 16
  %37 = ptrtoint i64* %36 to i64
  %38 = inttoptr i64 %37 to i64*
  store i64 %33, i64* %38
  %39 = add i64 %37, 8
  %40 = inttoptr i64 %39 to i64*
  store i64 %35, i64* %40
  %41 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %37, i64* %41
; # (push $Nil NIL)
  %42 = alloca i64, i64 2, align 16
  %43 = ptrtoint i64* %42 to i64
  %44 = inttoptr i64 %43 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %44
; # (link (push $Nil NIL))
  %45 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %46 = load i64, i64* %45
  %47 = inttoptr i64 %43 to i64*
  %48 = getelementptr i64, i64* %47, i32 1
  store i64 %46, i64* %48
  %49 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %43, i64* %49
; # (while (pair Y) (let U (++ Y) (when (member U Z) (let V (cons U $...
  br label %$12
$12:
  %50 = phi i64 [%15, %$7], [%89, %$22] ; # Y
  %51 = phi i64 [0, %$7], [%90, %$22] ; # P
; # (pair Y)
  %52 = and i64 %50, 15
  %53 = icmp eq i64 %52, 0
  br i1 %53, label %$13, label %$14
$13:
  %54 = phi i64 [%50, %$12] ; # Y
  %55 = phi i64 [%51, %$12] ; # P
; # (let U (++ Y) (when (member U Z) (let V (cons U $Nil) (setq P (if...
; # (++ Y)
  %56 = inttoptr i64 %54 to i64*
  %57 = load i64, i64* %56
  %58 = getelementptr i64, i64* %56, i32 1
  %59 = load i64, i64* %58
; # (when (member U Z) (let V (cons U $Nil) (setq P (if P (set 2 P V)...
; # (member U Z)
  br label %$15
$15:
  %60 = phi i64 [%33, %$13], [%72, %$19] ; # L
  %61 = and i64 %60, 15
  %62 = icmp ne i64 %61, 0
  br i1 %62, label %$18, label %$16
$18:
  %63 = phi i64 [%60, %$15] ; # L
  br label %$17
$16:
  %64 = phi i64 [%60, %$15] ; # L
  %65 = inttoptr i64 %64 to i64*
  %66 = load i64, i64* %65
  %67 = call i1 @equal(i64 %57, i64 %66)
  br i1 %67, label %$20, label %$19
$20:
  %68 = phi i64 [%64, %$16] ; # L
  br label %$17
$19:
  %69 = phi i64 [%64, %$16] ; # L
  %70 = inttoptr i64 %69 to i64*
  %71 = getelementptr i64, i64* %70, i32 1
  %72 = load i64, i64* %71
  br label %$15
$17:
  %73 = phi i64 [%63, %$18], [%68, %$20] ; # L
  %74 = phi i1 [0, %$18], [1, %$20] ; # ->
  br i1 %74, label %$21, label %$22
$21:
  %75 = phi i64 [%59, %$17] ; # Y
  %76 = phi i64 [%55, %$17] ; # P
; # (let V (cons U $Nil) (setq P (if P (set 2 P V) (set R V))))
; # (cons U $Nil)
  %77 = call i64 @cons(i64 %57, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (if P (set 2 P V) (set R V))
  %78 = icmp ne i64 %76, 0
  br i1 %78, label %$23, label %$24
$23:
  %79 = phi i64 [%75, %$21] ; # Y
  %80 = phi i64 [%76, %$21] ; # P
; # (set 2 P V)
  %81 = inttoptr i64 %80 to i64*
  %82 = getelementptr i64, i64* %81, i32 1
  store i64 %77, i64* %82
  br label %$25
$24:
  %83 = phi i64 [%75, %$21] ; # Y
  %84 = phi i64 [%76, %$21] ; # P
; # (set R V)
  %85 = inttoptr i64 %43 to i64*
  store i64 %77, i64* %85
  br label %$25
$25:
  %86 = phi i64 [%79, %$23], [%83, %$24] ; # Y
  %87 = phi i64 [%80, %$23], [%84, %$24] ; # P
  %88 = phi i64 [%77, %$23], [%77, %$24] ; # ->
  br label %$22
$22:
  %89 = phi i64 [%59, %$17], [%86, %$25] ; # Y
  %90 = phi i64 [%55, %$17], [%88, %$25] ; # P
  br label %$12
$14:
  %91 = phi i64 [%50, %$12] ; # Y
  %92 = phi i64 [%51, %$12] ; # P
; # (val R)
  %93 = inttoptr i64 %43 to i64*
  %94 = load i64, i64* %93
; # (drop *Safe)
  %95 = inttoptr i64 %19 to i64*
  %96 = getelementptr i64, i64* %95, i32 1
  %97 = load i64, i64* %96
  %98 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %97, i64* %98
  ret i64 %94
}

define i64 @_Diff(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (save (eval (++ X))) Z (save (eval (car X))) ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (save (eval (++ X)))
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %17 = load i64, i64* %16
  %18 = alloca i64, i64 2, align 16
  %19 = ptrtoint i64* %18 to i64
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = add i64 %19, 8
  %22 = inttoptr i64 %21 to i64*
  store i64 %17, i64* %22
  %23 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %19, i64* %23
; # (car X)
  %24 = inttoptr i64 %7 to i64*
  %25 = load i64, i64* %24
; # (eval (car X))
  %26 = and i64 %25, 6
  %27 = icmp ne i64 %26, 0
  br i1 %27, label %$9, label %$8
$9:
  br label %$7
$8:
  %28 = and i64 %25, 8
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %$11, label %$10
$11:
  %30 = inttoptr i64 %25 to i64*
  %31 = load i64, i64* %30
  br label %$7
$10:
  %32 = call i64 @evList(i64 %25)
  br label %$7
$7:
  %33 = phi i64 [%25, %$9], [%31, %$11], [%32, %$10] ; # ->
; # (save (eval (car X)))
  %34 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %35 = load i64, i64* %34
  %36 = alloca i64, i64 2, align 16
  %37 = ptrtoint i64* %36 to i64
  %38 = inttoptr i64 %37 to i64*
  store i64 %33, i64* %38
  %39 = add i64 %37, 8
  %40 = inttoptr i64 %39 to i64*
  store i64 %35, i64* %40
  %41 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %37, i64* %41
; # (push $Nil NIL)
  %42 = alloca i64, i64 2, align 16
  %43 = ptrtoint i64* %42 to i64
  %44 = inttoptr i64 %43 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %44
; # (link (push $Nil NIL))
  %45 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %46 = load i64, i64* %45
  %47 = inttoptr i64 %43 to i64*
  %48 = getelementptr i64, i64* %47, i32 1
  store i64 %46, i64* %48
  %49 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %43, i64* %49
; # (while (pair Y) (let U (++ Y) (unless (member U Z) (let V (cons U...
  br label %$12
$12:
  %50 = phi i64 [%15, %$7], [%89, %$22] ; # Y
  %51 = phi i64 [0, %$7], [%90, %$22] ; # P
; # (pair Y)
  %52 = and i64 %50, 15
  %53 = icmp eq i64 %52, 0
  br i1 %53, label %$13, label %$14
$13:
  %54 = phi i64 [%50, %$12] ; # Y
  %55 = phi i64 [%51, %$12] ; # P
; # (let U (++ Y) (unless (member U Z) (let V (cons U $Nil) (setq P (...
; # (++ Y)
  %56 = inttoptr i64 %54 to i64*
  %57 = load i64, i64* %56
  %58 = getelementptr i64, i64* %56, i32 1
  %59 = load i64, i64* %58
; # (unless (member U Z) (let V (cons U $Nil) (setq P (if P (set 2 P ...
; # (member U Z)
  br label %$15
$15:
  %60 = phi i64 [%33, %$13], [%72, %$19] ; # L
  %61 = and i64 %60, 15
  %62 = icmp ne i64 %61, 0
  br i1 %62, label %$18, label %$16
$18:
  %63 = phi i64 [%60, %$15] ; # L
  br label %$17
$16:
  %64 = phi i64 [%60, %$15] ; # L
  %65 = inttoptr i64 %64 to i64*
  %66 = load i64, i64* %65
  %67 = call i1 @equal(i64 %57, i64 %66)
  br i1 %67, label %$20, label %$19
$20:
  %68 = phi i64 [%64, %$16] ; # L
  br label %$17
$19:
  %69 = phi i64 [%64, %$16] ; # L
  %70 = inttoptr i64 %69 to i64*
  %71 = getelementptr i64, i64* %70, i32 1
  %72 = load i64, i64* %71
  br label %$15
$17:
  %73 = phi i64 [%63, %$18], [%68, %$20] ; # L
  %74 = phi i1 [0, %$18], [1, %$20] ; # ->
  br i1 %74, label %$22, label %$21
$21:
  %75 = phi i64 [%59, %$17] ; # Y
  %76 = phi i64 [%55, %$17] ; # P
; # (let V (cons U $Nil) (setq P (if P (set 2 P V) (set R V))))
; # (cons U $Nil)
  %77 = call i64 @cons(i64 %57, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (if P (set 2 P V) (set R V))
  %78 = icmp ne i64 %76, 0
  br i1 %78, label %$23, label %$24
$23:
  %79 = phi i64 [%75, %$21] ; # Y
  %80 = phi i64 [%76, %$21] ; # P
; # (set 2 P V)
  %81 = inttoptr i64 %80 to i64*
  %82 = getelementptr i64, i64* %81, i32 1
  store i64 %77, i64* %82
  br label %$25
$24:
  %83 = phi i64 [%75, %$21] ; # Y
  %84 = phi i64 [%76, %$21] ; # P
; # (set R V)
  %85 = inttoptr i64 %43 to i64*
  store i64 %77, i64* %85
  br label %$25
$25:
  %86 = phi i64 [%79, %$23], [%83, %$24] ; # Y
  %87 = phi i64 [%80, %$23], [%84, %$24] ; # P
  %88 = phi i64 [%77, %$23], [%77, %$24] ; # ->
  br label %$22
$22:
  %89 = phi i64 [%59, %$17], [%86, %$25] ; # Y
  %90 = phi i64 [%55, %$17], [%88, %$25] ; # P
  br label %$12
$14:
  %91 = phi i64 [%50, %$12] ; # Y
  %92 = phi i64 [%51, %$12] ; # P
; # (val R)
  %93 = inttoptr i64 %43 to i64*
  %94 = load i64, i64* %93
; # (drop *Safe)
  %95 = inttoptr i64 %19 to i64*
  %96 = getelementptr i64, i64* %95, i32 1
  %97 = load i64, i64* %96
  %98 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %97, i64* %98
  ret i64 %94
}

define i64 @_Index(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (save (eval (++ X))) Z (eval (car X)) Cnt 1 U...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (save (eval (++ X)))
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %17 = load i64, i64* %16
  %18 = alloca i64, i64 2, align 16
  %19 = ptrtoint i64* %18 to i64
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = add i64 %19, 8
  %22 = inttoptr i64 %21 to i64*
  store i64 %17, i64* %22
  %23 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %19, i64* %23
; # (car X)
  %24 = inttoptr i64 %7 to i64*
  %25 = load i64, i64* %24
; # (eval (car X))
  %26 = and i64 %25, 6
  %27 = icmp ne i64 %26, 0
  br i1 %27, label %$9, label %$8
$9:
  br label %$7
$8:
  %28 = and i64 %25, 8
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %$11, label %$10
$11:
  %30 = inttoptr i64 %25 to i64*
  %31 = load i64, i64* %30
  br label %$7
$10:
  %32 = call i64 @evList(i64 %25)
  br label %$7
$7:
  %33 = phi i64 [%25, %$9], [%31, %$11], [%32, %$10] ; # ->
; # (loop (? (atom Z) $Nil) (? (equal Y (car Z)) (cnt Cnt)) (inc 'Cnt...
  br label %$12
$12:
  %34 = phi i64 [%33, %$7], [%58, %$18] ; # Z
  %35 = phi i64 [1, %$7], [%59, %$18] ; # Cnt
; # (? (atom Z) $Nil)
; # (atom Z)
  %36 = and i64 %34, 15
  %37 = icmp ne i64 %36, 0
  br i1 %37, label %$15, label %$13
$15:
  %38 = phi i64 [%34, %$12] ; # Z
  %39 = phi i64 [%35, %$12] ; # Cnt
  br label %$14
$13:
  %40 = phi i64 [%34, %$12] ; # Z
  %41 = phi i64 [%35, %$12] ; # Cnt
; # (? (equal Y (car Z)) (cnt Cnt))
; # (car Z)
  %42 = inttoptr i64 %40 to i64*
  %43 = load i64, i64* %42
; # (equal Y (car Z))
  %44 = call i1 @equal(i64 %15, i64 %43)
  br i1 %44, label %$17, label %$16
$17:
  %45 = phi i64 [%40, %$13] ; # Z
  %46 = phi i64 [%41, %$13] ; # Cnt
; # (cnt Cnt)
  %47 = shl i64 %46, 4
  %48 = or i64 %47, 2
  br label %$14
$16:
  %49 = phi i64 [%40, %$13] ; # Z
  %50 = phi i64 [%41, %$13] ; # Cnt
; # (inc 'Cnt)
  %51 = add i64 %50, 1
; # (? (== U (shift Z)) $Nil)
; # (shift Z)
  %52 = inttoptr i64 %49 to i64*
  %53 = getelementptr i64, i64* %52, i32 1
  %54 = load i64, i64* %53
; # (== U (shift Z))
  %55 = icmp eq i64 %33, %54
  br i1 %55, label %$19, label %$18
$19:
  %56 = phi i64 [%54, %$16] ; # Z
  %57 = phi i64 [%51, %$16] ; # Cnt
  br label %$14
$18:
  %58 = phi i64 [%54, %$16] ; # Z
  %59 = phi i64 [%51, %$16] ; # Cnt
  br label %$12
$14:
  %60 = phi i64 [%38, %$15], [%45, %$17], [%56, %$19] ; # Z
  %61 = phi i64 [%39, %$15], [%46, %$17], [%57, %$19] ; # Cnt
  %62 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$15], [%48, %$17], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$19] ; # ->
; # (drop *Safe)
  %63 = inttoptr i64 %19 to i64*
  %64 = getelementptr i64, i64* %63, i32 1
  %65 = load i64, i64* %64
  %66 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %65, i64* %66
  ret i64 %62
}

define i64 @_Offset(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (save (eval (++ X))) Z (eval (car X)) Cnt 1) ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (save (eval (++ X)))
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %17 = load i64, i64* %16
  %18 = alloca i64, i64 2, align 16
  %19 = ptrtoint i64* %18 to i64
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = add i64 %19, 8
  %22 = inttoptr i64 %21 to i64*
  store i64 %17, i64* %22
  %23 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %19, i64* %23
; # (car X)
  %24 = inttoptr i64 %7 to i64*
  %25 = load i64, i64* %24
; # (eval (car X))
  %26 = and i64 %25, 6
  %27 = icmp ne i64 %26, 0
  br i1 %27, label %$9, label %$8
$9:
  br label %$7
$8:
  %28 = and i64 %25, 8
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %$11, label %$10
$11:
  %30 = inttoptr i64 %25 to i64*
  %31 = load i64, i64* %30
  br label %$7
$10:
  %32 = call i64 @evList(i64 %25)
  br label %$7
$7:
  %33 = phi i64 [%25, %$9], [%31, %$11], [%32, %$10] ; # ->
; # (loop (? (atom Z) $Nil) (? (equal Y Z) (cnt Cnt)) (inc 'Cnt) (shi...
  br label %$12
$12:
  %34 = phi i64 [%33, %$7], [%52, %$16] ; # Z
  %35 = phi i64 [1, %$7], [%49, %$16] ; # Cnt
; # (? (atom Z) $Nil)
; # (atom Z)
  %36 = and i64 %34, 15
  %37 = icmp ne i64 %36, 0
  br i1 %37, label %$15, label %$13
$15:
  %38 = phi i64 [%34, %$12] ; # Z
  %39 = phi i64 [%35, %$12] ; # Cnt
  br label %$14
$13:
  %40 = phi i64 [%34, %$12] ; # Z
  %41 = phi i64 [%35, %$12] ; # Cnt
; # (? (equal Y Z) (cnt Cnt))
; # (equal Y Z)
  %42 = call i1 @equal(i64 %15, i64 %40)
  br i1 %42, label %$17, label %$16
$17:
  %43 = phi i64 [%40, %$13] ; # Z
  %44 = phi i64 [%41, %$13] ; # Cnt
; # (cnt Cnt)
  %45 = shl i64 %44, 4
  %46 = or i64 %45, 2
  br label %$14
$16:
  %47 = phi i64 [%40, %$13] ; # Z
  %48 = phi i64 [%41, %$13] ; # Cnt
; # (inc 'Cnt)
  %49 = add i64 %48, 1
; # (shift Z)
  %50 = inttoptr i64 %47 to i64*
  %51 = getelementptr i64, i64* %50, i32 1
  %52 = load i64, i64* %51
  br label %$12
$14:
  %53 = phi i64 [%38, %$15], [%43, %$17] ; # Z
  %54 = phi i64 [%39, %$15], [%44, %$17] ; # Cnt
  %55 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$15], [%46, %$17] ; # ->
; # (drop *Safe)
  %56 = inttoptr i64 %19 to i64*
  %57 = getelementptr i64, i64* %56, i32 1
  %58 = load i64, i64* %57
  %59 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %58, i64* %59
  ret i64 %55
}

define i64 @_Prior(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (save (eval (++ X))) Z (eval (car X))) (when ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (save (eval (++ X)))
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %17 = load i64, i64* %16
  %18 = alloca i64, i64 2, align 16
  %19 = ptrtoint i64* %18 to i64
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = add i64 %19, 8
  %22 = inttoptr i64 %21 to i64*
  store i64 %17, i64* %22
  %23 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %19, i64* %23
; # (car X)
  %24 = inttoptr i64 %7 to i64*
  %25 = load i64, i64* %24
; # (eval (car X))
  %26 = and i64 %25, 6
  %27 = icmp ne i64 %26, 0
  br i1 %27, label %$9, label %$8
$9:
  br label %$7
$8:
  %28 = and i64 %25, 8
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %$11, label %$10
$11:
  %30 = inttoptr i64 %25 to i64*
  %31 = load i64, i64* %30
  br label %$7
$10:
  %32 = call i64 @evList(i64 %25)
  br label %$7
$7:
  %33 = phi i64 [%25, %$9], [%31, %$11], [%32, %$10] ; # ->
; # (when (and (pair Y) (<> Y Z)) (while (pair Z) (when (== (cdr Z) Y...
; # (and (pair Y) (<> Y Z))
; # (pair Y)
  %34 = and i64 %15, 15
  %35 = icmp eq i64 %34, 0
  br i1 %35, label %$13, label %$12
$13:
  %36 = phi i64 [%33, %$7] ; # Z
; # (<> Y Z)
  %37 = icmp ne i64 %15, %36
  br label %$12
$12:
  %38 = phi i64 [%33, %$7], [%36, %$13] ; # Z
  %39 = phi i1 [0, %$7], [%37, %$13] ; # ->
  br i1 %39, label %$14, label %$15
$14:
  %40 = phi i64 [%38, %$12] ; # Z
; # (while (pair Z) (when (== (cdr Z) Y) (ret Z)) (setq Z @))
  br label %$16
$16:
  %41 = phi i64 [%40, %$14], [%47, %$20] ; # Z
; # (pair Z)
  %42 = and i64 %41, 15
  %43 = icmp eq i64 %42, 0
  br i1 %43, label %$17, label %$18
$17:
  %44 = phi i64 [%41, %$16] ; # Z
; # (when (== (cdr Z) Y) (ret Z))
; # (cdr Z)
  %45 = inttoptr i64 %44 to i64*
  %46 = getelementptr i64, i64* %45, i32 1
  %47 = load i64, i64* %46
; # (== (cdr Z) Y)
  %48 = icmp eq i64 %47, %15
  br i1 %48, label %$19, label %$20
$19:
  %49 = phi i64 [%44, %$17] ; # Z
; # (ret Z)
; # (drop *Safe)
  %50 = inttoptr i64 %19 to i64*
  %51 = getelementptr i64, i64* %50, i32 1
  %52 = load i64, i64* %51
  %53 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %52, i64* %53
  ret i64 %49
$20:
  %54 = phi i64 [%44, %$17] ; # Z
  br label %$16
$18:
  %55 = phi i64 [%41, %$16] ; # Z
  br label %$15
$15:
  %56 = phi i64 [%38, %$12], [%55, %$18] ; # Z
; # (drop *Safe)
  %57 = inttoptr i64 %19 to i64*
  %58 = getelementptr i64, i64* %57, i32 1
  %59 = load i64, i64* %58
  %60 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %59, i64* %60
  ret i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
}

define i64 @_Length(i64) align 8 {
$1:
; # (let X (eval (cadr Exe)) (cond ((num? X) (fmtNum X -1 0 0 null)) ...
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (cond ((num? X) (fmtNum X -1 0 0 null)) ((pair X) (let (C ONE Y X...
; # (num? X)
  %14 = and i64 %13, 6
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$9, label %$8
$9:
  %16 = phi i64 [%13, %$2] ; # X
; # (fmtNum X -1 0 0 null)
  %17 = call i64 @fmtNum(i64 %16, i64 -1, i8 0, i8 0, i64* null)
  br label %$7
$8:
  %18 = phi i64 [%13, %$2] ; # X
; # (pair X)
  %19 = and i64 %18, 15
  %20 = icmp eq i64 %19, 0
  br i1 %20, label %$11, label %$10
$11:
  %21 = phi i64 [%18, %$8] ; # X
; # (let (C ONE Y X) (loop (set X (| (car X) 1)) (? (atom (shift X)) ...
; # (loop (set X (| (car X) 1)) (? (atom (shift X)) (loop (set Y (& (...
  br label %$12
$12:
  %22 = phi i64 [%21, %$11], [%100, %$19] ; # X
  %23 = phi i64 [18, %$11], [%103, %$19] ; # C
  %24 = phi i64 [%21, %$11], [%102, %$19] ; # Y
; # (set X (| (car X) 1))
; # (car X)
  %25 = inttoptr i64 %22 to i64*
  %26 = load i64, i64* %25
; # (| (car X) 1)
  %27 = or i64 %26, 1
  %28 = inttoptr i64 %22 to i64*
  store i64 %27, i64* %28
; # (? (atom (shift X)) (loop (set Y (& (car Y) -2)) (? (== X (shift ...
; # (shift X)
  %29 = inttoptr i64 %22 to i64*
  %30 = getelementptr i64, i64* %29, i32 1
  %31 = load i64, i64* %30
; # (atom (shift X))
  %32 = and i64 %31, 15
  %33 = icmp ne i64 %32, 0
  br i1 %33, label %$15, label %$13
$15:
  %34 = phi i64 [%31, %$12] ; # X
  %35 = phi i64 [%23, %$12] ; # C
  %36 = phi i64 [%24, %$12] ; # Y
; # (loop (set Y (& (car Y) -2)) (? (== X (shift Y))))
  br label %$16
$16:
  %37 = phi i64 [%34, %$15], [%48, %$17] ; # X
  %38 = phi i64 [%35, %$15], [%49, %$17] ; # C
  %39 = phi i64 [%36, %$15], [%50, %$17] ; # Y
; # (set Y (& (car Y) -2))
; # (car Y)
  %40 = inttoptr i64 %39 to i64*
  %41 = load i64, i64* %40
; # (& (car Y) -2)
  %42 = and i64 %41, -2
  %43 = inttoptr i64 %39 to i64*
  store i64 %42, i64* %43
; # (? (== X (shift Y)))
; # (shift Y)
  %44 = inttoptr i64 %39 to i64*
  %45 = getelementptr i64, i64* %44, i32 1
  %46 = load i64, i64* %45
; # (== X (shift Y))
  %47 = icmp eq i64 %37, %46
  br i1 %47, label %$18, label %$17
$17:
  %48 = phi i64 [%37, %$16] ; # X
  %49 = phi i64 [%38, %$16] ; # C
  %50 = phi i64 [%46, %$16] ; # Y
  br label %$16
$18:
  %51 = phi i64 [%37, %$16] ; # X
  %52 = phi i64 [%38, %$16] ; # C
  %53 = phi i64 [%46, %$16] ; # Y
  %54 = phi i64 [0, %$16] ; # ->
  br label %$14
$13:
  %55 = phi i64 [%31, %$12] ; # X
  %56 = phi i64 [%23, %$12] ; # C
  %57 = phi i64 [%24, %$12] ; # Y
; # (? (& (car X) 1) (until (== X Y) (set Y (& (car Y) -2)) (shift Y)...
; # (car X)
  %58 = inttoptr i64 %55 to i64*
  %59 = load i64, i64* %58
; # (& (car X) 1)
  %60 = and i64 %59, 1
  %61 = icmp ne i64 %60, 0
  br i1 %61, label %$20, label %$19
$20:
  %62 = phi i64 [%55, %$13] ; # X
  %63 = phi i64 [%56, %$13] ; # C
  %64 = phi i64 [%57, %$13] ; # Y
; # (until (== X Y) (set Y (& (car Y) -2)) (shift Y))
  br label %$21
$21:
  %65 = phi i64 [%62, %$20], [%69, %$22] ; # X
  %66 = phi i64 [%63, %$20], [%70, %$22] ; # C
  %67 = phi i64 [%64, %$20], [%78, %$22] ; # Y
; # (== X Y)
  %68 = icmp eq i64 %65, %67
  br i1 %68, label %$23, label %$22
$22:
  %69 = phi i64 [%65, %$21] ; # X
  %70 = phi i64 [%66, %$21] ; # C
  %71 = phi i64 [%67, %$21] ; # Y
; # (set Y (& (car Y) -2))
; # (car Y)
  %72 = inttoptr i64 %71 to i64*
  %73 = load i64, i64* %72
; # (& (car Y) -2)
  %74 = and i64 %73, -2
  %75 = inttoptr i64 %71 to i64*
  store i64 %74, i64* %75
; # (shift Y)
  %76 = inttoptr i64 %71 to i64*
  %77 = getelementptr i64, i64* %76, i32 1
  %78 = load i64, i64* %77
  br label %$21
$23:
  %79 = phi i64 [%65, %$21] ; # X
  %80 = phi i64 [%66, %$21] ; # C
  %81 = phi i64 [%67, %$21] ; # Y
; # (loop (set Y (& (car Y) -2)) (? (== X (shift Y))))
  br label %$24
$24:
  %82 = phi i64 [%79, %$23], [%93, %$25] ; # X
  %83 = phi i64 [%80, %$23], [%94, %$25] ; # C
  %84 = phi i64 [%81, %$23], [%95, %$25] ; # Y
; # (set Y (& (car Y) -2))
; # (car Y)
  %85 = inttoptr i64 %84 to i64*
  %86 = load i64, i64* %85
; # (& (car Y) -2)
  %87 = and i64 %86, -2
  %88 = inttoptr i64 %84 to i64*
  store i64 %87, i64* %88
; # (? (== X (shift Y)))
; # (shift Y)
  %89 = inttoptr i64 %84 to i64*
  %90 = getelementptr i64, i64* %89, i32 1
  %91 = load i64, i64* %90
; # (== X (shift Y))
  %92 = icmp eq i64 %82, %91
  br i1 %92, label %$26, label %$25
$25:
  %93 = phi i64 [%82, %$24] ; # X
  %94 = phi i64 [%83, %$24] ; # C
  %95 = phi i64 [%91, %$24] ; # Y
  br label %$24
$26:
  %96 = phi i64 [%82, %$24] ; # X
  %97 = phi i64 [%83, %$24] ; # C
  %98 = phi i64 [%91, %$24] ; # Y
  %99 = phi i64 [0, %$24] ; # ->
  br label %$14
$19:
  %100 = phi i64 [%55, %$13] ; # X
  %101 = phi i64 [%56, %$13] ; # C
  %102 = phi i64 [%57, %$13] ; # Y
; # (inc 'C (hex "10"))
  %103 = add i64 %101, 16
  br label %$12
$14:
  %104 = phi i64 [%51, %$18], [%96, %$26] ; # X
  %105 = phi i64 [%52, %$18], [%97, %$26] ; # C
  %106 = phi i64 [%53, %$18], [%98, %$26] ; # Y
  %107 = phi i64 [%52, %$18], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$26] ; # ->
  br label %$7
$10:
  %108 = phi i64 [%18, %$8] ; # X
; # (nil? X)
  %109 = icmp eq i64 %108, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %109, label %$28, label %$27
$28:
  %110 = phi i64 [%108, %$10] ; # X
  br label %$7
$27:
  %111 = phi i64 [%108, %$10] ; # X
; # (tail X)
  %112 = add i64 %111, -8
; # (val (tail X))
  %113 = inttoptr i64 %112 to i64*
  %114 = load i64, i64* %113
; # (sym? (val (tail X)))
  %115 = and i64 %114, 8
  %116 = icmp ne i64 %115, 0
  br i1 %116, label %$30, label %$29
$30:
  %117 = phi i64 [%111, %$27] ; # X
  br label %$7
$29:
  %118 = phi i64 [%111, %$27] ; # X
; # (let (C ZERO P (push 0 (name @))) (while (symChar P) (inc 'C (hex...
; # (name @)
  br label %$31
$31:
  %119 = phi i64 [%114, %$29], [%125, %$32] ; # Tail
  %120 = and i64 %119, 6
  %121 = icmp ne i64 %120, 0
  br i1 %121, label %$33, label %$32
$32:
  %122 = phi i64 [%119, %$31] ; # Tail
  %123 = inttoptr i64 %122 to i64*
  %124 = getelementptr i64, i64* %123, i32 1
  %125 = load i64, i64* %124
  br label %$31
$33:
  %126 = phi i64 [%119, %$31] ; # Tail
; # (push 0 (name @))
  %127 = alloca i64, i64 2, align 16
  store i64 0, i64* %127
  %128 = getelementptr i64, i64* %127, i32 1
  store i64 %126, i64* %128
; # (while (symChar P) (inc 'C (hex "10")))
  br label %$34
$34:
  %129 = phi i64 [%118, %$33], [%133, %$35] ; # X
  %130 = phi i64 [2, %$33], [%135, %$35] ; # C
; # (symChar P)
  %131 = call i32 @symChar(i64* %127)
  %132 = icmp ne i32 %131, 0
  br i1 %132, label %$35, label %$36
$35:
  %133 = phi i64 [%129, %$34] ; # X
  %134 = phi i64 [%130, %$34] ; # C
; # (inc 'C (hex "10"))
  %135 = add i64 %134, 16
  br label %$34
$36:
  %136 = phi i64 [%129, %$34] ; # X
  %137 = phi i64 [%130, %$34] ; # C
  br label %$7
$7:
  %138 = phi i64 [%16, %$9], [%104, %$14], [%110, %$28], [%117, %$30], [%136, %$36] ; # X
  %139 = phi i64 [%17, %$9], [%107, %$14], [2, %$28], [2, %$30], [%137, %$36] ; # ->
  ret i64 %139
}

define i64 @size(i64) align 8 {
$1:
; # (let (C 1 X L Y (car X)) (loop (when (pair Y) (stkChk 0) (inc 'C ...
; # (car X)
  %1 = inttoptr i64 %0 to i64*
  %2 = load i64, i64* %1
; # (loop (when (pair Y) (stkChk 0) (inc 'C (size Y))) (set X (| Y 1)...
  br label %$2
$2:
  %3 = phi i64 [%0, %$1], [%107, %$13] ; # L
  %4 = phi i64 [1, %$1], [%111, %$13] ; # C
  %5 = phi i64 [%0, %$1], [%109, %$13] ; # X
  %6 = phi i64 [%2, %$1], [%110, %$13] ; # Y
; # (when (pair Y) (stkChk 0) (inc 'C (size Y)))
; # (pair Y)
  %7 = and i64 %6, 15
  %8 = icmp eq i64 %7, 0
  br i1 %8, label %$3, label %$4
$3:
  %9 = phi i64 [%3, %$2] ; # L
  %10 = phi i64 [%4, %$2] ; # C
  %11 = phi i64 [%5, %$2] ; # X
  %12 = phi i64 [%6, %$2] ; # Y
; # (stkChk 0)
  %13 = load i8*, i8** @$StkLimit
  %14 = call i8* @llvm.stacksave()
  %15 = icmp ugt i8* %13, %14
  br i1 %15, label %$5, label %$6
$5:
  call void @stkErr(i64 0)
  unreachable
$6:
; # (size Y)
  %16 = call i64 @size(i64 %12)
; # (inc 'C (size Y))
  %17 = add i64 %10, %16
  br label %$4
$4:
  %18 = phi i64 [%3, %$2], [%9, %$6] ; # L
  %19 = phi i64 [%4, %$2], [%17, %$6] ; # C
  %20 = phi i64 [%5, %$2], [%11, %$6] ; # X
  %21 = phi i64 [%6, %$2], [%12, %$6] ; # Y
; # (set X (| Y 1))
; # (| Y 1)
  %22 = or i64 %21, 1
  %23 = inttoptr i64 %20 to i64*
  store i64 %22, i64* %23
; # (? (atom (shift X)) (loop (set L (& (car L) -2)) (? (== X (shift ...
; # (shift X)
  %24 = inttoptr i64 %20 to i64*
  %25 = getelementptr i64, i64* %24, i32 1
  %26 = load i64, i64* %25
; # (atom (shift X))
  %27 = and i64 %26, 15
  %28 = icmp ne i64 %27, 0
  br i1 %28, label %$9, label %$7
$9:
  %29 = phi i64 [%18, %$4] ; # L
  %30 = phi i64 [%19, %$4] ; # C
  %31 = phi i64 [%26, %$4] ; # X
  %32 = phi i64 [%21, %$4] ; # Y
; # (loop (set L (& (car L) -2)) (? (== X (shift L))))
  br label %$10
$10:
  %33 = phi i64 [%29, %$9], [%45, %$11] ; # L
  %34 = phi i64 [%30, %$9], [%46, %$11] ; # C
  %35 = phi i64 [%31, %$9], [%47, %$11] ; # X
  %36 = phi i64 [%32, %$9], [%48, %$11] ; # Y
; # (set L (& (car L) -2))
; # (car L)
  %37 = inttoptr i64 %33 to i64*
  %38 = load i64, i64* %37
; # (& (car L) -2)
  %39 = and i64 %38, -2
  %40 = inttoptr i64 %33 to i64*
  store i64 %39, i64* %40
; # (? (== X (shift L)))
; # (shift L)
  %41 = inttoptr i64 %33 to i64*
  %42 = getelementptr i64, i64* %41, i32 1
  %43 = load i64, i64* %42
; # (== X (shift L))
  %44 = icmp eq i64 %35, %43
  br i1 %44, label %$12, label %$11
$11:
  %45 = phi i64 [%43, %$10] ; # L
  %46 = phi i64 [%34, %$10] ; # C
  %47 = phi i64 [%35, %$10] ; # X
  %48 = phi i64 [%36, %$10] ; # Y
  br label %$10
$12:
  %49 = phi i64 [%43, %$10] ; # L
  %50 = phi i64 [%34, %$10] ; # C
  %51 = phi i64 [%35, %$10] ; # X
  %52 = phi i64 [%36, %$10] ; # Y
  %53 = phi i64 [0, %$10] ; # ->
  br label %$8
$7:
  %54 = phi i64 [%18, %$4] ; # L
  %55 = phi i64 [%19, %$4] ; # C
  %56 = phi i64 [%26, %$4] ; # X
  %57 = phi i64 [%21, %$4] ; # Y
; # (? (& (setq Y (car X)) 1) (until (== X L) (set L (& (car L) -2)) ...
; # (car X)
  %58 = inttoptr i64 %56 to i64*
  %59 = load i64, i64* %58
; # (& (setq Y (car X)) 1)
  %60 = and i64 %59, 1
  %61 = icmp ne i64 %60, 0
  br i1 %61, label %$14, label %$13
$14:
  %62 = phi i64 [%54, %$7] ; # L
  %63 = phi i64 [%55, %$7] ; # C
  %64 = phi i64 [%56, %$7] ; # X
  %65 = phi i64 [%59, %$7] ; # Y
; # (until (== X L) (set L (& (car L) -2)) (shift L))
  br label %$15
$15:
  %66 = phi i64 [%62, %$14], [%81, %$16] ; # L
  %67 = phi i64 [%63, %$14], [%72, %$16] ; # C
  %68 = phi i64 [%64, %$14], [%73, %$16] ; # X
  %69 = phi i64 [%65, %$14], [%74, %$16] ; # Y
; # (== X L)
  %70 = icmp eq i64 %68, %66
  br i1 %70, label %$17, label %$16
$16:
  %71 = phi i64 [%66, %$15] ; # L
  %72 = phi i64 [%67, %$15] ; # C
  %73 = phi i64 [%68, %$15] ; # X
  %74 = phi i64 [%69, %$15] ; # Y
; # (set L (& (car L) -2))
; # (car L)
  %75 = inttoptr i64 %71 to i64*
  %76 = load i64, i64* %75
; # (& (car L) -2)
  %77 = and i64 %76, -2
  %78 = inttoptr i64 %71 to i64*
  store i64 %77, i64* %78
; # (shift L)
  %79 = inttoptr i64 %71 to i64*
  %80 = getelementptr i64, i64* %79, i32 1
  %81 = load i64, i64* %80
  br label %$15
$17:
  %82 = phi i64 [%66, %$15] ; # L
  %83 = phi i64 [%67, %$15] ; # C
  %84 = phi i64 [%68, %$15] ; # X
  %85 = phi i64 [%69, %$15] ; # Y
; # (loop (set L (& (car L) -2)) (? (== X (shift L))))
  br label %$18
$18:
  %86 = phi i64 [%82, %$17], [%98, %$19] ; # L
  %87 = phi i64 [%83, %$17], [%99, %$19] ; # C
  %88 = phi i64 [%84, %$17], [%100, %$19] ; # X
  %89 = phi i64 [%85, %$17], [%101, %$19] ; # Y
; # (set L (& (car L) -2))
; # (car L)
  %90 = inttoptr i64 %86 to i64*
  %91 = load i64, i64* %90
; # (& (car L) -2)
  %92 = and i64 %91, -2
  %93 = inttoptr i64 %86 to i64*
  store i64 %92, i64* %93
; # (? (== X (shift L)))
; # (shift L)
  %94 = inttoptr i64 %86 to i64*
  %95 = getelementptr i64, i64* %94, i32 1
  %96 = load i64, i64* %95
; # (== X (shift L))
  %97 = icmp eq i64 %88, %96
  br i1 %97, label %$20, label %$19
$19:
  %98 = phi i64 [%96, %$18] ; # L
  %99 = phi i64 [%87, %$18] ; # C
  %100 = phi i64 [%88, %$18] ; # X
  %101 = phi i64 [%89, %$18] ; # Y
  br label %$18
$20:
  %102 = phi i64 [%96, %$18] ; # L
  %103 = phi i64 [%87, %$18] ; # C
  %104 = phi i64 [%88, %$18] ; # X
  %105 = phi i64 [%89, %$18] ; # Y
  %106 = phi i64 [0, %$18] ; # ->
  br label %$8
$13:
  %107 = phi i64 [%54, %$7] ; # L
  %108 = phi i64 [%55, %$7] ; # C
  %109 = phi i64 [%56, %$7] ; # X
  %110 = phi i64 [%59, %$7] ; # Y
; # (inc 'C)
  %111 = add i64 %108, 1
  br label %$2
$8:
  %112 = phi i64 [%49, %$12], [%102, %$20] ; # L
  %113 = phi i64 [%50, %$12], [%103, %$20] ; # C
  %114 = phi i64 [%51, %$12], [%104, %$20] ; # X
  %115 = phi i64 [%52, %$12], [%105, %$20] ; # Y
  %116 = phi i64 [%50, %$12], [%103, %$20] ; # ->
  ret i64 %116
}

define i64 @binSize(i64) align 8 {
$1:
; # (cond ((cnt? X) (setq X (shr X 3)) (: 1 (let C 2 (while (setq X (...
; # (cnt? X)
  %1 = and i64 %0, 2
  %2 = icmp ne i64 %1, 0
  br i1 %2, label %$4, label %$3
$4:
  %3 = phi i64 [%0, %$1] ; # X
; # (shr X 3)
  %4 = lshr i64 %3, 3
; # (: 1 (let C 2 (while (setq X (shr X 8)) (inc 'C)) C))
  br label %$-1
$-1:
  %5 = phi i64 [%4, %$4], [%98, %$32] ; # X
; # (let C 2 (while (setq X (shr X 8)) (inc 'C)) C)
; # (while (setq X (shr X 8)) (inc 'C))
  br label %$5
$5:
  %6 = phi i64 [%5, %$-1], [%10, %$6] ; # X
  %7 = phi i64 [2, %$-1], [%12, %$6] ; # C
; # (shr X 8)
  %8 = lshr i64 %6, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$7
$6:
  %10 = phi i64 [%8, %$5] ; # X
  %11 = phi i64 [%7, %$5] ; # C
; # (inc 'C)
  %12 = add i64 %11, 1
  br label %$5
$7:
  %13 = phi i64 [%8, %$5] ; # X
  %14 = phi i64 [%7, %$5] ; # C
  br label %$2
$3:
  %15 = phi i64 [%0, %$1] ; # X
; # (big? X)
  %16 = and i64 %15, 4
  %17 = icmp ne i64 %16, 0
  br i1 %17, label %$9, label %$8
$9:
  %18 = phi i64 [%15, %$3] ; # X
; # (pos X)
  %19 = and i64 %18, -9
; # (let C 9 (loop (setq D (val (dig X))) (? (cnt? (setq X (val (big ...
; # (loop (setq D (val (dig X))) (? (cnt? (setq X (val (big X))))) (i...
  br label %$10
$10:
  %20 = phi i64 [%19, %$9], [%30, %$11] ; # X
  %21 = phi i64 [9, %$9], [%32, %$11] ; # C
; # (dig X)
  %22 = add i64 %20, -4
; # (val (dig X))
  %23 = inttoptr i64 %22 to i64*
  %24 = load i64, i64* %23
; # (? (cnt? (setq X (val (big X)))))
; # (big X)
  %25 = add i64 %20, 4
; # (val (big X))
  %26 = inttoptr i64 %25 to i64*
  %27 = load i64, i64* %26
; # (cnt? (setq X (val (big X))))
  %28 = and i64 %27, 2
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %$12, label %$11
$11:
  %30 = phi i64 [%27, %$10] ; # X
  %31 = phi i64 [%21, %$10] ; # C
; # (inc 'C 8)
  %32 = add i64 %31, 8
  br label %$10
$12:
  %33 = phi i64 [%27, %$10] ; # X
  %34 = phi i64 [%21, %$10] ; # C
  %35 = phi i64 [0, %$10] ; # ->
; # (int X)
  %36 = lshr i64 %33, 4
; # (add D D)
  %37 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %24, i64 %24)
  %38 = extractvalue {i64, i1} %37, 1
  %39 = extractvalue {i64, i1} %37, 0
; # (+ X X @@)
  %40 = add i64 %36, %36
  %41 = zext i1 %38 to i64
  %42 = add i64 %40, %41
; # (: 2 (when X (loop (inc 'C) (? (=0 (setq X (shr X 8)))))) (if (>=...
  br label %$-2
$-2:
  %43 = phi i64 [%42, %$12], [%112, %$35] ; # X
  %44 = phi i64 [%34, %$12], [%111, %$35] ; # C
; # (when X (loop (inc 'C) (? (=0 (setq X (shr X 8))))))
  %45 = icmp ne i64 %43, 0
  br i1 %45, label %$13, label %$14
$13:
  %46 = phi i64 [%43, %$-2] ; # X
  %47 = phi i64 [%44, %$-2] ; # C
; # (loop (inc 'C) (? (=0 (setq X (shr X 8)))))
  br label %$15
$15:
  %48 = phi i64 [%46, %$13], [%53, %$16] ; # X
  %49 = phi i64 [%47, %$13], [%54, %$16] ; # C
; # (inc 'C)
  %50 = add i64 %49, 1
; # (? (=0 (setq X (shr X 8))))
; # (shr X 8)
  %51 = lshr i64 %48, 8
; # (=0 (setq X (shr X 8)))
  %52 = icmp eq i64 %51, 0
  br i1 %52, label %$17, label %$16
$16:
  %53 = phi i64 [%51, %$15] ; # X
  %54 = phi i64 [%50, %$15] ; # C
  br label %$15
$17:
  %55 = phi i64 [%51, %$15] ; # X
  %56 = phi i64 [%50, %$15] ; # C
  %57 = phi i64 [0, %$15] ; # ->
  br label %$14
$14:
  %58 = phi i64 [%43, %$-2], [%55, %$17] ; # X
  %59 = phi i64 [%44, %$-2], [%56, %$17] ; # C
; # (if (>= C (+ 63 1)) (+ C (/ (- C 64) 255) 1) C)
; # (+ 63 1)
; # (>= C (+ 63 1))
  %60 = icmp uge i64 %59, 64
  br i1 %60, label %$18, label %$19
$18:
  %61 = phi i64 [%58, %$14] ; # X
  %62 = phi i64 [%59, %$14] ; # C
; # (- C 64)
  %63 = sub i64 %62, 64
; # (/ (- C 64) 255)
  %64 = udiv i64 %63, 255
; # (+ C (/ (- C 64) 255) 1)
  %65 = add i64 %62, %64
  %66 = add i64 %65, 1
  br label %$20
$19:
  %67 = phi i64 [%58, %$14] ; # X
  %68 = phi i64 [%59, %$14] ; # C
  br label %$20
$20:
  %69 = phi i64 [%61, %$18], [%67, %$19] ; # X
  %70 = phi i64 [%62, %$18], [%68, %$19] ; # C
  %71 = phi i64 [%66, %$18], [%68, %$19] ; # ->
  br label %$2
$8:
  %72 = phi i64 [%15, %$3] ; # X
; # (sym? X)
  %73 = and i64 %72, 8
  %74 = icmp ne i64 %73, 0
  br i1 %74, label %$22, label %$21
$22:
  %75 = phi i64 [%72, %$8] ; # X
; # (cond ((nil? X) 1) ((== (name (& (val (tail X)) -9)) ZERO) 1) ((c...
; # (nil? X)
  %76 = icmp eq i64 %75, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %76, label %$25, label %$24
$25:
  %77 = phi i64 [%75, %$22] ; # X
  br label %$23
$24:
  %78 = phi i64 [%75, %$22] ; # X
; # (tail X)
  %79 = add i64 %78, -8
; # (val (tail X))
  %80 = inttoptr i64 %79 to i64*
  %81 = load i64, i64* %80
; # (& (val (tail X)) -9)
  %82 = and i64 %81, -9
; # (name (& (val (tail X)) -9))
  br label %$26
$26:
  %83 = phi i64 [%82, %$24], [%89, %$27] ; # Tail
  %84 = and i64 %83, 6
  %85 = icmp ne i64 %84, 0
  br i1 %85, label %$28, label %$27
$27:
  %86 = phi i64 [%83, %$26] ; # Tail
  %87 = inttoptr i64 %86 to i64*
  %88 = getelementptr i64, i64* %87, i32 1
  %89 = load i64, i64* %88
  br label %$26
$28:
  %90 = phi i64 [%83, %$26] ; # Tail
; # (== (name (& (val (tail X)) -9)) ZERO)
  %91 = icmp eq i64 %90, 2
  br i1 %91, label %$30, label %$29
$30:
  %92 = phi i64 [%78, %$28] ; # X
  br label %$23
$29:
  %93 = phi i64 [%78, %$28] ; # X
; # (cnt? (setq X @))
  %94 = and i64 %90, 2
  %95 = icmp ne i64 %94, 0
  br i1 %95, label %$32, label %$31
$32:
  %96 = phi i64 [%90, %$29] ; # X
; # (shl X 2)
  %97 = shl i64 %96, 2
; # (shr (shl X 2) 6)
  %98 = lshr i64 %97, 6
; # (goto 1)
  br label %$-1
$31:
  %99 = phi i64 [%90, %$29] ; # X
; # (let C 9 (until (cnt? (setq X (val (big X)))) (inc 'C 8)) (setq X...
; # (until (cnt? (setq X (val (big X)))) (inc 'C 8))
  br label %$33
$33:
  %100 = phi i64 [%99, %$31], [%107, %$34] ; # X
  %101 = phi i64 [9, %$31], [%109, %$34] ; # C
; # (big X)
  %102 = add i64 %100, 4
; # (val (big X))
  %103 = inttoptr i64 %102 to i64*
  %104 = load i64, i64* %103
; # (cnt? (setq X (val (big X))))
  %105 = and i64 %104, 2
  %106 = icmp ne i64 %105, 0
  br i1 %106, label %$35, label %$34
$34:
  %107 = phi i64 [%104, %$33] ; # X
  %108 = phi i64 [%101, %$33] ; # C
; # (inc 'C 8)
  %109 = add i64 %108, 8
  br label %$33
$35:
  %110 = phi i64 [%104, %$33] ; # X
  %111 = phi i64 [%101, %$33] ; # C
; # (int X)
  %112 = lshr i64 %110, 4
; # (goto 2)
  br label %$-2
$23:
  %113 = phi i64 [%77, %$25], [%92, %$30] ; # X
  %114 = phi i64 [1, %$25], [1, %$30] ; # ->
  br label %$2
$21:
  %115 = phi i64 [%72, %$8] ; # X
; # (let (C 2 Y X) (loop (inc 'C (binSize (++ X))) (? (nil? X) C) (? ...
; # (loop (inc 'C (binSize (++ X))) (? (nil? X) C) (? (== Y X) (inc C...
  br label %$36
$36:
  %116 = phi i64 [%115, %$21], [%141, %$42] ; # X
  %117 = phi i64 [2, %$21], [%142, %$42] ; # C
; # (++ X)
  %118 = inttoptr i64 %116 to i64*
  %119 = load i64, i64* %118
  %120 = getelementptr i64, i64* %118, i32 1
  %121 = load i64, i64* %120
; # (binSize (++ X))
  %122 = call i64 @binSize(i64 %119)
; # (inc 'C (binSize (++ X)))
  %123 = add i64 %117, %122
; # (? (nil? X) C)
; # (nil? X)
  %124 = icmp eq i64 %121, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %124, label %$39, label %$37
$39:
  %125 = phi i64 [%121, %$36] ; # X
  %126 = phi i64 [%123, %$36] ; # C
  br label %$38
$37:
  %127 = phi i64 [%121, %$36] ; # X
  %128 = phi i64 [%123, %$36] ; # C
; # (? (== Y X) (inc C))
; # (== Y X)
  %129 = icmp eq i64 %115, %127
  br i1 %129, label %$41, label %$40
$41:
  %130 = phi i64 [%127, %$37] ; # X
  %131 = phi i64 [%128, %$37] ; # C
; # (inc C)
  %132 = add i64 %131, 1
  br label %$38
$40:
  %133 = phi i64 [%127, %$37] ; # X
  %134 = phi i64 [%128, %$37] ; # C
; # (? (atom X) (+ C (binSize X)))
; # (atom X)
  %135 = and i64 %133, 15
  %136 = icmp ne i64 %135, 0
  br i1 %136, label %$43, label %$42
$43:
  %137 = phi i64 [%133, %$40] ; # X
  %138 = phi i64 [%134, %$40] ; # C
; # (binSize X)
  %139 = call i64 @binSize(i64 %137)
; # (+ C (binSize X))
  %140 = add i64 %138, %139
  br label %$38
$42:
  %141 = phi i64 [%133, %$40] ; # X
  %142 = phi i64 [%134, %$40] ; # C
  br label %$36
$38:
  %143 = phi i64 [%125, %$39], [%130, %$41], [%137, %$43] ; # X
  %144 = phi i64 [%126, %$39], [%131, %$41], [%138, %$43] ; # C
  %145 = phi i64 [%126, %$39], [%132, %$41], [%140, %$43] ; # ->
  br label %$2
$2:
  %146 = phi i64 [%13, %$7], [%69, %$20], [%113, %$23], [%143, %$38] ; # X
  %147 = phi i64 [%14, %$7], [%71, %$20], [%114, %$23], [%145, %$38] ; # ->
  ret i64 %147
}

define i64 @_Size(i64) align 8 {
$1:
; # (let X (eval (cadr Exe)) (cond ((cnt? X) (setq X (shr X 3)) (let ...
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (cond ((cnt? X) (setq X (shr X 3)) (let C ONE (while (setq X (shr...
; # (cnt? X)
  %14 = and i64 %13, 2
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$9, label %$8
$9:
  %16 = phi i64 [%13, %$2] ; # X
; # (shr X 3)
  %17 = lshr i64 %16, 3
; # (let C ONE (while (setq X (shr X 8)) (inc 'C (hex "10"))) C)
; # (while (setq X (shr X 8)) (inc 'C (hex "10")))
  br label %$10
$10:
  %18 = phi i64 [%17, %$9], [%22, %$11] ; # X
  %19 = phi i64 [18, %$9], [%24, %$11] ; # C
; # (shr X 8)
  %20 = lshr i64 %18, 8
  %21 = icmp ne i64 %20, 0
  br i1 %21, label %$11, label %$12
$11:
  %22 = phi i64 [%20, %$10] ; # X
  %23 = phi i64 [%19, %$10] ; # C
; # (inc 'C (hex "10"))
  %24 = add i64 %23, 16
  br label %$10
$12:
  %25 = phi i64 [%20, %$10] ; # X
  %26 = phi i64 [%19, %$10] ; # C
  br label %$7
$8:
  %27 = phi i64 [%13, %$2] ; # X
; # (big? X)
  %28 = and i64 %27, 4
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %$14, label %$13
$14:
  %30 = phi i64 [%27, %$8] ; # X
; # (pos X)
  %31 = and i64 %30, -9
; # (let (C (hex "82") D T) (loop (setq D (val (dig X))) (? (cnt? (se...
; # (loop (setq D (val (dig X))) (? (cnt? (setq X (val (big X))))) (i...
  br label %$15
$15:
  %32 = phi i64 [%31, %$14], [%42, %$16] ; # X
  %33 = phi i64 [130, %$14], [%45, %$16] ; # C
; # (dig X)
  %34 = add i64 %32, -4
; # (val (dig X))
  %35 = inttoptr i64 %34 to i64*
  %36 = load i64, i64* %35
; # (? (cnt? (setq X (val (big X)))))
; # (big X)
  %37 = add i64 %32, 4
; # (val (big X))
  %38 = inttoptr i64 %37 to i64*
  %39 = load i64, i64* %38
; # (cnt? (setq X (val (big X))))
  %40 = and i64 %39, 2
  %41 = icmp ne i64 %40, 0
  br i1 %41, label %$17, label %$16
$16:
  %42 = phi i64 [%39, %$15] ; # X
  %43 = phi i64 [%33, %$15] ; # C
  %44 = phi i64 [%36, %$15] ; # D
; # (inc 'C (hex "80"))
  %45 = add i64 %43, 128
  br label %$15
$17:
  %46 = phi i64 [%39, %$15] ; # X
  %47 = phi i64 [%33, %$15] ; # C
  %48 = phi i64 [%36, %$15] ; # D
  %49 = phi i64 [0, %$15] ; # ->
; # (int X)
  %50 = lshr i64 %46, 4
; # (add D D)
  %51 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %48, i64 %48)
  %52 = extractvalue {i64, i1} %51, 1
  %53 = extractvalue {i64, i1} %51, 0
; # (when (setq X (+ X X @@)) (loop (inc 'C (hex "10")) (? (=0 (setq ...
; # (+ X X @@)
  %54 = add i64 %50, %50
  %55 = zext i1 %52 to i64
  %56 = add i64 %54, %55
  %57 = icmp ne i64 %56, 0
  br i1 %57, label %$18, label %$19
$18:
  %58 = phi i64 [%56, %$17] ; # X
  %59 = phi i64 [%47, %$17] ; # C
  %60 = phi i64 [%48, %$17] ; # D
; # (loop (inc 'C (hex "10")) (? (=0 (setq X (shr X 8)))))
  br label %$20
$20:
  %61 = phi i64 [%58, %$18], [%67, %$21] ; # X
  %62 = phi i64 [%59, %$18], [%68, %$21] ; # C
  %63 = phi i64 [%60, %$18], [%69, %$21] ; # D
; # (inc 'C (hex "10"))
  %64 = add i64 %62, 16
; # (? (=0 (setq X (shr X 8))))
; # (shr X 8)
  %65 = lshr i64 %61, 8
; # (=0 (setq X (shr X 8)))
  %66 = icmp eq i64 %65, 0
  br i1 %66, label %$22, label %$21
$21:
  %67 = phi i64 [%65, %$20] ; # X
  %68 = phi i64 [%64, %$20] ; # C
  %69 = phi i64 [%63, %$20] ; # D
  br label %$20
$22:
  %70 = phi i64 [%65, %$20] ; # X
  %71 = phi i64 [%64, %$20] ; # C
  %72 = phi i64 [%63, %$20] ; # D
  %73 = phi i64 [0, %$20] ; # ->
  br label %$19
$19:
  %74 = phi i64 [%56, %$17], [%70, %$22] ; # X
  %75 = phi i64 [%47, %$17], [%71, %$22] ; # C
  %76 = phi i64 [%48, %$17], [%72, %$22] ; # D
  br label %$7
$13:
  %77 = phi i64 [%27, %$8] ; # X
; # (pair X)
  %78 = and i64 %77, 15
  %79 = icmp eq i64 %78, 0
  br i1 %79, label %$24, label %$23
$24:
  %80 = phi i64 [%77, %$13] ; # X
; # (size X)
  %81 = call i64 @size(i64 %80)
; # (cnt (size X))
  %82 = shl i64 %81, 4
  %83 = or i64 %82, 2
  br label %$7
$23:
  %84 = phi i64 [%77, %$13] ; # X
; # (nil? X)
  %85 = icmp eq i64 %84, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %85, label %$26, label %$25
$26:
  %86 = phi i64 [%84, %$23] ; # X
  br label %$7
$25:
  %87 = phi i64 [%84, %$23] ; # X
; # (tail X)
  %88 = add i64 %87, -8
; # (val (tail X))
  %89 = inttoptr i64 %88 to i64*
  %90 = load i64, i64* %89
; # (sym? (val (tail X)))
  %91 = and i64 %90, 8
  %92 = icmp ne i64 %91, 0
  br i1 %92, label %$28, label %$27
$28:
  %93 = phi i64 [%87, %$25] ; # X
; # (dbFetch Exe X)
  call void @dbFetch(i64 %0, i64 %93)
; # (let (C (+ (binSize (val X)) (inc BLK)) Y (& (val (tail X)) -9)) ...
; # (val X)
  %94 = inttoptr i64 %93 to i64*
  %95 = load i64, i64* %94
; # (binSize (val X))
  %96 = call i64 @binSize(i64 %95)
; # (inc BLK)
; # (+ (binSize (val X)) (inc BLK))
  %97 = add i64 %96, 7
; # (tail X)
  %98 = add i64 %93, -8
; # (val (tail X))
  %99 = inttoptr i64 %98 to i64*
  %100 = load i64, i64* %99
; # (& (val (tail X)) -9)
  %101 = and i64 %100, -9
; # (while (pair Y) (let Z (++ Y) (setq C (+ C (if (atom Z) (+ (binSi...
  br label %$29
$29:
  %102 = phi i64 [%93, %$28], [%132, %$34] ; # X
  %103 = phi i64 [%97, %$28], [%136, %$34] ; # C
  %104 = phi i64 [%101, %$28], [%134, %$34] ; # Y
; # (pair Y)
  %105 = and i64 %104, 15
  %106 = icmp eq i64 %105, 0
  br i1 %106, label %$30, label %$31
$30:
  %107 = phi i64 [%102, %$29] ; # X
  %108 = phi i64 [%103, %$29] ; # C
  %109 = phi i64 [%104, %$29] ; # Y
; # (let Z (++ Y) (setq C (+ C (if (atom Z) (+ (binSize Z) 2) (+ (bin...
; # (++ Y)
  %110 = inttoptr i64 %109 to i64*
  %111 = load i64, i64* %110
  %112 = getelementptr i64, i64* %110, i32 1
  %113 = load i64, i64* %112
; # (if (atom Z) (+ (binSize Z) 2) (+ (binSize (car Z)) (binSize (cdr...
; # (atom Z)
  %114 = and i64 %111, 15
  %115 = icmp ne i64 %114, 0
  br i1 %115, label %$32, label %$33
$32:
  %116 = phi i64 [%107, %$30] ; # X
  %117 = phi i64 [%108, %$30] ; # C
  %118 = phi i64 [%113, %$30] ; # Y
; # (binSize Z)
  %119 = call i64 @binSize(i64 %111)
; # (+ (binSize Z) 2)
  %120 = add i64 %119, 2
  br label %$34
$33:
  %121 = phi i64 [%107, %$30] ; # X
  %122 = phi i64 [%108, %$30] ; # C
  %123 = phi i64 [%113, %$30] ; # Y
; # (car Z)
  %124 = inttoptr i64 %111 to i64*
  %125 = load i64, i64* %124
; # (binSize (car Z))
  %126 = call i64 @binSize(i64 %125)
; # (cdr Z)
  %127 = inttoptr i64 %111 to i64*
  %128 = getelementptr i64, i64* %127, i32 1
  %129 = load i64, i64* %128
; # (binSize (cdr Z))
  %130 = call i64 @binSize(i64 %129)
; # (+ (binSize (car Z)) (binSize (cdr Z)))
  %131 = add i64 %126, %130
  br label %$34
$34:
  %132 = phi i64 [%116, %$32], [%121, %$33] ; # X
  %133 = phi i64 [%117, %$32], [%122, %$33] ; # C
  %134 = phi i64 [%118, %$32], [%123, %$33] ; # Y
  %135 = phi i64 [%120, %$32], [%131, %$33] ; # ->
; # (+ C (if (atom Z) (+ (binSize Z) 2) (+ (binSize (car Z)) (binSize...
  %136 = add i64 %108, %135
  br label %$29
$31:
  %137 = phi i64 [%102, %$29] ; # X
  %138 = phi i64 [%103, %$29] ; # C
  %139 = phi i64 [%104, %$29] ; # Y
; # (cnt C)
  %140 = shl i64 %138, 4
  %141 = or i64 %140, 2
  br label %$7
$27:
  %142 = phi i64 [%87, %$25] ; # X
; # (name @)
  br label %$35
$35:
  %143 = phi i64 [%90, %$27], [%149, %$36] ; # Tail
  %144 = and i64 %143, 6
  %145 = icmp ne i64 %144, 0
  br i1 %145, label %$37, label %$36
$36:
  %146 = phi i64 [%143, %$35] ; # Tail
  %147 = inttoptr i64 %146 to i64*
  %148 = getelementptr i64, i64* %147, i32 1
  %149 = load i64, i64* %148
  br label %$35
$37:
  %150 = phi i64 [%143, %$35] ; # Tail
; # (== (name @) ZERO)
  %151 = icmp eq i64 %150, 2
  br i1 %151, label %$39, label %$38
$39:
  %152 = phi i64 [%142, %$37] ; # X
  br label %$7
$38:
  %153 = phi i64 [%142, %$37] ; # X
; # (cnt? @)
  %154 = and i64 %150, 2
  %155 = icmp ne i64 %154, 0
  br i1 %155, label %$41, label %$40
$41:
  %156 = phi i64 [%153, %$38] ; # X
; # (let (C ONE Z (int @)) (while (setq Z (shr Z 8)) (inc 'C (hex "10...
; # (int @)
  %157 = lshr i64 %150, 4
; # (while (setq Z (shr Z 8)) (inc 'C (hex "10")))
  br label %$42
$42:
  %158 = phi i64 [%156, %$41], [%163, %$43] ; # X
  %159 = phi i64 [18, %$41], [%166, %$43] ; # C
  %160 = phi i64 [%157, %$41], [%165, %$43] ; # Z
; # (shr Z 8)
  %161 = lshr i64 %160, 8
  %162 = icmp ne i64 %161, 0
  br i1 %162, label %$43, label %$44
$43:
  %163 = phi i64 [%158, %$42] ; # X
  %164 = phi i64 [%159, %$42] ; # C
  %165 = phi i64 [%161, %$42] ; # Z
; # (inc 'C (hex "10"))
  %166 = add i64 %164, 16
  br label %$42
$44:
  %167 = phi i64 [%158, %$42] ; # X
  %168 = phi i64 [%159, %$42] ; # C
  %169 = phi i64 [%161, %$42] ; # Z
  br label %$7
$40:
  %170 = phi i64 [%153, %$38] ; # X
; # (let (C (hex "82") Z @) (until (cnt? (setq Z (val (big Z)))) (inc...
; # (until (cnt? (setq Z (val (big Z)))) (inc 'C (hex "80")))
  br label %$45
$45:
  %171 = phi i64 [%170, %$40], [%179, %$46] ; # X
  %172 = phi i64 [130, %$40], [%182, %$46] ; # C
  %173 = phi i64 [%150, %$40], [%181, %$46] ; # Z
; # (big Z)
  %174 = add i64 %173, 4
; # (val (big Z))
  %175 = inttoptr i64 %174 to i64*
  %176 = load i64, i64* %175
; # (cnt? (setq Z (val (big Z))))
  %177 = and i64 %176, 2
  %178 = icmp ne i64 %177, 0
  br i1 %178, label %$47, label %$46
$46:
  %179 = phi i64 [%171, %$45] ; # X
  %180 = phi i64 [%172, %$45] ; # C
  %181 = phi i64 [%176, %$45] ; # Z
; # (inc 'C (hex "80"))
  %182 = add i64 %180, 128
  br label %$45
$47:
  %183 = phi i64 [%171, %$45] ; # X
  %184 = phi i64 [%172, %$45] ; # C
  %185 = phi i64 [%176, %$45] ; # Z
; # (when (setq Z (int Z)) (loop (inc 'C (hex "10")) (? (=0 (setq Z (...
; # (int Z)
  %186 = lshr i64 %185, 4
  %187 = icmp ne i64 %186, 0
  br i1 %187, label %$48, label %$49
$48:
  %188 = phi i64 [%183, %$47] ; # X
  %189 = phi i64 [%184, %$47] ; # C
  %190 = phi i64 [%186, %$47] ; # Z
; # (loop (inc 'C (hex "10")) (? (=0 (setq Z (shr Z 8)))))
  br label %$50
$50:
  %191 = phi i64 [%188, %$48], [%197, %$51] ; # X
  %192 = phi i64 [%189, %$48], [%198, %$51] ; # C
  %193 = phi i64 [%190, %$48], [%199, %$51] ; # Z
; # (inc 'C (hex "10"))
  %194 = add i64 %192, 16
; # (? (=0 (setq Z (shr Z 8))))
; # (shr Z 8)
  %195 = lshr i64 %193, 8
; # (=0 (setq Z (shr Z 8)))
  %196 = icmp eq i64 %195, 0
  br i1 %196, label %$52, label %$51
$51:
  %197 = phi i64 [%191, %$50] ; # X
  %198 = phi i64 [%194, %$50] ; # C
  %199 = phi i64 [%195, %$50] ; # Z
  br label %$50
$52:
  %200 = phi i64 [%191, %$50] ; # X
  %201 = phi i64 [%194, %$50] ; # C
  %202 = phi i64 [%195, %$50] ; # Z
  %203 = phi i64 [0, %$50] ; # ->
  br label %$49
$49:
  %204 = phi i64 [%183, %$47], [%200, %$52] ; # X
  %205 = phi i64 [%184, %$47], [%201, %$52] ; # C
  %206 = phi i64 [%186, %$47], [%202, %$52] ; # Z
  br label %$7
$7:
  %207 = phi i64 [%25, %$12], [%74, %$19], [%80, %$24], [%86, %$26], [%137, %$31], [%152, %$39], [%167, %$44], [%204, %$49] ; # X
  %208 = phi i64 [%26, %$12], [%75, %$19], [%83, %$24], [2, %$26], [%141, %$31], [%150, %$39], [%168, %$44], [%205, %$49] ; # ->
  ret i64 %208
}

define i64 @_Bytes(i64) align 8 {
$1:
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (binSize (eval (cadr Exe)))
  %14 = call i64 @binSize(i64 %13)
; # (cnt (binSize (eval (cadr Exe))))
  %15 = shl i64 %14, 4
  %16 = or i64 %15, 2
  ret i64 %16
}

define i64 @_Assoc(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (save (eval (++ X))) Z (eval (car X)) H Z) (l...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (save (eval (++ X)))
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %17 = load i64, i64* %16
  %18 = alloca i64, i64 2, align 16
  %19 = ptrtoint i64* %18 to i64
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = add i64 %19, 8
  %22 = inttoptr i64 %21 to i64*
  store i64 %17, i64* %22
  %23 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %19, i64* %23
; # (car X)
  %24 = inttoptr i64 %7 to i64*
  %25 = load i64, i64* %24
; # (eval (car X))
  %26 = and i64 %25, 6
  %27 = icmp ne i64 %26, 0
  br i1 %27, label %$9, label %$8
$9:
  br label %$7
$8:
  %28 = and i64 %25, 8
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %$11, label %$10
$11:
  %30 = inttoptr i64 %25 to i64*
  %31 = load i64, i64* %30
  br label %$7
$10:
  %32 = call i64 @evList(i64 %25)
  br label %$7
$7:
  %33 = phi i64 [%25, %$9], [%31, %$11], [%32, %$10] ; # ->
; # (loop (? (atom Z) $Nil) (let C (car Z) (? (and (pair C) (equal Y ...
  br label %$12
$12:
  %34 = phi i64 [%33, %$7], [%56, %$20] ; # Z
; # (? (atom Z) $Nil)
; # (atom Z)
  %35 = and i64 %34, 15
  %36 = icmp ne i64 %35, 0
  br i1 %36, label %$15, label %$13
$15:
  %37 = phi i64 [%34, %$12] ; # Z
  br label %$14
$13:
  %38 = phi i64 [%34, %$12] ; # Z
; # (let C (car Z) (? (and (pair C) (equal Y (car C))) C))
; # (car Z)
  %39 = inttoptr i64 %38 to i64*
  %40 = load i64, i64* %39
; # (? (and (pair C) (equal Y (car C))) C)
; # (and (pair C) (equal Y (car C)))
; # (pair C)
  %41 = and i64 %40, 15
  %42 = icmp eq i64 %41, 0
  br i1 %42, label %$17, label %$16
$17:
  %43 = phi i64 [%38, %$13] ; # Z
; # (car C)
  %44 = inttoptr i64 %40 to i64*
  %45 = load i64, i64* %44
; # (equal Y (car C))
  %46 = call i1 @equal(i64 %15, i64 %45)
  br label %$16
$16:
  %47 = phi i64 [%38, %$13], [%43, %$17] ; # Z
  %48 = phi i1 [0, %$13], [%46, %$17] ; # ->
  br i1 %48, label %$19, label %$18
$19:
  %49 = phi i64 [%47, %$16] ; # Z
  br label %$14
$18:
  %50 = phi i64 [%47, %$16] ; # Z
; # (? (== H (shift Z)) $Nil)
; # (shift Z)
  %51 = inttoptr i64 %50 to i64*
  %52 = getelementptr i64, i64* %51, i32 1
  %53 = load i64, i64* %52
; # (== H (shift Z))
  %54 = icmp eq i64 %33, %53
  br i1 %54, label %$21, label %$20
$21:
  %55 = phi i64 [%53, %$18] ; # Z
  br label %$14
$20:
  %56 = phi i64 [%53, %$18] ; # Z
  br label %$12
$14:
  %57 = phi i64 [%37, %$15], [%49, %$19], [%55, %$21] ; # Z
  %58 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$15], [%40, %$19], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$21] ; # ->
; # (drop *Safe)
  %59 = inttoptr i64 %19 to i64*
  %60 = getelementptr i64, i64* %59, i32 1
  %61 = load i64, i64* %60
  %62 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %61, i64* %62
  ret i64 %58
}

define i64 @_Rassoc(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (save (eval (++ X))) Z (eval (car X)) H Z) (l...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (save (eval (++ X)))
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %17 = load i64, i64* %16
  %18 = alloca i64, i64 2, align 16
  %19 = ptrtoint i64* %18 to i64
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = add i64 %19, 8
  %22 = inttoptr i64 %21 to i64*
  store i64 %17, i64* %22
  %23 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %19, i64* %23
; # (car X)
  %24 = inttoptr i64 %7 to i64*
  %25 = load i64, i64* %24
; # (eval (car X))
  %26 = and i64 %25, 6
  %27 = icmp ne i64 %26, 0
  br i1 %27, label %$9, label %$8
$9:
  br label %$7
$8:
  %28 = and i64 %25, 8
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %$11, label %$10
$11:
  %30 = inttoptr i64 %25 to i64*
  %31 = load i64, i64* %30
  br label %$7
$10:
  %32 = call i64 @evList(i64 %25)
  br label %$7
$7:
  %33 = phi i64 [%25, %$9], [%31, %$11], [%32, %$10] ; # ->
; # (loop (? (atom Z) $Nil) (let C (car Z) (? (and (pair C) (equal Y ...
  br label %$12
$12:
  %34 = phi i64 [%33, %$7], [%57, %$20] ; # Z
; # (? (atom Z) $Nil)
; # (atom Z)
  %35 = and i64 %34, 15
  %36 = icmp ne i64 %35, 0
  br i1 %36, label %$15, label %$13
$15:
  %37 = phi i64 [%34, %$12] ; # Z
  br label %$14
$13:
  %38 = phi i64 [%34, %$12] ; # Z
; # (let C (car Z) (? (and (pair C) (equal Y (cdr C))) C))
; # (car Z)
  %39 = inttoptr i64 %38 to i64*
  %40 = load i64, i64* %39
; # (? (and (pair C) (equal Y (cdr C))) C)
; # (and (pair C) (equal Y (cdr C)))
; # (pair C)
  %41 = and i64 %40, 15
  %42 = icmp eq i64 %41, 0
  br i1 %42, label %$17, label %$16
$17:
  %43 = phi i64 [%38, %$13] ; # Z
; # (cdr C)
  %44 = inttoptr i64 %40 to i64*
  %45 = getelementptr i64, i64* %44, i32 1
  %46 = load i64, i64* %45
; # (equal Y (cdr C))
  %47 = call i1 @equal(i64 %15, i64 %46)
  br label %$16
$16:
  %48 = phi i64 [%38, %$13], [%43, %$17] ; # Z
  %49 = phi i1 [0, %$13], [%47, %$17] ; # ->
  br i1 %49, label %$19, label %$18
$19:
  %50 = phi i64 [%48, %$16] ; # Z
  br label %$14
$18:
  %51 = phi i64 [%48, %$16] ; # Z
; # (? (== H (shift Z)) $Nil)
; # (shift Z)
  %52 = inttoptr i64 %51 to i64*
  %53 = getelementptr i64, i64* %52, i32 1
  %54 = load i64, i64* %53
; # (== H (shift Z))
  %55 = icmp eq i64 %33, %54
  br i1 %55, label %$21, label %$20
$21:
  %56 = phi i64 [%54, %$18] ; # Z
  br label %$14
$20:
  %57 = phi i64 [%54, %$18] ; # Z
  br label %$12
$14:
  %58 = phi i64 [%37, %$15], [%50, %$19], [%56, %$21] ; # Z
  %59 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$15], [%40, %$19], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$21] ; # ->
; # (drop *Safe)
  %60 = inttoptr i64 %19 to i64*
  %61 = getelementptr i64, i64* %60, i32 1
  %62 = load i64, i64* %61
  %63 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %62, i64* %63
  ret i64 %59
}

define i64 @_Asoq(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (save (eval (++ X))) Z (eval (car X)) H Z) (l...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (save (eval (++ X)))
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %17 = load i64, i64* %16
  %18 = alloca i64, i64 2, align 16
  %19 = ptrtoint i64* %18 to i64
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = add i64 %19, 8
  %22 = inttoptr i64 %21 to i64*
  store i64 %17, i64* %22
  %23 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %19, i64* %23
; # (car X)
  %24 = inttoptr i64 %7 to i64*
  %25 = load i64, i64* %24
; # (eval (car X))
  %26 = and i64 %25, 6
  %27 = icmp ne i64 %26, 0
  br i1 %27, label %$9, label %$8
$9:
  br label %$7
$8:
  %28 = and i64 %25, 8
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %$11, label %$10
$11:
  %30 = inttoptr i64 %25 to i64*
  %31 = load i64, i64* %30
  br label %$7
$10:
  %32 = call i64 @evList(i64 %25)
  br label %$7
$7:
  %33 = phi i64 [%25, %$9], [%31, %$11], [%32, %$10] ; # ->
; # (loop (? (atom Z) $Nil) (let C (car Z) (? (and (pair C) (== Y (ca...
  br label %$12
$12:
  %34 = phi i64 [%33, %$7], [%56, %$20] ; # Z
; # (? (atom Z) $Nil)
; # (atom Z)
  %35 = and i64 %34, 15
  %36 = icmp ne i64 %35, 0
  br i1 %36, label %$15, label %$13
$15:
  %37 = phi i64 [%34, %$12] ; # Z
  br label %$14
$13:
  %38 = phi i64 [%34, %$12] ; # Z
; # (let C (car Z) (? (and (pair C) (== Y (car C))) C))
; # (car Z)
  %39 = inttoptr i64 %38 to i64*
  %40 = load i64, i64* %39
; # (? (and (pair C) (== Y (car C))) C)
; # (and (pair C) (== Y (car C)))
; # (pair C)
  %41 = and i64 %40, 15
  %42 = icmp eq i64 %41, 0
  br i1 %42, label %$17, label %$16
$17:
  %43 = phi i64 [%38, %$13] ; # Z
; # (car C)
  %44 = inttoptr i64 %40 to i64*
  %45 = load i64, i64* %44
; # (== Y (car C))
  %46 = icmp eq i64 %15, %45
  br label %$16
$16:
  %47 = phi i64 [%38, %$13], [%43, %$17] ; # Z
  %48 = phi i1 [0, %$13], [%46, %$17] ; # ->
  br i1 %48, label %$19, label %$18
$19:
  %49 = phi i64 [%47, %$16] ; # Z
  br label %$14
$18:
  %50 = phi i64 [%47, %$16] ; # Z
; # (? (== H (shift Z)) $Nil)
; # (shift Z)
  %51 = inttoptr i64 %50 to i64*
  %52 = getelementptr i64, i64* %51, i32 1
  %53 = load i64, i64* %52
; # (== H (shift Z))
  %54 = icmp eq i64 %33, %53
  br i1 %54, label %$21, label %$20
$21:
  %55 = phi i64 [%53, %$18] ; # Z
  br label %$14
$20:
  %56 = phi i64 [%53, %$18] ; # Z
  br label %$12
$14:
  %57 = phi i64 [%37, %$15], [%49, %$19], [%55, %$21] ; # Z
  %58 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$15], [%40, %$19], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$21] ; # ->
; # (drop *Safe)
  %59 = inttoptr i64 %19 to i64*
  %60 = getelementptr i64, i64* %59, i32 1
  %61 = load i64, i64* %60
  %62 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %61, i64* %62
  ret i64 %58
}

define i64 @_Rasoq(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (save (eval (++ X))) Z (eval (car X)) H Z) (l...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (save (eval (++ X)))
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %17 = load i64, i64* %16
  %18 = alloca i64, i64 2, align 16
  %19 = ptrtoint i64* %18 to i64
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = add i64 %19, 8
  %22 = inttoptr i64 %21 to i64*
  store i64 %17, i64* %22
  %23 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %19, i64* %23
; # (car X)
  %24 = inttoptr i64 %7 to i64*
  %25 = load i64, i64* %24
; # (eval (car X))
  %26 = and i64 %25, 6
  %27 = icmp ne i64 %26, 0
  br i1 %27, label %$9, label %$8
$9:
  br label %$7
$8:
  %28 = and i64 %25, 8
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %$11, label %$10
$11:
  %30 = inttoptr i64 %25 to i64*
  %31 = load i64, i64* %30
  br label %$7
$10:
  %32 = call i64 @evList(i64 %25)
  br label %$7
$7:
  %33 = phi i64 [%25, %$9], [%31, %$11], [%32, %$10] ; # ->
; # (loop (? (atom Z) $Nil) (let C (car Z) (? (and (pair C) (== Y (cd...
  br label %$12
$12:
  %34 = phi i64 [%33, %$7], [%57, %$20] ; # Z
; # (? (atom Z) $Nil)
; # (atom Z)
  %35 = and i64 %34, 15
  %36 = icmp ne i64 %35, 0
  br i1 %36, label %$15, label %$13
$15:
  %37 = phi i64 [%34, %$12] ; # Z
  br label %$14
$13:
  %38 = phi i64 [%34, %$12] ; # Z
; # (let C (car Z) (? (and (pair C) (== Y (cdr C))) C))
; # (car Z)
  %39 = inttoptr i64 %38 to i64*
  %40 = load i64, i64* %39
; # (? (and (pair C) (== Y (cdr C))) C)
; # (and (pair C) (== Y (cdr C)))
; # (pair C)
  %41 = and i64 %40, 15
  %42 = icmp eq i64 %41, 0
  br i1 %42, label %$17, label %$16
$17:
  %43 = phi i64 [%38, %$13] ; # Z
; # (cdr C)
  %44 = inttoptr i64 %40 to i64*
  %45 = getelementptr i64, i64* %44, i32 1
  %46 = load i64, i64* %45
; # (== Y (cdr C))
  %47 = icmp eq i64 %15, %46
  br label %$16
$16:
  %48 = phi i64 [%38, %$13], [%43, %$17] ; # Z
  %49 = phi i1 [0, %$13], [%47, %$17] ; # ->
  br i1 %49, label %$19, label %$18
$19:
  %50 = phi i64 [%48, %$16] ; # Z
  br label %$14
$18:
  %51 = phi i64 [%48, %$16] ; # Z
; # (? (== H (shift Z)) $Nil)
; # (shift Z)
  %52 = inttoptr i64 %51 to i64*
  %53 = getelementptr i64, i64* %52, i32 1
  %54 = load i64, i64* %53
; # (== H (shift Z))
  %55 = icmp eq i64 %33, %54
  br i1 %55, label %$21, label %$20
$21:
  %56 = phi i64 [%54, %$18] ; # Z
  br label %$14
$20:
  %57 = phi i64 [%54, %$18] ; # Z
  br label %$12
$14:
  %58 = phi i64 [%37, %$15], [%50, %$19], [%56, %$21] ; # Z
  %59 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$15], [%40, %$19], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$21] ; # ->
; # (drop *Safe)
  %60 = inttoptr i64 %19 to i64*
  %61 = getelementptr i64, i64* %60, i32 1
  %62 = load i64, i64* %61
  %63 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %62, i64* %63
  ret i64 %59
}

define i64 @_Rank(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (save (eval (++ X))) Z (save (eval (++ X))) R...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (save (eval (++ X)))
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %17 = load i64, i64* %16
  %18 = alloca i64, i64 2, align 16
  %19 = ptrtoint i64* %18 to i64
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = add i64 %19, 8
  %22 = inttoptr i64 %21 to i64*
  store i64 %17, i64* %22
  %23 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %19, i64* %23
; # (++ X)
  %24 = inttoptr i64 %7 to i64*
  %25 = load i64, i64* %24
  %26 = getelementptr i64, i64* %24, i32 1
  %27 = load i64, i64* %26
; # (eval (++ X))
  %28 = and i64 %25, 6
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %$9, label %$8
$9:
  br label %$7
$8:
  %30 = and i64 %25, 8
  %31 = icmp ne i64 %30, 0
  br i1 %31, label %$11, label %$10
$11:
  %32 = inttoptr i64 %25 to i64*
  %33 = load i64, i64* %32
  br label %$7
$10:
  %34 = call i64 @evList(i64 %25)
  br label %$7
$7:
  %35 = phi i64 [%25, %$9], [%33, %$11], [%34, %$10] ; # ->
; # (save (eval (++ X)))
  %36 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %37 = load i64, i64* %36
  %38 = alloca i64, i64 2, align 16
  %39 = ptrtoint i64* %38 to i64
  %40 = inttoptr i64 %39 to i64*
  store i64 %35, i64* %40
  %41 = add i64 %39, 8
  %42 = inttoptr i64 %41 to i64*
  store i64 %37, i64* %42
  %43 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %39, i64* %43
; # (if (nil? (eval (car X))) (until (gt0 (compare (caar Z) Y)) (setq...
; # (car X)
  %44 = inttoptr i64 %27 to i64*
  %45 = load i64, i64* %44
; # (eval (car X))
  %46 = and i64 %45, 6
  %47 = icmp ne i64 %46, 0
  br i1 %47, label %$14, label %$13
$14:
  br label %$12
$13:
  %48 = and i64 %45, 8
  %49 = icmp ne i64 %48, 0
  br i1 %49, label %$16, label %$15
$16:
  %50 = inttoptr i64 %45 to i64*
  %51 = load i64, i64* %50
  br label %$12
$15:
  %52 = call i64 @evList(i64 %45)
  br label %$12
$12:
  %53 = phi i64 [%45, %$14], [%51, %$16], [%52, %$15] ; # ->
; # (nil? (eval (car X)))
  %54 = icmp eq i64 %53, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %54, label %$17, label %$18
$17:
  %55 = phi i64 [%35, %$12] ; # Z
  %56 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$12] ; # R
; # (until (gt0 (compare (caar Z) Y)) (setq R Z) (? (atom (shift Z)))...
  br label %$20
$20:
  %57 = phi i64 [%55, %$17], [%72, %$23] ; # Z
  %58 = phi i64 [%56, %$17], [%73, %$23] ; # R
; # (caar Z)
  %59 = inttoptr i64 %57 to i64*
  %60 = load i64, i64* %59
  %61 = inttoptr i64 %60 to i64*
  %62 = load i64, i64* %61
; # (compare (caar Z) Y)
  %63 = call i64 @compare(i64 %62, i64 %15)
; # (gt0 (compare (caar Z) Y))
  %64 = icmp sgt i64 %63, 0
  br i1 %64, label %$22, label %$21
$21:
  %65 = phi i64 [%57, %$20] ; # Z
  %66 = phi i64 [%58, %$20] ; # R
; # (? (atom (shift Z)))
; # (shift Z)
  %67 = inttoptr i64 %65 to i64*
  %68 = getelementptr i64, i64* %67, i32 1
  %69 = load i64, i64* %68
; # (atom (shift Z))
  %70 = and i64 %69, 15
  %71 = icmp ne i64 %70, 0
  br i1 %71, label %$22, label %$23
$23:
  %72 = phi i64 [%69, %$21] ; # Z
  %73 = phi i64 [%65, %$21] ; # R
  br label %$20
$22:
  %74 = phi i64 [%57, %$20], [%69, %$21] ; # Z
  %75 = phi i64 [%58, %$20], [%65, %$21] ; # R
  br label %$19
$18:
  %76 = phi i64 [%35, %$12] ; # Z
  %77 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$12] ; # R
; # (until (lt0 (compare (caar Z) Y)) (setq R Z) (? (atom (shift Z)))...
  br label %$24
$24:
  %78 = phi i64 [%76, %$18], [%93, %$27] ; # Z
  %79 = phi i64 [%77, %$18], [%94, %$27] ; # R
; # (caar Z)
  %80 = inttoptr i64 %78 to i64*
  %81 = load i64, i64* %80
  %82 = inttoptr i64 %81 to i64*
  %83 = load i64, i64* %82
; # (compare (caar Z) Y)
  %84 = call i64 @compare(i64 %83, i64 %15)
; # (lt0 (compare (caar Z) Y))
  %85 = icmp slt i64 %84, 0
  br i1 %85, label %$26, label %$25
$25:
  %86 = phi i64 [%78, %$24] ; # Z
  %87 = phi i64 [%79, %$24] ; # R
; # (? (atom (shift Z)))
; # (shift Z)
  %88 = inttoptr i64 %86 to i64*
  %89 = getelementptr i64, i64* %88, i32 1
  %90 = load i64, i64* %89
; # (atom (shift Z))
  %91 = and i64 %90, 15
  %92 = icmp ne i64 %91, 0
  br i1 %92, label %$26, label %$27
$27:
  %93 = phi i64 [%90, %$25] ; # Z
  %94 = phi i64 [%86, %$25] ; # R
  br label %$24
$26:
  %95 = phi i64 [%78, %$24], [%90, %$25] ; # Z
  %96 = phi i64 [%79, %$24], [%86, %$25] ; # R
  br label %$19
$19:
  %97 = phi i64 [%74, %$22], [%95, %$26] ; # Z
  %98 = phi i64 [%75, %$22], [%96, %$26] ; # R
; # (car R)
  %99 = inttoptr i64 %98 to i64*
  %100 = load i64, i64* %99
; # (drop *Safe)
  %101 = inttoptr i64 %19 to i64*
  %102 = getelementptr i64, i64* %101, i32 1
  %103 = load i64, i64* %102
  %104 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %103, i64* %104
  ret i64 %100
}

define i1 @match(i64, i64) align 8 {
$1:
; # (loop (? (atom Pat) (if (or (num? Pat) (<> (firstByte Pat) (char ...
  br label %$2
$2:
  %2 = phi i64 [%0, %$1], [%118, %$29] ; # Pat
  %3 = phi i64 [%1, %$1], [%121, %$29] ; # Dat
; # (? (atom Pat) (if (or (num? Pat) (<> (firstByte Pat) (char "@")))...
; # (atom Pat)
  %4 = and i64 %2, 15
  %5 = icmp ne i64 %4, 0
  br i1 %5, label %$5, label %$3
$5:
  %6 = phi i64 [%2, %$2] ; # Pat
  %7 = phi i64 [%3, %$2] ; # Dat
; # (if (or (num? Pat) (<> (firstByte Pat) (char "@"))) (equal Pat Da...
; # (or (num? Pat) (<> (firstByte Pat) (char "@")))
; # (num? Pat)
  %8 = and i64 %6, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$7
$7:
  %10 = phi i64 [%6, %$5] ; # Pat
  %11 = phi i64 [%7, %$5] ; # Dat
; # (firstByte Pat)
  %12 = call i8 @firstByte(i64 %10)
; # (<> (firstByte Pat) (char "@"))
  %13 = icmp ne i8 %12, 64
  br label %$6
$6:
  %14 = phi i64 [%6, %$5], [%10, %$7] ; # Pat
  %15 = phi i64 [%7, %$5], [%11, %$7] ; # Dat
  %16 = phi i1 [1, %$5], [%13, %$7] ; # ->
  br i1 %16, label %$8, label %$9
$8:
  %17 = phi i64 [%14, %$6] ; # Pat
  %18 = phi i64 [%15, %$6] ; # Dat
; # (equal Pat Dat)
  %19 = call i1 @equal(i64 %17, i64 %18)
  br label %$10
$9:
  %20 = phi i64 [%14, %$6] ; # Pat
  %21 = phi i64 [%15, %$6] ; # Dat
; # (set Pat Dat)
  %22 = inttoptr i64 %20 to i64*
  store i64 %21, i64* %22
  br label %$10
$10:
  %23 = phi i64 [%17, %$8], [%20, %$9] ; # Pat
  %24 = phi i64 [%18, %$8], [%21, %$9] ; # Dat
  %25 = phi i1 [%19, %$8], [1, %$9] ; # ->
  br label %$4
$3:
  %26 = phi i64 [%2, %$2] ; # Pat
  %27 = phi i64 [%3, %$2] ; # Dat
; # (stkChk 0)
  %28 = load i8*, i8** @$StkLimit
  %29 = call i8* @llvm.stacksave()
  %30 = icmp ugt i8* %28, %29
  br i1 %30, label %$11, label %$12
$11:
  call void @stkErr(i64 0)
  unreachable
$12:
; # (let X (car Pat) (when (and (symb? X) (== (firstByte X) (char "@"...
; # (car Pat)
  %31 = inttoptr i64 %26 to i64*
  %32 = load i64, i64* %31
; # (when (and (symb? X) (== (firstByte X) (char "@"))) (? (atom Dat)...
; # (and (symb? X) (== (firstByte X) (char "@")))
; # (symb? X)
  %33 = xor i64 %32, 8
  %34 = and i64 %33, 14
  %35 = icmp eq i64 %34, 0
  br i1 %35, label %$14, label %$13
$14:
  %36 = phi i64 [%26, %$12] ; # Pat
  %37 = phi i64 [%27, %$12] ; # Dat
; # (firstByte X)
  %38 = call i8 @firstByte(i64 %32)
; # (== (firstByte X) (char "@"))
  %39 = icmp eq i8 %38, 64
  br label %$13
$13:
  %40 = phi i64 [%26, %$12], [%36, %$14] ; # Pat
  %41 = phi i64 [%27, %$12], [%37, %$14] ; # Dat
  %42 = phi i1 [0, %$12], [%39, %$14] ; # ->
  br i1 %42, label %$15, label %$16
$15:
  %43 = phi i64 [%40, %$13] ; # Pat
  %44 = phi i64 [%41, %$13] ; # Dat
; # (? (atom Dat) (and (equal (cdr Pat) Dat) (prog (set X $Nil) YES))...
; # (atom Dat)
  %45 = and i64 %44, 15
  %46 = icmp ne i64 %45, 0
  br i1 %46, label %$18, label %$17
$18:
  %47 = phi i64 [%43, %$15] ; # Pat
  %48 = phi i64 [%44, %$15] ; # Dat
; # (and (equal (cdr Pat) Dat) (prog (set X $Nil) YES))
; # (cdr Pat)
  %49 = inttoptr i64 %47 to i64*
  %50 = getelementptr i64, i64* %49, i32 1
  %51 = load i64, i64* %50
; # (equal (cdr Pat) Dat)
  %52 = call i1 @equal(i64 %51, i64 %48)
  br i1 %52, label %$20, label %$19
$20:
  %53 = phi i64 [%47, %$18] ; # Pat
  %54 = phi i64 [%48, %$18] ; # Dat
; # (set X $Nil)
  %55 = inttoptr i64 %32 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %55
  br label %$19
$19:
  %56 = phi i64 [%47, %$18], [%53, %$20] ; # Pat
  %57 = phi i64 [%48, %$18], [%54, %$20] ; # Dat
  %58 = phi i1 [0, %$18], [1, %$20] ; # ->
  br label %$4
$17:
  %59 = phi i64 [%43, %$15] ; # Pat
  %60 = phi i64 [%44, %$15] ; # Dat
; # (? (match (cdr Pat) (cdr Dat)) (set X (cons (car Dat) $Nil)) YES)...
; # (cdr Pat)
  %61 = inttoptr i64 %59 to i64*
  %62 = getelementptr i64, i64* %61, i32 1
  %63 = load i64, i64* %62
; # (cdr Dat)
  %64 = inttoptr i64 %60 to i64*
  %65 = getelementptr i64, i64* %64, i32 1
  %66 = load i64, i64* %65
; # (match (cdr Pat) (cdr Dat))
  %67 = call i1 @match(i64 %63, i64 %66)
  br i1 %67, label %$22, label %$21
$22:
  %68 = phi i64 [%59, %$17] ; # Pat
  %69 = phi i64 [%60, %$17] ; # Dat
; # (set X (cons (car Dat) $Nil))
; # (car Dat)
  %70 = inttoptr i64 %69 to i64*
  %71 = load i64, i64* %70
; # (cons (car Dat) $Nil)
  %72 = call i64 @cons(i64 %71, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %73 = inttoptr i64 %32 to i64*
  store i64 %72, i64* %73
  br label %$4
$21:
  %74 = phi i64 [%59, %$17] ; # Pat
  %75 = phi i64 [%60, %$17] ; # Dat
; # (? (match (cdr Pat) Dat) (set X $Nil) YES)
; # (cdr Pat)
  %76 = inttoptr i64 %74 to i64*
  %77 = getelementptr i64, i64* %76, i32 1
  %78 = load i64, i64* %77
; # (match (cdr Pat) Dat)
  %79 = call i1 @match(i64 %78, i64 %75)
  br i1 %79, label %$24, label %$23
$24:
  %80 = phi i64 [%74, %$21] ; # Pat
  %81 = phi i64 [%75, %$21] ; # Dat
; # (set X $Nil)
  %82 = inttoptr i64 %32 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %82
  br label %$4
$23:
  %83 = phi i64 [%74, %$21] ; # Pat
  %84 = phi i64 [%75, %$21] ; # Dat
; # (? (match Pat (cdr Dat)) (set X (cons (car Dat) (val X))) YES)
; # (cdr Dat)
  %85 = inttoptr i64 %84 to i64*
  %86 = getelementptr i64, i64* %85, i32 1
  %87 = load i64, i64* %86
; # (match Pat (cdr Dat))
  %88 = call i1 @match(i64 %83, i64 %87)
  br i1 %88, label %$26, label %$25
$26:
  %89 = phi i64 [%83, %$23] ; # Pat
  %90 = phi i64 [%84, %$23] ; # Dat
; # (set X (cons (car Dat) (val X)))
; # (car Dat)
  %91 = inttoptr i64 %90 to i64*
  %92 = load i64, i64* %91
; # (val X)
  %93 = inttoptr i64 %32 to i64*
  %94 = load i64, i64* %93
; # (cons (car Dat) (val X))
  %95 = call i64 @cons(i64 %92, i64 %94)
  %96 = inttoptr i64 %32 to i64*
  store i64 %95, i64* %96
  br label %$4
$25:
  %97 = phi i64 [%83, %$23] ; # Pat
  %98 = phi i64 [%84, %$23] ; # Dat
  br label %$16
$16:
  %99 = phi i64 [%40, %$13], [%97, %$25] ; # Pat
  %100 = phi i64 [%41, %$13], [%98, %$25] ; # Dat
; # (? (or (atom Dat) (not (match X (car Dat)))) NO)
; # (or (atom Dat) (not (match X (car Dat))))
; # (atom Dat)
  %101 = and i64 %100, 15
  %102 = icmp ne i64 %101, 0
  br i1 %102, label %$27, label %$28
$28:
  %103 = phi i64 [%99, %$16] ; # Pat
  %104 = phi i64 [%100, %$16] ; # Dat
; # (car Dat)
  %105 = inttoptr i64 %104 to i64*
  %106 = load i64, i64* %105
; # (match X (car Dat))
  %107 = call i1 @match(i64 %32, i64 %106)
; # (not (match X (car Dat)))
  %108 = icmp eq i1 %107, 0
  br label %$27
$27:
  %109 = phi i64 [%99, %$16], [%103, %$28] ; # Pat
  %110 = phi i64 [%100, %$16], [%104, %$28] ; # Dat
  %111 = phi i1 [1, %$16], [%108, %$28] ; # ->
  br i1 %111, label %$30, label %$29
$30:
  %112 = phi i64 [%109, %$27] ; # Pat
  %113 = phi i64 [%110, %$27] ; # Dat
  br label %$4
$29:
  %114 = phi i64 [%109, %$27] ; # Pat
  %115 = phi i64 [%110, %$27] ; # Dat
; # (shift Pat)
  %116 = inttoptr i64 %114 to i64*
  %117 = getelementptr i64, i64* %116, i32 1
  %118 = load i64, i64* %117
; # (shift Dat)
  %119 = inttoptr i64 %115 to i64*
  %120 = getelementptr i64, i64* %119, i32 1
  %121 = load i64, i64* %120
  br label %$2
$4:
  %122 = phi i64 [%23, %$10], [%56, %$19], [%68, %$22], [%80, %$24], [%89, %$26], [%112, %$30] ; # Pat
  %123 = phi i64 [%24, %$10], [%57, %$19], [%69, %$22], [%81, %$24], [%90, %$26], [%113, %$30] ; # Dat
  %124 = phi i1 [%25, %$10], [%58, %$19], [1, %$22], [1, %$24], [1, %$26], [0, %$30] ; # ->
  ret i1 %124
}

define i64 @_Match(i64) align 8 {
$1:
; # (let X (cdr Exe) (if (match (save (eval (++ X))) (save (eval (car...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (if (match (save (eval (++ X))) (save (eval (car X)))) $T $Nil)
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (save (eval (++ X)))
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %17 = load i64, i64* %16
  %18 = alloca i64, i64 2, align 16
  %19 = ptrtoint i64* %18 to i64
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = add i64 %19, 8
  %22 = inttoptr i64 %21 to i64*
  store i64 %17, i64* %22
  %23 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %19, i64* %23
; # (car X)
  %24 = inttoptr i64 %7 to i64*
  %25 = load i64, i64* %24
; # (eval (car X))
  %26 = and i64 %25, 6
  %27 = icmp ne i64 %26, 0
  br i1 %27, label %$9, label %$8
$9:
  br label %$7
$8:
  %28 = and i64 %25, 8
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %$11, label %$10
$11:
  %30 = inttoptr i64 %25 to i64*
  %31 = load i64, i64* %30
  br label %$7
$10:
  %32 = call i64 @evList(i64 %25)
  br label %$7
$7:
  %33 = phi i64 [%25, %$9], [%31, %$11], [%32, %$10] ; # ->
; # (save (eval (car X)))
  %34 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %35 = load i64, i64* %34
  %36 = alloca i64, i64 2, align 16
  %37 = ptrtoint i64* %36 to i64
  %38 = inttoptr i64 %37 to i64*
  store i64 %33, i64* %38
  %39 = add i64 %37, 8
  %40 = inttoptr i64 %39 to i64*
  store i64 %35, i64* %40
  %41 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %37, i64* %41
; # (match (save (eval (++ X))) (save (eval (car X))))
  %42 = call i1 @match(i64 %15, i64 %33)
  br i1 %42, label %$12, label %$13
$12:
  %43 = phi i64 [%7, %$7] ; # X
  br label %$14
$13:
  %44 = phi i64 [%7, %$7] ; # X
  br label %$14
$14:
  %45 = phi i64 [%43, %$12], [%44, %$13] ; # X
  %46 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$12], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$13] ; # ->
; # (drop *Safe)
  %47 = inttoptr i64 %19 to i64*
  %48 = getelementptr i64, i64* %47, i32 1
  %49 = load i64, i64* %48
  %50 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %49, i64* %50
  ret i64 %46
}

define i64 @fill2(i64, i64) align 8 {
$1:
; # (cond ((num? X) 0) ((sym? X) (let V (val X) (cond ((== X V) 0) ((...
; # (num? X)
  %2 = and i64 %0, 6
  %3 = icmp ne i64 %2, 0
  br i1 %3, label %$4, label %$3
$4:
  %4 = phi i64 [%0, %$1] ; # X
  br label %$2
$3:
  %5 = phi i64 [%0, %$1] ; # X
; # (sym? X)
  %6 = and i64 %5, 8
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$6, label %$5
$6:
  %8 = phi i64 [%5, %$3] ; # X
; # (let V (val X) (cond ((== X V) 0) ((nil? Y) (cond ((== X $At) 0) ...
; # (val X)
  %9 = inttoptr i64 %8 to i64*
  %10 = load i64, i64* %9
; # (cond ((== X V) 0) ((nil? Y) (cond ((== X $At) 0) ((== (firstByte...
; # (== X V)
  %11 = icmp eq i64 %8, %10
  br i1 %11, label %$9, label %$8
$9:
  %12 = phi i64 [%8, %$6] ; # X
  br label %$7
$8:
  %13 = phi i64 [%8, %$6] ; # X
; # (nil? Y)
  %14 = icmp eq i64 %1, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %14, label %$11, label %$10
$11:
  %15 = phi i64 [%13, %$8] ; # X
; # (cond ((== X $At) 0) ((== (firstByte X) (char "@")) V) (T 0))
; # (== X $At)
  %16 = icmp eq i64 %15, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64)
  br i1 %16, label %$14, label %$13
$14:
  %17 = phi i64 [%15, %$11] ; # X
  br label %$12
$13:
  %18 = phi i64 [%15, %$11] ; # X
; # (firstByte X)
  %19 = call i8 @firstByte(i64 %18)
; # (== (firstByte X) (char "@"))
  %20 = icmp eq i8 %19, 64
  br i1 %20, label %$16, label %$15
$16:
  %21 = phi i64 [%18, %$13] ; # X
  br label %$12
$15:
  %22 = phi i64 [%18, %$13] ; # X
  br label %$12
$12:
  %23 = phi i64 [%17, %$14], [%21, %$16], [%22, %$15] ; # X
  %24 = phi i64 [0, %$14], [%10, %$16], [0, %$15] ; # ->
  br label %$7
$10:
  %25 = phi i64 [%13, %$8] ; # X
; # (or (== X Y) (memq X Y))
; # (== X Y)
  %26 = icmp eq i64 %25, %1
  br i1 %26, label %$17, label %$18
$18:
  %27 = phi i64 [%25, %$10] ; # X
; # (memq X Y)
  br label %$19
$19:
  %28 = phi i64 [%1, %$18], [%40, %$23] ; # L
  %29 = and i64 %28, 15
  %30 = icmp ne i64 %29, 0
  br i1 %30, label %$22, label %$20
$22:
  %31 = phi i64 [%28, %$19] ; # L
  br label %$21
$20:
  %32 = phi i64 [%28, %$19] ; # L
  %33 = inttoptr i64 %32 to i64*
  %34 = load i64, i64* %33
  %35 = icmp eq i64 %27, %34
  br i1 %35, label %$24, label %$23
$24:
  %36 = phi i64 [%32, %$20] ; # L
  br label %$21
$23:
  %37 = phi i64 [%32, %$20] ; # L
  %38 = inttoptr i64 %37 to i64*
  %39 = getelementptr i64, i64* %38, i32 1
  %40 = load i64, i64* %39
  br label %$19
$21:
  %41 = phi i64 [%31, %$22], [%36, %$24] ; # L
  %42 = phi i1 [0, %$22], [1, %$24] ; # ->
  br label %$17
$17:
  %43 = phi i64 [%25, %$10], [%27, %$21] ; # X
  %44 = phi i1 [1, %$10], [%42, %$21] ; # ->
  br i1 %44, label %$26, label %$25
$26:
  %45 = phi i64 [%43, %$17] ; # X
  br label %$7
$25:
  %46 = phi i64 [%43, %$17] ; # X
  br label %$7
$7:
  %47 = phi i64 [%12, %$9], [%23, %$12], [%45, %$26], [%46, %$25] ; # X
  %48 = phi i64 [0, %$9], [%24, %$12], [%10, %$26], [0, %$25] ; # ->
  br label %$2
$5:
  %49 = phi i64 [%5, %$3] ; # X
; # (stkChk 0)
  %50 = load i8*, i8** @$StkLimit
  %51 = call i8* @llvm.stacksave()
  %52 = icmp ugt i8* %50, %51
  br i1 %52, label %$27, label %$28
$27:
  call void @stkErr(i64 0)
  unreachable
$28:
; # (let Z (++ X) (if (== Z $Up) (let V (eval (++ X)) (if (nil? V) (i...
; # (++ X)
  %53 = inttoptr i64 %49 to i64*
  %54 = load i64, i64* %53
  %55 = getelementptr i64, i64* %53, i32 1
  %56 = load i64, i64* %55
; # (if (== Z $Up) (let V (eval (++ X)) (if (nil? V) (if (fill2 X Y) ...
; # (== Z $Up)
  %57 = icmp eq i64 %54, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 728) to i64)
  br i1 %57, label %$29, label %$30
$29:
  %58 = phi i64 [%56, %$28] ; # X
  %59 = phi i64 [%54, %$28] ; # Z
; # (let V (eval (++ X)) (if (nil? V) (if (fill2 X Y) @ X) (save (set...
; # (++ X)
  %60 = inttoptr i64 %58 to i64*
  %61 = load i64, i64* %60
  %62 = getelementptr i64, i64* %60, i32 1
  %63 = load i64, i64* %62
; # (eval (++ X))
  %64 = and i64 %61, 6
  %65 = icmp ne i64 %64, 0
  br i1 %65, label %$34, label %$33
$34:
  br label %$32
$33:
  %66 = and i64 %61, 8
  %67 = icmp ne i64 %66, 0
  br i1 %67, label %$36, label %$35
$36:
  %68 = inttoptr i64 %61 to i64*
  %69 = load i64, i64* %68
  br label %$32
$35:
  %70 = call i64 @evList(i64 %61)
  br label %$32
$32:
  %71 = phi i64 [%61, %$34], [%69, %$36], [%70, %$35] ; # ->
; # (if (nil? V) (if (fill2 X Y) @ X) (save (setq Z V) (if (atom V) (...
; # (nil? V)
  %72 = icmp eq i64 %71, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %72, label %$37, label %$38
$37:
  %73 = phi i64 [%63, %$32] ; # X
  %74 = phi i64 [%59, %$32] ; # Z
  %75 = phi i64 [%71, %$32] ; # V
; # (if (fill2 X Y) @ X)
; # (fill2 X Y)
  %76 = call i64 @fill2(i64 %73, i64 %1)
  %77 = icmp ne i64 %76, 0
  br i1 %77, label %$40, label %$41
$40:
  %78 = phi i64 [%73, %$37] ; # X
  %79 = phi i64 [%74, %$37] ; # Z
  %80 = phi i64 [%75, %$37] ; # V
  br label %$42
$41:
  %81 = phi i64 [%73, %$37] ; # X
  %82 = phi i64 [%74, %$37] ; # Z
  %83 = phi i64 [%75, %$37] ; # V
  br label %$42
$42:
  %84 = phi i64 [%78, %$40], [%81, %$41] ; # X
  %85 = phi i64 [%79, %$40], [%82, %$41] ; # Z
  %86 = phi i64 [%80, %$40], [%83, %$41] ; # V
  %87 = phi i64 [%76, %$40], [%81, %$41] ; # ->
  br label %$39
$38:
  %88 = phi i64 [%63, %$32] ; # X
  %89 = phi i64 [%59, %$32] ; # Z
  %90 = phi i64 [%71, %$32] ; # V
; # (save (setq Z V) (if (atom V) (safe (setq Z (setq V (cons V $Nil)...
  %91 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %92 = load i64, i64* %91
  %93 = alloca i64, i64 2, align 16
  %94 = ptrtoint i64* %93 to i64
  %95 = inttoptr i64 %94 to i64*
  store i64 %90, i64* %95
  %96 = add i64 %94, 8
  %97 = inttoptr i64 %96 to i64*
  store i64 %92, i64* %97
  %98 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %94, i64* %98
; # (if (atom V) (safe (setq Z (setq V (cons V $Nil)))) (while (pair ...
; # (atom V)
  %99 = and i64 %90, 15
  %100 = icmp ne i64 %99, 0
  br i1 %100, label %$43, label %$44
$43:
  %101 = phi i64 [%88, %$38] ; # X
  %102 = phi i64 [%90, %$38] ; # Z
  %103 = phi i64 [%90, %$38] ; # V
; # (cons V $Nil)
  %104 = call i64 @cons(i64 %103, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (safe (setq Z (setq V (cons V $Nil))))
  %105 = inttoptr i64 %94 to i64*
  store i64 %104, i64* %105
  br label %$45
$44:
  %106 = phi i64 [%88, %$38] ; # X
  %107 = phi i64 [%90, %$38] ; # Z
  %108 = phi i64 [%90, %$38] ; # V
; # (while (pair (cdr V)) (setq V @))
  br label %$46
$46:
  %109 = phi i64 [%106, %$44], [%117, %$47] ; # X
  %110 = phi i64 [%107, %$44], [%118, %$47] ; # Z
  %111 = phi i64 [%108, %$44], [%114, %$47] ; # V
; # (cdr V)
  %112 = inttoptr i64 %111 to i64*
  %113 = getelementptr i64, i64* %112, i32 1
  %114 = load i64, i64* %113
; # (pair (cdr V))
  %115 = and i64 %114, 15
  %116 = icmp eq i64 %115, 0
  br i1 %116, label %$47, label %$48
$47:
  %117 = phi i64 [%109, %$46] ; # X
  %118 = phi i64 [%110, %$46] ; # Z
  %119 = phi i64 [%111, %$46] ; # V
  br label %$46
$48:
  %120 = phi i64 [%109, %$46] ; # X
  %121 = phi i64 [%110, %$46] ; # Z
  %122 = phi i64 [%111, %$46] ; # V
  br label %$45
$45:
  %123 = phi i64 [%101, %$43], [%120, %$48] ; # X
  %124 = phi i64 [%104, %$43], [%121, %$48] ; # Z
  %125 = phi i64 [%104, %$43], [%122, %$48] ; # V
; # (set 2 V (if (fill2 X Y) @ X))
; # (if (fill2 X Y) @ X)
; # (fill2 X Y)
  %126 = call i64 @fill2(i64 %123, i64 %1)
  %127 = icmp ne i64 %126, 0
  br i1 %127, label %$49, label %$50
$49:
  %128 = phi i64 [%123, %$45] ; # X
  %129 = phi i64 [%124, %$45] ; # Z
  %130 = phi i64 [%125, %$45] ; # V
  br label %$51
$50:
  %131 = phi i64 [%123, %$45] ; # X
  %132 = phi i64 [%124, %$45] ; # Z
  %133 = phi i64 [%125, %$45] ; # V
  br label %$51
$51:
  %134 = phi i64 [%128, %$49], [%131, %$50] ; # X
  %135 = phi i64 [%129, %$49], [%132, %$50] ; # Z
  %136 = phi i64 [%130, %$49], [%133, %$50] ; # V
  %137 = phi i64 [%126, %$49], [%131, %$50] ; # ->
  %138 = inttoptr i64 %125 to i64*
  %139 = getelementptr i64, i64* %138, i32 1
  store i64 %137, i64* %139
; # drop
  %140 = inttoptr i64 %94 to i64*
  %141 = getelementptr i64, i64* %140, i32 1
  %142 = load i64, i64* %141
  %143 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %142, i64* %143
  br label %$39
$39:
  %144 = phi i64 [%84, %$42], [%134, %$51] ; # X
  %145 = phi i64 [%85, %$42], [%135, %$51] ; # Z
  %146 = phi i64 [%86, %$42], [%136, %$51] ; # V
  %147 = phi i64 [%87, %$42], [%135, %$51] ; # ->
  br label %$31
$30:
  %148 = phi i64 [%56, %$28] ; # X
  %149 = phi i64 [%54, %$28] ; # Z
; # (cond ((fill2 Z Y) (save @ (cons @ (if (fill2 X Y) @ X)))) ((fill...
; # (fill2 Z Y)
  %150 = call i64 @fill2(i64 %149, i64 %1)
  %151 = icmp ne i64 %150, 0
  br i1 %151, label %$54, label %$53
$54:
  %152 = phi i64 [%148, %$30] ; # X
  %153 = phi i64 [%149, %$30] ; # Z
; # (save @ (cons @ (if (fill2 X Y) @ X)))
  %154 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %155 = load i64, i64* %154
  %156 = alloca i64, i64 2, align 16
  %157 = ptrtoint i64* %156 to i64
  %158 = inttoptr i64 %157 to i64*
  store i64 %150, i64* %158
  %159 = add i64 %157, 8
  %160 = inttoptr i64 %159 to i64*
  store i64 %155, i64* %160
  %161 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %157, i64* %161
; # (if (fill2 X Y) @ X)
; # (fill2 X Y)
  %162 = call i64 @fill2(i64 %152, i64 %1)
  %163 = icmp ne i64 %162, 0
  br i1 %163, label %$55, label %$56
$55:
  %164 = phi i64 [%152, %$54] ; # X
  %165 = phi i64 [%153, %$54] ; # Z
  br label %$57
$56:
  %166 = phi i64 [%152, %$54] ; # X
  %167 = phi i64 [%153, %$54] ; # Z
  br label %$57
$57:
  %168 = phi i64 [%164, %$55], [%166, %$56] ; # X
  %169 = phi i64 [%165, %$55], [%167, %$56] ; # Z
  %170 = phi i64 [%162, %$55], [%166, %$56] ; # ->
; # (cons @ (if (fill2 X Y) @ X))
  %171 = call i64 @cons(i64 %150, i64 %170)
; # drop
  %172 = inttoptr i64 %157 to i64*
  %173 = getelementptr i64, i64* %172, i32 1
  %174 = load i64, i64* %173
  %175 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %174, i64* %175
  br label %$52
$53:
  %176 = phi i64 [%148, %$30] ; # X
  %177 = phi i64 [%149, %$30] ; # Z
; # (fill2 X Y)
  %178 = call i64 @fill2(i64 %176, i64 %1)
  %179 = icmp ne i64 %178, 0
  br i1 %179, label %$59, label %$58
$59:
  %180 = phi i64 [%176, %$53] ; # X
  %181 = phi i64 [%177, %$53] ; # Z
; # (cons Z @)
  %182 = call i64 @cons(i64 %181, i64 %178)
  br label %$52
$58:
  %183 = phi i64 [%176, %$53] ; # X
  %184 = phi i64 [%177, %$53] ; # Z
  br label %$52
$52:
  %185 = phi i64 [%168, %$57], [%180, %$59], [%183, %$58] ; # X
  %186 = phi i64 [%169, %$57], [%181, %$59], [%184, %$58] ; # Z
  %187 = phi i64 [%171, %$57], [%182, %$59], [0, %$58] ; # ->
  br label %$31
$31:
  %188 = phi i64 [%144, %$39], [%185, %$52] ; # X
  %189 = phi i64 [%145, %$39], [%186, %$52] ; # Z
  %190 = phi i64 [%147, %$39], [%187, %$52] ; # ->
  br label %$2
$2:
  %191 = phi i64 [%4, %$4], [%47, %$7], [%188, %$31] ; # X
  %192 = phi i64 [0, %$4], [%48, %$7], [%190, %$31] ; # ->
  ret i64 %192
}

define i64 @fill3(i64, i64, i64) align 8 {
$1:
; # (if (atom X) (if (== X Y) Z 0) (stkChk 0) (let A (++ X) (cond ((f...
; # (atom X)
  %3 = and i64 %0, 15
  %4 = icmp ne i64 %3, 0
  br i1 %4, label %$2, label %$3
$2:
  %5 = phi i64 [%0, %$1] ; # X
; # (if (== X Y) Z 0)
; # (== X Y)
  %6 = icmp eq i64 %5, %1
  br i1 %6, label %$5, label %$6
$5:
  %7 = phi i64 [%5, %$2] ; # X
  br label %$7
$6:
  %8 = phi i64 [%5, %$2] ; # X
  br label %$7
$7:
  %9 = phi i64 [%7, %$5], [%8, %$6] ; # X
  %10 = phi i64 [%2, %$5], [0, %$6] ; # ->
  br label %$4
$3:
  %11 = phi i64 [%0, %$1] ; # X
; # (stkChk 0)
  %12 = load i8*, i8** @$StkLimit
  %13 = call i8* @llvm.stacksave()
  %14 = icmp ugt i8* %12, %13
  br i1 %14, label %$8, label %$9
$8:
  call void @stkErr(i64 0)
  unreachable
$9:
; # (let A (++ X) (cond ((fill3 A Y Z) (save @ (cons @ (if (fill3 X Y...
; # (++ X)
  %15 = inttoptr i64 %11 to i64*
  %16 = load i64, i64* %15
  %17 = getelementptr i64, i64* %15, i32 1
  %18 = load i64, i64* %17
; # (cond ((fill3 A Y Z) (save @ (cons @ (if (fill3 X Y Z) @ X)))) ((...
; # (fill3 A Y Z)
  %19 = call i64 @fill3(i64 %16, i64 %1, i64 %2)
  %20 = icmp ne i64 %19, 0
  br i1 %20, label %$12, label %$11
$12:
  %21 = phi i64 [%18, %$9] ; # X
; # (save @ (cons @ (if (fill3 X Y Z) @ X)))
  %22 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %23 = load i64, i64* %22
  %24 = alloca i64, i64 2, align 16
  %25 = ptrtoint i64* %24 to i64
  %26 = inttoptr i64 %25 to i64*
  store i64 %19, i64* %26
  %27 = add i64 %25, 8
  %28 = inttoptr i64 %27 to i64*
  store i64 %23, i64* %28
  %29 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %25, i64* %29
; # (if (fill3 X Y Z) @ X)
; # (fill3 X Y Z)
  %30 = call i64 @fill3(i64 %21, i64 %1, i64 %2)
  %31 = icmp ne i64 %30, 0
  br i1 %31, label %$13, label %$14
$13:
  %32 = phi i64 [%21, %$12] ; # X
  br label %$15
$14:
  %33 = phi i64 [%21, %$12] ; # X
  br label %$15
$15:
  %34 = phi i64 [%32, %$13], [%33, %$14] ; # X
  %35 = phi i64 [%30, %$13], [%33, %$14] ; # ->
; # (cons @ (if (fill3 X Y Z) @ X))
  %36 = call i64 @cons(i64 %19, i64 %35)
; # drop
  %37 = inttoptr i64 %25 to i64*
  %38 = getelementptr i64, i64* %37, i32 1
  %39 = load i64, i64* %38
  %40 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %39, i64* %40
  br label %$10
$11:
  %41 = phi i64 [%18, %$9] ; # X
; # (fill3 X Y Z)
  %42 = call i64 @fill3(i64 %41, i64 %1, i64 %2)
  %43 = icmp ne i64 %42, 0
  br i1 %43, label %$17, label %$16
$17:
  %44 = phi i64 [%41, %$11] ; # X
; # (cons A @)
  %45 = call i64 @cons(i64 %16, i64 %42)
  br label %$10
$16:
  %46 = phi i64 [%41, %$11] ; # X
  br label %$10
$10:
  %47 = phi i64 [%34, %$15], [%44, %$17], [%46, %$16] ; # X
  %48 = phi i64 [%36, %$15], [%45, %$17], [0, %$16] ; # ->
  br label %$4
$4:
  %49 = phi i64 [%9, %$7], [%47, %$10] ; # X
  %50 = phi i64 [%10, %$7], [%48, %$10] ; # ->
  ret i64 %50
}

define i64 @_Fill(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (save (eval (++ X))) Z (save (eval (++ X)))) ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (save (eval (++ X)))
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %17 = load i64, i64* %16
  %18 = alloca i64, i64 2, align 16
  %19 = ptrtoint i64* %18 to i64
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = add i64 %19, 8
  %22 = inttoptr i64 %21 to i64*
  store i64 %17, i64* %22
  %23 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %19, i64* %23
; # (++ X)
  %24 = inttoptr i64 %7 to i64*
  %25 = load i64, i64* %24
  %26 = getelementptr i64, i64* %24, i32 1
  %27 = load i64, i64* %26
; # (eval (++ X))
  %28 = and i64 %25, 6
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %$9, label %$8
$9:
  br label %$7
$8:
  %30 = and i64 %25, 8
  %31 = icmp ne i64 %30, 0
  br i1 %31, label %$11, label %$10
$11:
  %32 = inttoptr i64 %25 to i64*
  %33 = load i64, i64* %32
  br label %$7
$10:
  %34 = call i64 @evList(i64 %25)
  br label %$7
$7:
  %35 = phi i64 [%25, %$9], [%33, %$11], [%34, %$10] ; # ->
; # (save (eval (++ X)))
  %36 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %37 = load i64, i64* %36
  %38 = alloca i64, i64 2, align 16
  %39 = ptrtoint i64* %38 to i64
  %40 = inttoptr i64 %39 to i64*
  store i64 %35, i64* %40
  %41 = add i64 %39, 8
  %42 = inttoptr i64 %41 to i64*
  store i64 %37, i64* %42
  %43 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %39, i64* %43
; # (if (if (pair X) (fill3 Y Z (save (eval (car X)))) (fill2 Y Z)) @...
; # (if (pair X) (fill3 Y Z (save (eval (car X)))) (fill2 Y Z))
; # (pair X)
  %44 = and i64 %27, 15
  %45 = icmp eq i64 %44, 0
  br i1 %45, label %$12, label %$13
$12:
; # (car X)
  %46 = inttoptr i64 %27 to i64*
  %47 = load i64, i64* %46
; # (eval (car X))
  %48 = and i64 %47, 6
  %49 = icmp ne i64 %48, 0
  br i1 %49, label %$17, label %$16
$17:
  br label %$15
$16:
  %50 = and i64 %47, 8
  %51 = icmp ne i64 %50, 0
  br i1 %51, label %$19, label %$18
$19:
  %52 = inttoptr i64 %47 to i64*
  %53 = load i64, i64* %52
  br label %$15
$18:
  %54 = call i64 @evList(i64 %47)
  br label %$15
$15:
  %55 = phi i64 [%47, %$17], [%53, %$19], [%54, %$18] ; # ->
; # (save (eval (car X)))
  %56 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %57 = load i64, i64* %56
  %58 = alloca i64, i64 2, align 16
  %59 = ptrtoint i64* %58 to i64
  %60 = inttoptr i64 %59 to i64*
  store i64 %55, i64* %60
  %61 = add i64 %59, 8
  %62 = inttoptr i64 %61 to i64*
  store i64 %57, i64* %62
  %63 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %59, i64* %63
; # (fill3 Y Z (save (eval (car X))))
  %64 = call i64 @fill3(i64 %15, i64 %35, i64 %55)
  br label %$14
$13:
; # (fill2 Y Z)
  %65 = call i64 @fill2(i64 %15, i64 %35)
  br label %$14
$14:
  %66 = phi i64 [%64, %$15], [%65, %$13] ; # ->
  %67 = icmp ne i64 %66, 0
  br i1 %67, label %$20, label %$21
$20:
  br label %$22
$21:
  br label %$22
$22:
  %68 = phi i64 [%66, %$20], [%15, %$21] ; # ->
; # (drop *Safe)
  %69 = inttoptr i64 %19 to i64*
  %70 = getelementptr i64, i64* %69, i32 1
  %71 = load i64, i64* %70
  %72 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %71, i64* %72
  ret i64 %68
}
@$Penv = global i64 0
@$Pnl = global i64 0

define i1 @unify(i64, i64, i64, i64) align 8 {
$1:
; # (let Penv (val $Penv) (: 1 (when (and (symb? X1) (== (firstByte X...
; # (val $Penv)
  %4 = load i64, i64* @$Penv
; # (: 1 (when (and (symb? X1) (== (firstByte X1) (char "@"))) (let X...
  br label %$-1
$-1:
  %5 = phi i64 [%0, %$1], [%75, %$11] ; # N1
  %6 = phi i64 [%1, %$1], [%78, %$11] ; # X1
  %7 = phi i64 [%2, %$1], [%67, %$11] ; # N2
  %8 = phi i64 [%3, %$1], [%68, %$11] ; # X2
; # (when (and (symb? X1) (== (firstByte X1) (char "@"))) (let X (val...
; # (and (symb? X1) (== (firstByte X1) (char "@")))
; # (symb? X1)
  %9 = xor i64 %6, 8
  %10 = and i64 %9, 14
  %11 = icmp eq i64 %10, 0
  br i1 %11, label %$3, label %$2
$3:
  %12 = phi i64 [%5, %$-1] ; # N1
  %13 = phi i64 [%6, %$-1] ; # X1
  %14 = phi i64 [%7, %$-1] ; # N2
  %15 = phi i64 [%8, %$-1] ; # X2
; # (firstByte X1)
  %16 = call i8 @firstByte(i64 %13)
; # (== (firstByte X1) (char "@"))
  %17 = icmp eq i8 %16, 64
  br label %$2
$2:
  %18 = phi i64 [%5, %$-1], [%12, %$3] ; # N1
  %19 = phi i64 [%6, %$-1], [%13, %$3] ; # X1
  %20 = phi i64 [%7, %$-1], [%14, %$3] ; # N2
  %21 = phi i64 [%8, %$-1], [%15, %$3] ; # X2
  %22 = phi i1 [0, %$-1], [%17, %$3] ; # ->
  br i1 %22, label %$4, label %$5
$4:
  %23 = phi i64 [%18, %$2] ; # N1
  %24 = phi i64 [%19, %$2] ; # X1
  %25 = phi i64 [%20, %$2] ; # N2
  %26 = phi i64 [%21, %$2] ; # X2
; # (let X (val Penv) (while (pair (car X)) (let (Y @ Z (car Y)) (whe...
; # (val Penv)
  %27 = inttoptr i64 %4 to i64*
  %28 = load i64, i64* %27
; # (while (pair (car X)) (let (Y @ Z (car Y)) (when (and (== N1 (car...
  br label %$6
$6:
  %29 = phi i64 [%23, %$4], [%79, %$12] ; # N1
  %30 = phi i64 [%24, %$4], [%80, %$12] ; # X1
  %31 = phi i64 [%25, %$4], [%81, %$12] ; # N2
  %32 = phi i64 [%26, %$4], [%82, %$12] ; # X2
  %33 = phi i64 [%28, %$4], [%87, %$12] ; # X
; # (car X)
  %34 = inttoptr i64 %33 to i64*
  %35 = load i64, i64* %34
; # (pair (car X))
  %36 = and i64 %35, 15
  %37 = icmp eq i64 %36, 0
  br i1 %37, label %$7, label %$8
$7:
  %38 = phi i64 [%29, %$6] ; # N1
  %39 = phi i64 [%30, %$6] ; # X1
  %40 = phi i64 [%31, %$6] ; # N2
  %41 = phi i64 [%32, %$6] ; # X2
  %42 = phi i64 [%33, %$6] ; # X
; # (let (Y @ Z (car Y)) (when (and (== N1 (car Z)) (== X1 (cdr Z))) ...
; # (car Y)
  %43 = inttoptr i64 %35 to i64*
  %44 = load i64, i64* %43
; # (when (and (== N1 (car Z)) (== X1 (cdr Z))) (setq Z (cdr Y) N1 (c...
; # (and (== N1 (car Z)) (== X1 (cdr Z)))
; # (car Z)
  %45 = inttoptr i64 %44 to i64*
  %46 = load i64, i64* %45
; # (== N1 (car Z))
  %47 = icmp eq i64 %38, %46
  br i1 %47, label %$10, label %$9
$10:
  %48 = phi i64 [%38, %$7] ; # N1
  %49 = phi i64 [%39, %$7] ; # X1
  %50 = phi i64 [%40, %$7] ; # N2
  %51 = phi i64 [%41, %$7] ; # X2
  %52 = phi i64 [%42, %$7] ; # X
  %53 = phi i64 [%44, %$7] ; # Z
; # (cdr Z)
  %54 = inttoptr i64 %53 to i64*
  %55 = getelementptr i64, i64* %54, i32 1
  %56 = load i64, i64* %55
; # (== X1 (cdr Z))
  %57 = icmp eq i64 %49, %56
  br label %$9
$9:
  %58 = phi i64 [%38, %$7], [%48, %$10] ; # N1
  %59 = phi i64 [%39, %$7], [%49, %$10] ; # X1
  %60 = phi i64 [%40, %$7], [%50, %$10] ; # N2
  %61 = phi i64 [%41, %$7], [%51, %$10] ; # X2
  %62 = phi i64 [%42, %$7], [%52, %$10] ; # X
  %63 = phi i64 [%44, %$7], [%53, %$10] ; # Z
  %64 = phi i1 [0, %$7], [%57, %$10] ; # ->
  br i1 %64, label %$11, label %$12
$11:
  %65 = phi i64 [%58, %$9] ; # N1
  %66 = phi i64 [%59, %$9] ; # X1
  %67 = phi i64 [%60, %$9] ; # N2
  %68 = phi i64 [%61, %$9] ; # X2
  %69 = phi i64 [%62, %$9] ; # X
  %70 = phi i64 [%63, %$9] ; # Z
; # (cdr Y)
  %71 = inttoptr i64 %35 to i64*
  %72 = getelementptr i64, i64* %71, i32 1
  %73 = load i64, i64* %72
; # (car Z)
  %74 = inttoptr i64 %73 to i64*
  %75 = load i64, i64* %74
; # (cdr Z)
  %76 = inttoptr i64 %73 to i64*
  %77 = getelementptr i64, i64* %76, i32 1
  %78 = load i64, i64* %77
; # (goto 1)
  br label %$-1
$12:
  %79 = phi i64 [%58, %$9] ; # N1
  %80 = phi i64 [%59, %$9] ; # X1
  %81 = phi i64 [%60, %$9] ; # N2
  %82 = phi i64 [%61, %$9] ; # X2
  %83 = phi i64 [%62, %$9] ; # X
  %84 = phi i64 [%63, %$9] ; # Z
; # (shift X)
  %85 = inttoptr i64 %83 to i64*
  %86 = getelementptr i64, i64* %85, i32 1
  %87 = load i64, i64* %86
  br label %$6
$8:
  %88 = phi i64 [%29, %$6] ; # N1
  %89 = phi i64 [%30, %$6] ; # X1
  %90 = phi i64 [%31, %$6] ; # N2
  %91 = phi i64 [%32, %$6] ; # X2
  %92 = phi i64 [%33, %$6] ; # X
  br label %$5
$5:
  %93 = phi i64 [%18, %$2], [%88, %$8] ; # N1
  %94 = phi i64 [%19, %$2], [%89, %$8] ; # X1
  %95 = phi i64 [%20, %$2], [%90, %$8] ; # N2
  %96 = phi i64 [%21, %$2], [%91, %$8] ; # X2
; # (: 2 (when (and (symb? X2) (== (firstByte X2) (char "@"))) (let X...
  br label %$-2
$-2:
  %97 = phi i64 [%93, %$5], [%157, %$22] ; # N1
  %98 = phi i64 [%94, %$5], [%158, %$22] ; # X1
  %99 = phi i64 [%95, %$5], [%167, %$22] ; # N2
  %100 = phi i64 [%96, %$5], [%170, %$22] ; # X2
; # (when (and (symb? X2) (== (firstByte X2) (char "@"))) (let X (val...
; # (and (symb? X2) (== (firstByte X2) (char "@")))
; # (symb? X2)
  %101 = xor i64 %100, 8
  %102 = and i64 %101, 14
  %103 = icmp eq i64 %102, 0
  br i1 %103, label %$14, label %$13
$14:
  %104 = phi i64 [%97, %$-2] ; # N1
  %105 = phi i64 [%98, %$-2] ; # X1
  %106 = phi i64 [%99, %$-2] ; # N2
  %107 = phi i64 [%100, %$-2] ; # X2
; # (firstByte X2)
  %108 = call i8 @firstByte(i64 %107)
; # (== (firstByte X2) (char "@"))
  %109 = icmp eq i8 %108, 64
  br label %$13
$13:
  %110 = phi i64 [%97, %$-2], [%104, %$14] ; # N1
  %111 = phi i64 [%98, %$-2], [%105, %$14] ; # X1
  %112 = phi i64 [%99, %$-2], [%106, %$14] ; # N2
  %113 = phi i64 [%100, %$-2], [%107, %$14] ; # X2
  %114 = phi i1 [0, %$-2], [%109, %$14] ; # ->
  br i1 %114, label %$15, label %$16
$15:
  %115 = phi i64 [%110, %$13] ; # N1
  %116 = phi i64 [%111, %$13] ; # X1
  %117 = phi i64 [%112, %$13] ; # N2
  %118 = phi i64 [%113, %$13] ; # X2
; # (let X (val Penv) (while (pair (car X)) (let (Y @ Z (car Y)) (whe...
; # (val Penv)
  %119 = inttoptr i64 %4 to i64*
  %120 = load i64, i64* %119
; # (while (pair (car X)) (let (Y @ Z (car Y)) (when (and (== N2 (car...
  br label %$17
$17:
  %121 = phi i64 [%115, %$15], [%171, %$23] ; # N1
  %122 = phi i64 [%116, %$15], [%172, %$23] ; # X1
  %123 = phi i64 [%117, %$15], [%173, %$23] ; # N2
  %124 = phi i64 [%118, %$15], [%174, %$23] ; # X2
  %125 = phi i64 [%120, %$15], [%179, %$23] ; # X
; # (car X)
  %126 = inttoptr i64 %125 to i64*
  %127 = load i64, i64* %126
; # (pair (car X))
  %128 = and i64 %127, 15
  %129 = icmp eq i64 %128, 0
  br i1 %129, label %$18, label %$19
$18:
  %130 = phi i64 [%121, %$17] ; # N1
  %131 = phi i64 [%122, %$17] ; # X1
  %132 = phi i64 [%123, %$17] ; # N2
  %133 = phi i64 [%124, %$17] ; # X2
  %134 = phi i64 [%125, %$17] ; # X
; # (let (Y @ Z (car Y)) (when (and (== N2 (car Z)) (== X2 (cdr Z))) ...
; # (car Y)
  %135 = inttoptr i64 %127 to i64*
  %136 = load i64, i64* %135
; # (when (and (== N2 (car Z)) (== X2 (cdr Z))) (setq Z (cdr Y) N2 (c...
; # (and (== N2 (car Z)) (== X2 (cdr Z)))
; # (car Z)
  %137 = inttoptr i64 %136 to i64*
  %138 = load i64, i64* %137
; # (== N2 (car Z))
  %139 = icmp eq i64 %132, %138
  br i1 %139, label %$21, label %$20
$21:
  %140 = phi i64 [%130, %$18] ; # N1
  %141 = phi i64 [%131, %$18] ; # X1
  %142 = phi i64 [%132, %$18] ; # N2
  %143 = phi i64 [%133, %$18] ; # X2
  %144 = phi i64 [%134, %$18] ; # X
  %145 = phi i64 [%136, %$18] ; # Z
; # (cdr Z)
  %146 = inttoptr i64 %145 to i64*
  %147 = getelementptr i64, i64* %146, i32 1
  %148 = load i64, i64* %147
; # (== X2 (cdr Z))
  %149 = icmp eq i64 %143, %148
  br label %$20
$20:
  %150 = phi i64 [%130, %$18], [%140, %$21] ; # N1
  %151 = phi i64 [%131, %$18], [%141, %$21] ; # X1
  %152 = phi i64 [%132, %$18], [%142, %$21] ; # N2
  %153 = phi i64 [%133, %$18], [%143, %$21] ; # X2
  %154 = phi i64 [%134, %$18], [%144, %$21] ; # X
  %155 = phi i64 [%136, %$18], [%145, %$21] ; # Z
  %156 = phi i1 [0, %$18], [%149, %$21] ; # ->
  br i1 %156, label %$22, label %$23
$22:
  %157 = phi i64 [%150, %$20] ; # N1
  %158 = phi i64 [%151, %$20] ; # X1
  %159 = phi i64 [%152, %$20] ; # N2
  %160 = phi i64 [%153, %$20] ; # X2
  %161 = phi i64 [%154, %$20] ; # X
  %162 = phi i64 [%155, %$20] ; # Z
; # (cdr Y)
  %163 = inttoptr i64 %127 to i64*
  %164 = getelementptr i64, i64* %163, i32 1
  %165 = load i64, i64* %164
; # (car Z)
  %166 = inttoptr i64 %165 to i64*
  %167 = load i64, i64* %166
; # (cdr Z)
  %168 = inttoptr i64 %165 to i64*
  %169 = getelementptr i64, i64* %168, i32 1
  %170 = load i64, i64* %169
; # (goto 2)
  br label %$-2
$23:
  %171 = phi i64 [%150, %$20] ; # N1
  %172 = phi i64 [%151, %$20] ; # X1
  %173 = phi i64 [%152, %$20] ; # N2
  %174 = phi i64 [%153, %$20] ; # X2
  %175 = phi i64 [%154, %$20] ; # X
  %176 = phi i64 [%155, %$20] ; # Z
; # (shift X)
  %177 = inttoptr i64 %175 to i64*
  %178 = getelementptr i64, i64* %177, i32 1
  %179 = load i64, i64* %178
  br label %$17
$19:
  %180 = phi i64 [%121, %$17] ; # N1
  %181 = phi i64 [%122, %$17] ; # X1
  %182 = phi i64 [%123, %$17] ; # N2
  %183 = phi i64 [%124, %$17] ; # X2
  %184 = phi i64 [%125, %$17] ; # X
  br label %$16
$16:
  %185 = phi i64 [%110, %$13], [%180, %$19] ; # N1
  %186 = phi i64 [%111, %$13], [%181, %$19] ; # X1
  %187 = phi i64 [%112, %$13], [%182, %$19] ; # N2
  %188 = phi i64 [%113, %$13], [%183, %$19] ; # X2
; # (cond ((and (== N1 N2) (equal X1 X2)) YES) ((and (symb? X1) (== (...
; # (and (== N1 N2) (equal X1 X2))
; # (== N1 N2)
  %189 = icmp eq i64 %185, %187
  br i1 %189, label %$26, label %$25
$26:
  %190 = phi i64 [%185, %$16] ; # N1
  %191 = phi i64 [%186, %$16] ; # X1
  %192 = phi i64 [%187, %$16] ; # N2
  %193 = phi i64 [%188, %$16] ; # X2
; # (equal X1 X2)
  %194 = call i1 @equal(i64 %191, i64 %193)
  br label %$25
$25:
  %195 = phi i64 [%185, %$16], [%190, %$26] ; # N1
  %196 = phi i64 [%186, %$16], [%191, %$26] ; # X1
  %197 = phi i64 [%187, %$16], [%192, %$26] ; # N2
  %198 = phi i64 [%188, %$16], [%193, %$26] ; # X2
  %199 = phi i1 [0, %$16], [%194, %$26] ; # ->
  br i1 %199, label %$28, label %$27
$28:
  %200 = phi i64 [%195, %$25] ; # N1
  %201 = phi i64 [%196, %$25] ; # X1
  %202 = phi i64 [%197, %$25] ; # N2
  %203 = phi i64 [%198, %$25] ; # X2
  br label %$24
$27:
  %204 = phi i64 [%195, %$25] ; # N1
  %205 = phi i64 [%196, %$25] ; # X1
  %206 = phi i64 [%197, %$25] ; # N2
  %207 = phi i64 [%198, %$25] ; # X2
; # (and (symb? X1) (== (firstByte X1) (char "@")))
; # (symb? X1)
  %208 = xor i64 %205, 8
  %209 = and i64 %208, 14
  %210 = icmp eq i64 %209, 0
  br i1 %210, label %$30, label %$29
$30:
  %211 = phi i64 [%204, %$27] ; # N1
  %212 = phi i64 [%205, %$27] ; # X1
  %213 = phi i64 [%206, %$27] ; # N2
  %214 = phi i64 [%207, %$27] ; # X2
; # (firstByte X1)
  %215 = call i8 @firstByte(i64 %212)
; # (== (firstByte X1) (char "@"))
  %216 = icmp eq i8 %215, 64
  br label %$29
$29:
  %217 = phi i64 [%204, %$27], [%211, %$30] ; # N1
  %218 = phi i64 [%205, %$27], [%212, %$30] ; # X1
  %219 = phi i64 [%206, %$27], [%213, %$30] ; # N2
  %220 = phi i64 [%207, %$27], [%214, %$30] ; # X2
  %221 = phi i1 [0, %$27], [%216, %$30] ; # ->
  br i1 %221, label %$32, label %$31
$32:
  %222 = phi i64 [%217, %$29] ; # N1
  %223 = phi i64 [%218, %$29] ; # X1
  %224 = phi i64 [%219, %$29] ; # N2
  %225 = phi i64 [%220, %$29] ; # X2
; # (unless (== X1 $At) (set Penv (cons (cons3 N1 X1 N2 X2) (val Penv...
; # (== X1 $At)
  %226 = icmp eq i64 %223, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64)
  br i1 %226, label %$34, label %$33
$33:
  %227 = phi i64 [%222, %$32] ; # N1
  %228 = phi i64 [%223, %$32] ; # X1
  %229 = phi i64 [%224, %$32] ; # N2
  %230 = phi i64 [%225, %$32] ; # X2
; # (set Penv (cons (cons3 N1 X1 N2 X2) (val Penv)))
; # (cons3 N1 X1 N2 X2)
  %231 = call i64 @cons3(i64 %227, i64 %228, i64 %229, i64 %230)
; # (val Penv)
  %232 = inttoptr i64 %4 to i64*
  %233 = load i64, i64* %232
; # (cons (cons3 N1 X1 N2 X2) (val Penv))
  %234 = call i64 @cons(i64 %231, i64 %233)
  %235 = inttoptr i64 %4 to i64*
  store i64 %234, i64* %235
  br label %$34
$34:
  %236 = phi i64 [%222, %$32], [%227, %$33] ; # N1
  %237 = phi i64 [%223, %$32], [%228, %$33] ; # X1
  %238 = phi i64 [%224, %$32], [%229, %$33] ; # N2
  %239 = phi i64 [%225, %$32], [%230, %$33] ; # X2
  br label %$24
$31:
  %240 = phi i64 [%217, %$29] ; # N1
  %241 = phi i64 [%218, %$29] ; # X1
  %242 = phi i64 [%219, %$29] ; # N2
  %243 = phi i64 [%220, %$29] ; # X2
; # (and (symb? X2) (== (firstByte X2) (char "@")))
; # (symb? X2)
  %244 = xor i64 %243, 8
  %245 = and i64 %244, 14
  %246 = icmp eq i64 %245, 0
  br i1 %246, label %$36, label %$35
$36:
  %247 = phi i64 [%240, %$31] ; # N1
  %248 = phi i64 [%241, %$31] ; # X1
  %249 = phi i64 [%242, %$31] ; # N2
  %250 = phi i64 [%243, %$31] ; # X2
; # (firstByte X2)
  %251 = call i8 @firstByte(i64 %250)
; # (== (firstByte X2) (char "@"))
  %252 = icmp eq i8 %251, 64
  br label %$35
$35:
  %253 = phi i64 [%240, %$31], [%247, %$36] ; # N1
  %254 = phi i64 [%241, %$31], [%248, %$36] ; # X1
  %255 = phi i64 [%242, %$31], [%249, %$36] ; # N2
  %256 = phi i64 [%243, %$31], [%250, %$36] ; # X2
  %257 = phi i1 [0, %$31], [%252, %$36] ; # ->
  br i1 %257, label %$38, label %$37
$38:
  %258 = phi i64 [%253, %$35] ; # N1
  %259 = phi i64 [%254, %$35] ; # X1
  %260 = phi i64 [%255, %$35] ; # N2
  %261 = phi i64 [%256, %$35] ; # X2
; # (unless (== X2 $At) (set Penv (cons (cons3 N2 X2 N1 X1) (val Penv...
; # (== X2 $At)
  %262 = icmp eq i64 %261, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64)
  br i1 %262, label %$40, label %$39
$39:
  %263 = phi i64 [%258, %$38] ; # N1
  %264 = phi i64 [%259, %$38] ; # X1
  %265 = phi i64 [%260, %$38] ; # N2
  %266 = phi i64 [%261, %$38] ; # X2
; # (set Penv (cons (cons3 N2 X2 N1 X1) (val Penv)))
; # (cons3 N2 X2 N1 X1)
  %267 = call i64 @cons3(i64 %265, i64 %266, i64 %263, i64 %264)
; # (val Penv)
  %268 = inttoptr i64 %4 to i64*
  %269 = load i64, i64* %268
; # (cons (cons3 N2 X2 N1 X1) (val Penv))
  %270 = call i64 @cons(i64 %267, i64 %269)
  %271 = inttoptr i64 %4 to i64*
  store i64 %270, i64* %271
  br label %$40
$40:
  %272 = phi i64 [%258, %$38], [%263, %$39] ; # N1
  %273 = phi i64 [%259, %$38], [%264, %$39] ; # X1
  %274 = phi i64 [%260, %$38], [%265, %$39] ; # N2
  %275 = phi i64 [%261, %$38], [%266, %$39] ; # X2
  br label %$24
$37:
  %276 = phi i64 [%253, %$35] ; # N1
  %277 = phi i64 [%254, %$35] ; # X1
  %278 = phi i64 [%255, %$35] ; # N2
  %279 = phi i64 [%256, %$35] ; # X2
; # (or (atom X1) (atom X2))
; # (atom X1)
  %280 = and i64 %277, 15
  %281 = icmp ne i64 %280, 0
  br i1 %281, label %$41, label %$42
$42:
  %282 = phi i64 [%276, %$37] ; # N1
  %283 = phi i64 [%277, %$37] ; # X1
  %284 = phi i64 [%278, %$37] ; # N2
  %285 = phi i64 [%279, %$37] ; # X2
; # (atom X2)
  %286 = and i64 %285, 15
  %287 = icmp ne i64 %286, 0
  br label %$41
$41:
  %288 = phi i64 [%276, %$37], [%282, %$42] ; # N1
  %289 = phi i64 [%277, %$37], [%283, %$42] ; # X1
  %290 = phi i64 [%278, %$37], [%284, %$42] ; # N2
  %291 = phi i64 [%279, %$37], [%285, %$42] ; # X2
  %292 = phi i1 [1, %$37], [%287, %$42] ; # ->
  br i1 %292, label %$44, label %$43
$44:
  %293 = phi i64 [%288, %$41] ; # N1
  %294 = phi i64 [%289, %$41] ; # X1
  %295 = phi i64 [%290, %$41] ; # N2
  %296 = phi i64 [%291, %$41] ; # X2
; # (equal X1 X2)
  %297 = call i1 @equal(i64 %294, i64 %296)
  br label %$24
$43:
  %298 = phi i64 [%288, %$41] ; # N1
  %299 = phi i64 [%289, %$41] ; # X1
  %300 = phi i64 [%290, %$41] ; # N2
  %301 = phi i64 [%291, %$41] ; # X2
; # (stkChk 0)
  %302 = load i8*, i8** @$StkLimit
  %303 = call i8* @llvm.stacksave()
  %304 = icmp ugt i8* %302, %303
  br i1 %304, label %$45, label %$46
$45:
  call void @stkErr(i64 0)
  unreachable
$46:
; # (let Env (val Penv) (or (and (unify N1 (car X1) N2 (car X2)) (uni...
; # (val Penv)
  %305 = inttoptr i64 %4 to i64*
  %306 = load i64, i64* %305
; # (or (and (unify N1 (car X1) N2 (car X2)) (unify N1 (cdr X1) N2 (c...
; # (and (unify N1 (car X1) N2 (car X2)) (unify N1 (cdr X1) N2 (cdr X...
; # (car X1)
  %307 = inttoptr i64 %299 to i64*
  %308 = load i64, i64* %307
; # (car X2)
  %309 = inttoptr i64 %301 to i64*
  %310 = load i64, i64* %309
; # (unify N1 (car X1) N2 (car X2))
  %311 = call i1 @unify(i64 %298, i64 %308, i64 %300, i64 %310)
  br i1 %311, label %$49, label %$48
$49:
  %312 = phi i64 [%298, %$46] ; # N1
  %313 = phi i64 [%299, %$46] ; # X1
  %314 = phi i64 [%300, %$46] ; # N2
  %315 = phi i64 [%301, %$46] ; # X2
; # (cdr X1)
  %316 = inttoptr i64 %313 to i64*
  %317 = getelementptr i64, i64* %316, i32 1
  %318 = load i64, i64* %317
; # (cdr X2)
  %319 = inttoptr i64 %315 to i64*
  %320 = getelementptr i64, i64* %319, i32 1
  %321 = load i64, i64* %320
; # (unify N1 (cdr X1) N2 (cdr X2))
  %322 = call i1 @unify(i64 %312, i64 %318, i64 %314, i64 %321)
  br label %$48
$48:
  %323 = phi i64 [%298, %$46], [%312, %$49] ; # N1
  %324 = phi i64 [%299, %$46], [%313, %$49] ; # X1
  %325 = phi i64 [%300, %$46], [%314, %$49] ; # N2
  %326 = phi i64 [%301, %$46], [%315, %$49] ; # X2
  %327 = phi i1 [0, %$46], [%322, %$49] ; # ->
  br i1 %327, label %$47, label %$50
$50:
  %328 = phi i64 [%323, %$48] ; # N1
  %329 = phi i64 [%324, %$48] ; # X1
  %330 = phi i64 [%325, %$48] ; # N2
  %331 = phi i64 [%326, %$48] ; # X2
; # (set Penv Env)
  %332 = inttoptr i64 %4 to i64*
  store i64 %306, i64* %332
  br label %$47
$47:
  %333 = phi i64 [%323, %$48], [%328, %$50] ; # N1
  %334 = phi i64 [%324, %$48], [%329, %$50] ; # X1
  %335 = phi i64 [%325, %$48], [%330, %$50] ; # N2
  %336 = phi i64 [%326, %$48], [%331, %$50] ; # X2
  %337 = phi i1 [1, %$48], [0, %$50] ; # ->
  br label %$24
$24:
  %338 = phi i64 [%200, %$28], [%236, %$34], [%272, %$40], [%293, %$44], [%333, %$47] ; # N1
  %339 = phi i64 [%201, %$28], [%237, %$34], [%273, %$40], [%294, %$44], [%334, %$47] ; # X1
  %340 = phi i64 [%202, %$28], [%238, %$34], [%274, %$40], [%295, %$44], [%335, %$47] ; # N2
  %341 = phi i64 [%203, %$28], [%239, %$34], [%275, %$40], [%296, %$44], [%336, %$47] ; # X2
  %342 = phi i1 [1, %$28], [1, %$34], [1, %$40], [%297, %$44], [%337, %$47] ; # ->
  ret i1 %342
}

define i64 @lup(i64, i64) align 8 {
$1:
; # (let Penv (val $Penv) (: 1 (when (and (symb? X) (== (firstByte X)...
; # (val $Penv)
  %2 = load i64, i64* @$Penv
; # (: 1 (when (and (symb? X) (== (firstByte X) (char "@"))) (let V (...
  br label %$-1
$-1:
  %3 = phi i64 [%0, %$1], [%55, %$11] ; # N
  %4 = phi i64 [%1, %$1], [%58, %$11] ; # X
; # (when (and (symb? X) (== (firstByte X) (char "@"))) (let V (val P...
; # (and (symb? X) (== (firstByte X) (char "@")))
; # (symb? X)
  %5 = xor i64 %4, 8
  %6 = and i64 %5, 14
  %7 = icmp eq i64 %6, 0
  br i1 %7, label %$3, label %$2
$3:
  %8 = phi i64 [%3, %$-1] ; # N
  %9 = phi i64 [%4, %$-1] ; # X
; # (firstByte X)
  %10 = call i8 @firstByte(i64 %9)
; # (== (firstByte X) (char "@"))
  %11 = icmp eq i8 %10, 64
  br label %$2
$2:
  %12 = phi i64 [%3, %$-1], [%8, %$3] ; # N
  %13 = phi i64 [%4, %$-1], [%9, %$3] ; # X
  %14 = phi i1 [0, %$-1], [%11, %$3] ; # ->
  br i1 %14, label %$4, label %$5
$4:
  %15 = phi i64 [%12, %$2] ; # N
  %16 = phi i64 [%13, %$2] ; # X
; # (let V (val Penv) (while (pair (car V)) (let (Y @ Z (car Y)) (whe...
; # (val Penv)
  %17 = inttoptr i64 %2 to i64*
  %18 = load i64, i64* %17
; # (while (pair (car V)) (let (Y @ Z (car Y)) (when (and (== N (car ...
  br label %$6
$6:
  %19 = phi i64 [%15, %$4], [%59, %$12] ; # N
  %20 = phi i64 [%16, %$4], [%60, %$12] ; # X
  %21 = phi i64 [%18, %$4], [%65, %$12] ; # V
; # (car V)
  %22 = inttoptr i64 %21 to i64*
  %23 = load i64, i64* %22
; # (pair (car V))
  %24 = and i64 %23, 15
  %25 = icmp eq i64 %24, 0
  br i1 %25, label %$7, label %$8
$7:
  %26 = phi i64 [%19, %$6] ; # N
  %27 = phi i64 [%20, %$6] ; # X
  %28 = phi i64 [%21, %$6] ; # V
; # (let (Y @ Z (car Y)) (when (and (== N (car Z)) (== X (cdr Z))) (s...
; # (car Y)
  %29 = inttoptr i64 %23 to i64*
  %30 = load i64, i64* %29
; # (when (and (== N (car Z)) (== X (cdr Z))) (setq Z (cdr Y) N (car ...
; # (and (== N (car Z)) (== X (cdr Z)))
; # (car Z)
  %31 = inttoptr i64 %30 to i64*
  %32 = load i64, i64* %31
; # (== N (car Z))
  %33 = icmp eq i64 %26, %32
  br i1 %33, label %$10, label %$9
$10:
  %34 = phi i64 [%26, %$7] ; # N
  %35 = phi i64 [%27, %$7] ; # X
  %36 = phi i64 [%28, %$7] ; # V
  %37 = phi i64 [%30, %$7] ; # Z
; # (cdr Z)
  %38 = inttoptr i64 %37 to i64*
  %39 = getelementptr i64, i64* %38, i32 1
  %40 = load i64, i64* %39
; # (== X (cdr Z))
  %41 = icmp eq i64 %35, %40
  br label %$9
$9:
  %42 = phi i64 [%26, %$7], [%34, %$10] ; # N
  %43 = phi i64 [%27, %$7], [%35, %$10] ; # X
  %44 = phi i64 [%28, %$7], [%36, %$10] ; # V
  %45 = phi i64 [%30, %$7], [%37, %$10] ; # Z
  %46 = phi i1 [0, %$7], [%41, %$10] ; # ->
  br i1 %46, label %$11, label %$12
$11:
  %47 = phi i64 [%42, %$9] ; # N
  %48 = phi i64 [%43, %$9] ; # X
  %49 = phi i64 [%44, %$9] ; # V
  %50 = phi i64 [%45, %$9] ; # Z
; # (cdr Y)
  %51 = inttoptr i64 %23 to i64*
  %52 = getelementptr i64, i64* %51, i32 1
  %53 = load i64, i64* %52
; # (car Z)
  %54 = inttoptr i64 %53 to i64*
  %55 = load i64, i64* %54
; # (cdr Z)
  %56 = inttoptr i64 %53 to i64*
  %57 = getelementptr i64, i64* %56, i32 1
  %58 = load i64, i64* %57
; # (goto 1)
  br label %$-1
$12:
  %59 = phi i64 [%42, %$9] ; # N
  %60 = phi i64 [%43, %$9] ; # X
  %61 = phi i64 [%44, %$9] ; # V
  %62 = phi i64 [%45, %$9] ; # Z
; # (shift V)
  %63 = inttoptr i64 %61 to i64*
  %64 = getelementptr i64, i64* %63, i32 1
  %65 = load i64, i64* %64
  br label %$6
$8:
  %66 = phi i64 [%19, %$6] ; # N
  %67 = phi i64 [%20, %$6] ; # X
  %68 = phi i64 [%21, %$6] ; # V
  br label %$5
$5:
  %69 = phi i64 [%12, %$2], [%66, %$8] ; # N
  %70 = phi i64 [%13, %$2], [%67, %$8] ; # X
; # (if (or (atom X) (cnt? (car X)) (== @ $Up)) X (stkChk 0) (let Z (...
; # (or (atom X) (cnt? (car X)) (== @ $Up))
; # (atom X)
  %71 = and i64 %70, 15
  %72 = icmp ne i64 %71, 0
  br i1 %72, label %$13, label %$14
$14:
  %73 = phi i64 [%69, %$5] ; # N
  %74 = phi i64 [%70, %$5] ; # X
; # (car X)
  %75 = inttoptr i64 %74 to i64*
  %76 = load i64, i64* %75
; # (cnt? (car X))
  %77 = and i64 %76, 2
  %78 = icmp ne i64 %77, 0
  br i1 %78, label %$13, label %$15
$15:
  %79 = phi i64 [%73, %$14] ; # N
  %80 = phi i64 [%74, %$14] ; # X
; # (== @ $Up)
  %81 = icmp eq i64 %76, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 728) to i64)
  br label %$13
$13:
  %82 = phi i64 [%69, %$5], [%73, %$14], [%79, %$15] ; # N
  %83 = phi i64 [%70, %$5], [%74, %$14], [%80, %$15] ; # X
  %84 = phi i1 [1, %$5], [1, %$14], [%81, %$15] ; # ->
  br i1 %84, label %$16, label %$17
$16:
  %85 = phi i64 [%82, %$13] ; # N
  %86 = phi i64 [%83, %$13] ; # X
  br label %$18
$17:
  %87 = phi i64 [%82, %$13] ; # N
  %88 = phi i64 [%83, %$13] ; # X
; # (stkChk 0)
  %89 = load i8*, i8** @$StkLimit
  %90 = call i8* @llvm.stacksave()
  %91 = icmp ugt i8* %89, %90
  br i1 %91, label %$19, label %$20
$19:
  call void @stkErr(i64 0)
  unreachable
$20:
; # (let Z (save (lup N (car X))) (cons Z (lup N (cdr X))))
; # (car X)
  %92 = inttoptr i64 %88 to i64*
  %93 = load i64, i64* %92
; # (lup N (car X))
  %94 = call i64 @lup(i64 %87, i64 %93)
; # (save (lup N (car X)))
  %95 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %96 = load i64, i64* %95
  %97 = alloca i64, i64 2, align 16
  %98 = ptrtoint i64* %97 to i64
  %99 = inttoptr i64 %98 to i64*
  store i64 %94, i64* %99
  %100 = add i64 %98, 8
  %101 = inttoptr i64 %100 to i64*
  store i64 %96, i64* %101
  %102 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %98, i64* %102
; # (cdr X)
  %103 = inttoptr i64 %88 to i64*
  %104 = getelementptr i64, i64* %103, i32 1
  %105 = load i64, i64* %104
; # (lup N (cdr X))
  %106 = call i64 @lup(i64 %87, i64 %105)
; # (cons Z (lup N (cdr X)))
  %107 = call i64 @cons(i64 %94, i64 %106)
; # (drop *Safe)
  %108 = inttoptr i64 %98 to i64*
  %109 = getelementptr i64, i64* %108, i32 1
  %110 = load i64, i64* %109
  %111 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %110, i64* %111
  br label %$18
$18:
  %112 = phi i64 [%85, %$16], [%87, %$20] ; # N
  %113 = phi i64 [%86, %$16], [%88, %$20] ; # X
  %114 = phi i64 [%86, %$16], [%107, %$20] ; # ->
  ret i64 %114
}

define i64 @lookup(i64, i64) align 8 {
$1:
; # (if (and (symb? (setq X (lup N X))) (== (firstByte X) (char "@"))...
; # (and (symb? (setq X (lup N X))) (== (firstByte X) (char "@")))
; # (lup N X)
  %2 = call i64 @lup(i64 %0, i64 %1)
; # (symb? (setq X (lup N X)))
  %3 = xor i64 %2, 8
  %4 = and i64 %3, 14
  %5 = icmp eq i64 %4, 0
  br i1 %5, label %$3, label %$2
$3:
  %6 = phi i64 [%2, %$1] ; # X
; # (firstByte X)
  %7 = call i8 @firstByte(i64 %6)
; # (== (firstByte X) (char "@"))
  %8 = icmp eq i8 %7, 64
  br label %$2
$2:
  %9 = phi i64 [%2, %$1], [%6, %$3] ; # X
  %10 = phi i1 [0, %$1], [%8, %$3] ; # ->
  br i1 %10, label %$4, label %$5
$4:
  %11 = phi i64 [%9, %$2] ; # X
  br label %$6
$5:
  %12 = phi i64 [%9, %$2] ; # X
  br label %$6
$6:
  %13 = phi i64 [%11, %$4], [%12, %$5] ; # X
  %14 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$4], [%12, %$5] ; # ->
  ret i64 %14
}

define i64 @uniFill(i64) align 8 {
$1:
; # (cond ((num? X) X) ((sym? X) (lup (car (val (val $Pnl))) X)) (T (...
; # (num? X)
  %1 = and i64 %0, 6
  %2 = icmp ne i64 %1, 0
  br i1 %2, label %$4, label %$3
$4:
  br label %$2
$3:
; # (sym? X)
  %3 = and i64 %0, 8
  %4 = icmp ne i64 %3, 0
  br i1 %4, label %$6, label %$5
$6:
; # (val $Pnl)
  %5 = load i64, i64* @$Pnl
; # (val (val $Pnl))
  %6 = inttoptr i64 %5 to i64*
  %7 = load i64, i64* %6
; # (car (val (val $Pnl)))
  %8 = inttoptr i64 %7 to i64*
  %9 = load i64, i64* %8
; # (lup (car (val (val $Pnl))) X)
  %10 = call i64 @lup(i64 %9, i64 %0)
  br label %$2
$5:
; # (stkChk 0)
  %11 = load i8*, i8** @$StkLimit
  %12 = call i8* @llvm.stacksave()
  %13 = icmp ugt i8* %11, %12
  br i1 %13, label %$7, label %$8
$7:
  call void @stkErr(i64 0)
  unreachable
$8:
; # (let Y (save (uniFill (car X))) (cons Y (uniFill (cdr X))))
; # (car X)
  %14 = inttoptr i64 %0 to i64*
  %15 = load i64, i64* %14
; # (uniFill (car X))
  %16 = call i64 @uniFill(i64 %15)
; # (save (uniFill (car X)))
  %17 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %18 = load i64, i64* %17
  %19 = alloca i64, i64 2, align 16
  %20 = ptrtoint i64* %19 to i64
  %21 = inttoptr i64 %20 to i64*
  store i64 %16, i64* %21
  %22 = add i64 %20, 8
  %23 = inttoptr i64 %22 to i64*
  store i64 %18, i64* %23
  %24 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %20, i64* %24
; # (cdr X)
  %25 = inttoptr i64 %0 to i64*
  %26 = getelementptr i64, i64* %25, i32 1
  %27 = load i64, i64* %26
; # (uniFill (cdr X))
  %28 = call i64 @uniFill(i64 %27)
; # (cons Y (uniFill (cdr X)))
  %29 = call i64 @cons(i64 %16, i64 %28)
; # (drop *Safe)
  %30 = inttoptr i64 %20 to i64*
  %31 = getelementptr i64, i64* %30, i32 1
  %32 = load i64, i64* %31
  %33 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %32, i64* %33
  br label %$2
$2:
  %34 = phi i64 [%0, %$4], [%10, %$6], [%29, %$8] ; # ->
  ret i64 %34
}

define i64 @uniRun(i64) align 8 {
$1:
; # (let (P (val $Bind) Q P Z Prg Tos 0) (loop (until (atom (car Z)) ...
; # (val $Bind)
  %1 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  %2 = load i64, i64* %1
; # (loop (until (atom (car Z)) (let U Z (setq Z @) (set U Tos) (setq...
  br label %$2
$2:
  %3 = phi i64 [%0, %$1], [%261, %$13] ; # Prg
  %4 = phi i64 [%2, %$1], [%262, %$13] ; # P
  %5 = phi i64 [%0, %$1], [%263, %$13] ; # Z
  %6 = phi i64 [0, %$1], [%264, %$13] ; # Tos
; # (until (atom (car Z)) (let U Z (setq Z @) (set U Tos) (setq Tos U...
  br label %$3
$3:
  %7 = phi i64 [%3, %$2], [%15, %$4] ; # Prg
  %8 = phi i64 [%4, %$2], [%16, %$4] ; # P
  %9 = phi i64 [%5, %$2], [%12, %$4] ; # Z
  %10 = phi i64 [%6, %$2], [%17, %$4] ; # Tos
; # (car Z)
  %11 = inttoptr i64 %9 to i64*
  %12 = load i64, i64* %11
; # (atom (car Z))
  %13 = and i64 %12, 15
  %14 = icmp ne i64 %13, 0
  br i1 %14, label %$5, label %$4
$4:
  %15 = phi i64 [%7, %$3] ; # Prg
  %16 = phi i64 [%8, %$3] ; # P
  %17 = phi i64 [%9, %$3] ; # Z
  %18 = phi i64 [%10, %$3] ; # Tos
; # (let U Z (setq Z @) (set U Tos) (setq Tos U))
; # (set U Tos)
  %19 = inttoptr i64 %17 to i64*
  store i64 %18, i64* %19
  br label %$3
$5:
  %20 = phi i64 [%7, %$3] ; # Prg
  %21 = phi i64 [%8, %$3] ; # P
  %22 = phi i64 [%9, %$3] ; # Z
  %23 = phi i64 [%10, %$3] ; # Tos
; # (let Y (car Z) (when (and (symb? Y) (<> -ZERO (val Y)) (== (first...
; # (car Z)
  %24 = inttoptr i64 %22 to i64*
  %25 = load i64, i64* %24
; # (when (and (symb? Y) (<> -ZERO (val Y)) (== (firstByte Y) (char "...
; # (and (symb? Y) (<> -ZERO (val Y)) (== (firstByte Y) (char "@")))
; # (symb? Y)
  %26 = xor i64 %25, 8
  %27 = and i64 %26, 14
  %28 = icmp eq i64 %27, 0
  br i1 %28, label %$7, label %$6
$7:
  %29 = phi i64 [%20, %$5] ; # Prg
  %30 = phi i64 [%21, %$5] ; # P
  %31 = phi i64 [%22, %$5] ; # Z
  %32 = phi i64 [%23, %$5] ; # Tos
; # (val Y)
  %33 = inttoptr i64 %25 to i64*
  %34 = load i64, i64* %33
; # (<> -ZERO (val Y))
  %35 = icmp ne i64 10, %34
  br i1 %35, label %$8, label %$6
$8:
  %36 = phi i64 [%29, %$7] ; # Prg
  %37 = phi i64 [%30, %$7] ; # P
  %38 = phi i64 [%31, %$7] ; # Z
  %39 = phi i64 [%32, %$7] ; # Tos
; # (firstByte Y)
  %40 = call i8 @firstByte(i64 %25)
; # (== (firstByte Y) (char "@"))
  %41 = icmp eq i8 %40, 64
  br label %$6
$6:
  %42 = phi i64 [%20, %$5], [%29, %$7], [%36, %$8] ; # Prg
  %43 = phi i64 [%21, %$5], [%30, %$7], [%37, %$8] ; # P
  %44 = phi i64 [%22, %$5], [%31, %$7], [%38, %$8] ; # Z
  %45 = phi i64 [%23, %$5], [%32, %$7], [%39, %$8] ; # Tos
  %46 = phi i1 [0, %$5], [0, %$7], [%41, %$8] ; # ->
  br i1 %46, label %$9, label %$10
$9:
  %47 = phi i64 [%42, %$6] ; # Prg
  %48 = phi i64 [%43, %$6] ; # P
  %49 = phi i64 [%44, %$6] ; # Z
  %50 = phi i64 [%45, %$6] ; # Tos
; # (set $Bind (setq P (push (val Y) Y P)))
; # (val Y)
  %51 = inttoptr i64 %25 to i64*
  %52 = load i64, i64* %51
; # (push (val Y) Y P)
  %53 = alloca i64, i64 3, align 16
  %54 = ptrtoint i64* %53 to i64
  %55 = inttoptr i64 %54 to i64*
  store i64 %52, i64* %55
  %56 = add i64 %54, 8
  %57 = inttoptr i64 %56 to i64*
  store i64 %25, i64* %57
  %58 = add i64 %54, 16
  %59 = inttoptr i64 %58 to i64*
  store i64 %48, i64* %59
  %60 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %54, i64* %60
; # (set Y -ZERO)
  %61 = inttoptr i64 %25 to i64*
  store i64 10, i64* %61
  br label %$10
$10:
  %62 = phi i64 [%42, %$6], [%47, %$9] ; # Prg
  %63 = phi i64 [%43, %$6], [%54, %$9] ; # P
  %64 = phi i64 [%44, %$6], [%49, %$9] ; # Z
  %65 = phi i64 [%45, %$6], [%50, %$9] ; # Tos
; # (loop (? (pair (cdr Z)) (let U Z (setq Z @) (set 2 U Tos) (setq T...
  br label %$11
$11:
  %66 = phi i64 [%62, %$10], [%256, %$40] ; # Prg
  %67 = phi i64 [%63, %$10], [%257, %$40] ; # P
  %68 = phi i64 [%64, %$10], [%258, %$40] ; # Z
  %69 = phi i64 [%65, %$10], [%259, %$40] ; # Tos
; # (? (pair (cdr Z)) (let U Z (setq Z @) (set 2 U Tos) (setq Tos (| ...
; # (cdr Z)
  %70 = inttoptr i64 %68 to i64*
  %71 = getelementptr i64, i64* %70, i32 1
  %72 = load i64, i64* %71
; # (pair (cdr Z))
  %73 = and i64 %72, 15
  %74 = icmp eq i64 %73, 0
  br i1 %74, label %$14, label %$12
$14:
  %75 = phi i64 [%66, %$11] ; # Prg
  %76 = phi i64 [%67, %$11] ; # P
  %77 = phi i64 [%68, %$11] ; # Z
  %78 = phi i64 [%69, %$11] ; # Tos
; # (let U Z (setq Z @) (set 2 U Tos) (setq Tos (| U 8)))
; # (set 2 U Tos)
  %79 = inttoptr i64 %77 to i64*
  %80 = getelementptr i64, i64* %79, i32 1
  store i64 %78, i64* %80
; # (| U 8)
  %81 = or i64 %77, 8
  br label %$13
$12:
  %82 = phi i64 [%66, %$11] ; # Prg
  %83 = phi i64 [%67, %$11] ; # P
  %84 = phi i64 [%68, %$11] ; # Z
  %85 = phi i64 [%69, %$11] ; # Tos
; # (let Y @ (when (and (symb? Y) (<> -ZERO (val Y)) (== (firstByte Y...
; # (when (and (symb? Y) (<> -ZERO (val Y)) (== (firstByte Y) (char "...
; # (and (symb? Y) (<> -ZERO (val Y)) (== (firstByte Y) (char "@")))
; # (symb? Y)
  %86 = xor i64 %72, 8
  %87 = and i64 %86, 14
  %88 = icmp eq i64 %87, 0
  br i1 %88, label %$16, label %$15
$16:
  %89 = phi i64 [%82, %$12] ; # Prg
  %90 = phi i64 [%83, %$12] ; # P
  %91 = phi i64 [%84, %$12] ; # Z
  %92 = phi i64 [%85, %$12] ; # Tos
; # (val Y)
  %93 = inttoptr i64 %72 to i64*
  %94 = load i64, i64* %93
; # (<> -ZERO (val Y))
  %95 = icmp ne i64 10, %94
  br i1 %95, label %$17, label %$15
$17:
  %96 = phi i64 [%89, %$16] ; # Prg
  %97 = phi i64 [%90, %$16] ; # P
  %98 = phi i64 [%91, %$16] ; # Z
  %99 = phi i64 [%92, %$16] ; # Tos
; # (firstByte Y)
  %100 = call i8 @firstByte(i64 %72)
; # (== (firstByte Y) (char "@"))
  %101 = icmp eq i8 %100, 64
  br label %$15
$15:
  %102 = phi i64 [%82, %$12], [%89, %$16], [%96, %$17] ; # Prg
  %103 = phi i64 [%83, %$12], [%90, %$16], [%97, %$17] ; # P
  %104 = phi i64 [%84, %$12], [%91, %$16], [%98, %$17] ; # Z
  %105 = phi i64 [%85, %$12], [%92, %$16], [%99, %$17] ; # Tos
  %106 = phi i1 [0, %$12], [0, %$16], [%101, %$17] ; # ->
  br i1 %106, label %$18, label %$19
$18:
  %107 = phi i64 [%102, %$15] ; # Prg
  %108 = phi i64 [%103, %$15] ; # P
  %109 = phi i64 [%104, %$15] ; # Z
  %110 = phi i64 [%105, %$15] ; # Tos
; # (set $Bind (setq P (push (val Y) Y P)))
; # (val Y)
  %111 = inttoptr i64 %72 to i64*
  %112 = load i64, i64* %111
; # (push (val Y) Y P)
  %113 = alloca i64, i64 3, align 16
  %114 = ptrtoint i64* %113 to i64
  %115 = inttoptr i64 %114 to i64*
  store i64 %112, i64* %115
  %116 = add i64 %114, 8
  %117 = inttoptr i64 %116 to i64*
  store i64 %72, i64* %117
  %118 = add i64 %114, 16
  %119 = inttoptr i64 %118 to i64*
  store i64 %108, i64* %119
  %120 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %114, i64* %120
; # (set Y -ZERO)
  %121 = inttoptr i64 %72 to i64*
  store i64 10, i64* %121
  br label %$19
$19:
  %122 = phi i64 [%102, %$15], [%107, %$18] ; # Prg
  %123 = phi i64 [%103, %$15], [%114, %$18] ; # P
  %124 = phi i64 [%104, %$15], [%109, %$18] ; # Z
  %125 = phi i64 [%105, %$15], [%110, %$18] ; # Tos
; # (loop (unless Tos (let (X P N (car (val (val $Pnl)))) (until (== ...
  br label %$20
$20:
  %126 = phi i64 [%122, %$19], [%246, %$39] ; # Prg
  %127 = phi i64 [%123, %$19], [%247, %$39] ; # P
  %128 = phi i64 [%124, %$19], [%250, %$39] ; # Z
  %129 = phi i64 [%125, %$19], [%253, %$39] ; # Tos
; # (unless Tos (let (X P N (car (val (val $Pnl)))) (until (== Q X) (...
  %130 = icmp ne i64 %129, 0
  br i1 %130, label %$22, label %$21
$21:
  %131 = phi i64 [%126, %$20] ; # Prg
  %132 = phi i64 [%127, %$20] ; # P
  %133 = phi i64 [%128, %$20] ; # Z
  %134 = phi i64 [%129, %$20] ; # Tos
; # (let (X P N (car (val (val $Pnl)))) (until (== Q X) (let Y (val 2...
; # (val $Pnl)
  %135 = load i64, i64* @$Pnl
; # (val (val $Pnl))
  %136 = inttoptr i64 %135 to i64*
  %137 = load i64, i64* %136
; # (car (val (val $Pnl)))
  %138 = inttoptr i64 %137 to i64*
  %139 = load i64, i64* %138
; # (until (== Q X) (let Y (val 2 X) (set Y (lookup N Y))) (setq X (v...
  br label %$23
$23:
  %140 = phi i64 [%131, %$21], [%146, %$24] ; # Prg
  %141 = phi i64 [%132, %$21], [%147, %$24] ; # P
  %142 = phi i64 [%133, %$21], [%148, %$24] ; # Z
  %143 = phi i64 [%134, %$21], [%149, %$24] ; # Tos
  %144 = phi i64 [%132, %$21], [%158, %$24] ; # X
; # (== Q X)
  %145 = icmp eq i64 %2, %144
  br i1 %145, label %$25, label %$24
$24:
  %146 = phi i64 [%140, %$23] ; # Prg
  %147 = phi i64 [%141, %$23] ; # P
  %148 = phi i64 [%142, %$23] ; # Z
  %149 = phi i64 [%143, %$23] ; # Tos
  %150 = phi i64 [%144, %$23] ; # X
; # (let Y (val 2 X) (set Y (lookup N Y)))
; # (val 2 X)
  %151 = inttoptr i64 %150 to i64*
  %152 = getelementptr i64, i64* %151, i32 1
  %153 = load i64, i64* %152
; # (set Y (lookup N Y))
; # (lookup N Y)
  %154 = call i64 @lookup(i64 %139, i64 %153)
  %155 = inttoptr i64 %153 to i64*
  store i64 %154, i64* %155
; # (val 3 X)
  %156 = inttoptr i64 %150 to i64*
  %157 = getelementptr i64, i64* %156, i32 2
  %158 = load i64, i64* %157
  br label %$23
$25:
  %159 = phi i64 [%140, %$23] ; # Prg
  %160 = phi i64 [%141, %$23] ; # P
  %161 = phi i64 [%142, %$23] ; # Z
  %162 = phi i64 [%143, %$23] ; # Tos
  %163 = phi i64 [%144, %$23] ; # X
; # (loop (let X (++ Prg) (when (atom Prg) (setq X (eval X)) (until (...
  br label %$26
$26:
  %164 = phi i64 [%159, %$25], [%227, %$37] ; # Prg
  %165 = phi i64 [%160, %$25], [%228, %$37] ; # P
  %166 = phi i64 [%161, %$25], [%229, %$37] ; # Z
  %167 = phi i64 [%162, %$25], [%230, %$37] ; # Tos
; # (let X (++ Prg) (when (atom Prg) (setq X (eval X)) (until (== Q P...
; # (++ Prg)
  %168 = inttoptr i64 %164 to i64*
  %169 = load i64, i64* %168
  %170 = getelementptr i64, i64* %168, i32 1
  %171 = load i64, i64* %170
; # (when (atom Prg) (setq X (eval X)) (until (== Q P) (set (val 2 P)...
; # (atom Prg)
  %172 = and i64 %171, 15
  %173 = icmp ne i64 %172, 0
  br i1 %173, label %$27, label %$28
$27:
  %174 = phi i64 [%171, %$26] ; # Prg
  %175 = phi i64 [%165, %$26] ; # P
  %176 = phi i64 [%166, %$26] ; # Z
  %177 = phi i64 [%167, %$26] ; # Tos
  %178 = phi i64 [%169, %$26] ; # X
; # (eval X)
  %179 = and i64 %178, 6
  %180 = icmp ne i64 %179, 0
  br i1 %180, label %$31, label %$30
$31:
  br label %$29
$30:
  %181 = and i64 %178, 8
  %182 = icmp ne i64 %181, 0
  br i1 %182, label %$33, label %$32
$33:
  %183 = inttoptr i64 %178 to i64*
  %184 = load i64, i64* %183
  br label %$29
$32:
  %185 = call i64 @evList(i64 %178)
  br label %$29
$29:
  %186 = phi i64 [%178, %$31], [%184, %$33], [%185, %$32] ; # ->
; # (until (== Q P) (set (val 2 P) (val P)) (setq P (val 3 P)))
  br label %$34
$34:
  %187 = phi i64 [%174, %$29], [%193, %$35] ; # Prg
  %188 = phi i64 [%175, %$29], [%206, %$35] ; # P
  %189 = phi i64 [%176, %$29], [%195, %$35] ; # Z
  %190 = phi i64 [%177, %$29], [%196, %$35] ; # Tos
  %191 = phi i64 [%186, %$29], [%197, %$35] ; # X
; # (== Q P)
  %192 = icmp eq i64 %2, %188
  br i1 %192, label %$36, label %$35
$35:
  %193 = phi i64 [%187, %$34] ; # Prg
  %194 = phi i64 [%188, %$34] ; # P
  %195 = phi i64 [%189, %$34] ; # Z
  %196 = phi i64 [%190, %$34] ; # Tos
  %197 = phi i64 [%191, %$34] ; # X
; # (set (val 2 P) (val P))
; # (val 2 P)
  %198 = inttoptr i64 %194 to i64*
  %199 = getelementptr i64, i64* %198, i32 1
  %200 = load i64, i64* %199
; # (val P)
  %201 = inttoptr i64 %194 to i64*
  %202 = load i64, i64* %201
  %203 = inttoptr i64 %200 to i64*
  store i64 %202, i64* %203
; # (val 3 P)
  %204 = inttoptr i64 %194 to i64*
  %205 = getelementptr i64, i64* %204, i32 2
  %206 = load i64, i64* %205
  br label %$34
$36:
  %207 = phi i64 [%187, %$34] ; # Prg
  %208 = phi i64 [%188, %$34] ; # P
  %209 = phi i64 [%189, %$34] ; # Z
  %210 = phi i64 [%190, %$34] ; # Tos
  %211 = phi i64 [%191, %$34] ; # X
; # (set $Bind P)
  %212 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  store i64 %208, i64* %212
; # (ret X)
  ret i64 %211
$28:
  %213 = phi i64 [%171, %$26] ; # Prg
  %214 = phi i64 [%165, %$26] ; # P
  %215 = phi i64 [%166, %$26] ; # Z
  %216 = phi i64 [%167, %$26] ; # Tos
  %217 = phi i64 [%169, %$26] ; # X
; # (and (pair X) (evList X))
; # (pair X)
  %218 = and i64 %217, 15
  %219 = icmp eq i64 %218, 0
  br i1 %219, label %$38, label %$37
$38:
  %220 = phi i64 [%213, %$28] ; # Prg
  %221 = phi i64 [%214, %$28] ; # P
  %222 = phi i64 [%215, %$28] ; # Z
  %223 = phi i64 [%216, %$28] ; # Tos
  %224 = phi i64 [%217, %$28] ; # X
; # (evList X)
  %225 = call i64 @evList(i64 %224)
  %226 = icmp ne i64 %225, 0
  br label %$37
$37:
  %227 = phi i64 [%213, %$28], [%220, %$38] ; # Prg
  %228 = phi i64 [%214, %$28], [%221, %$38] ; # P
  %229 = phi i64 [%215, %$28], [%222, %$38] ; # Z
  %230 = phi i64 [%216, %$28], [%223, %$38] ; # Tos
  %231 = phi i64 [%217, %$28], [%224, %$38] ; # X
  %232 = phi i1 [0, %$28], [%226, %$38] ; # ->
  br label %$26
$22:
  %233 = phi i64 [%126, %$20] ; # Prg
  %234 = phi i64 [%127, %$20] ; # P
  %235 = phi i64 [%128, %$20] ; # Z
  %236 = phi i64 [%129, %$20] ; # Tos
; # (? (=0 (& Tos 8)) (let U Tos (setq Tos (car U)) (set U Z) (setq Z...
; # (& Tos 8)
  %237 = and i64 %236, 8
; # (=0 (& Tos 8))
  %238 = icmp eq i64 %237, 0
  br i1 %238, label %$41, label %$39
$41:
  %239 = phi i64 [%233, %$22] ; # Prg
  %240 = phi i64 [%234, %$22] ; # P
  %241 = phi i64 [%235, %$22] ; # Z
  %242 = phi i64 [%236, %$22] ; # Tos
; # (let U Tos (setq Tos (car U)) (set U Z) (setq Z U))
; # (car U)
  %243 = inttoptr i64 %242 to i64*
  %244 = load i64, i64* %243
; # (set U Z)
  %245 = inttoptr i64 %242 to i64*
  store i64 %241, i64* %245
  br label %$40
$39:
  %246 = phi i64 [%233, %$22] ; # Prg
  %247 = phi i64 [%234, %$22] ; # P
  %248 = phi i64 [%235, %$22] ; # Z
  %249 = phi i64 [%236, %$22] ; # Tos
; # (let U (& Tos -9) (setq Tos (cdr U)) (set 2 U Z) (setq Z U))
; # (& Tos -9)
  %250 = and i64 %249, -9
; # (cdr U)
  %251 = inttoptr i64 %250 to i64*
  %252 = getelementptr i64, i64* %251, i32 1
  %253 = load i64, i64* %252
; # (set 2 U Z)
  %254 = inttoptr i64 %250 to i64*
  %255 = getelementptr i64, i64* %254, i32 1
  store i64 %248, i64* %255
  br label %$20
$40:
  %256 = phi i64 [%239, %$41] ; # Prg
  %257 = phi i64 [%240, %$41] ; # P
  %258 = phi i64 [%242, %$41] ; # Z
  %259 = phi i64 [%244, %$41] ; # Tos
  %260 = phi i64 [%242, %$41] ; # ->
  br label %$11
$13:
  %261 = phi i64 [%75, %$14] ; # Prg
  %262 = phi i64 [%76, %$14] ; # P
  %263 = phi i64 [%72, %$14] ; # Z
  %264 = phi i64 [%81, %$14] ; # Tos
  %265 = phi i64 [%81, %$14] ; # ->
  br label %$2
}

define i64 @_Prove(i64) align 8 {
$1:
; # (let X (cdr Exe) (if (atom (eval (car X))) $Nil (let (Q (save @) ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (if (atom (eval (car X))) $Nil (let (Q (save @) Dbg (if (nil? (ev...
; # (car X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (car X))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (atom (eval (car X)))
  %14 = and i64 %13, 15
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$7, label %$8
$7:
  %16 = phi i64 [%3, %$2] ; # X
  br label %$9
$8:
  %17 = phi i64 [%3, %$2] ; # X
; # (let (Q (save @) Dbg (if (nil? (eval (cadr X))) 0 (save @)) P (pr...
; # (save @)
  %18 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %19 = load i64, i64* %18
  %20 = alloca i64, i64 2, align 16
  %21 = ptrtoint i64* %20 to i64
  %22 = inttoptr i64 %21 to i64*
  store i64 %13, i64* %22
  %23 = add i64 %21, 8
  %24 = inttoptr i64 %23 to i64*
  store i64 %19, i64* %24
  %25 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %21, i64* %25
; # (if (nil? (eval (cadr X))) 0 (save @))
; # (cadr X)
  %26 = inttoptr i64 %17 to i64*
  %27 = getelementptr i64, i64* %26, i32 1
  %28 = load i64, i64* %27
  %29 = inttoptr i64 %28 to i64*
  %30 = load i64, i64* %29
; # (eval (cadr X))
  %31 = and i64 %30, 6
  %32 = icmp ne i64 %31, 0
  br i1 %32, label %$12, label %$11
$12:
  br label %$10
$11:
  %33 = and i64 %30, 8
  %34 = icmp ne i64 %33, 0
  br i1 %34, label %$14, label %$13
$14:
  %35 = inttoptr i64 %30 to i64*
  %36 = load i64, i64* %35
  br label %$10
$13:
  %37 = call i64 @evList(i64 %30)
  br label %$10
$10:
  %38 = phi i64 [%30, %$12], [%36, %$14], [%37, %$13] ; # ->
; # (nil? (eval (cadr X)))
  %39 = icmp eq i64 %38, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %39, label %$15, label %$16
$15:
  %40 = phi i64 [%17, %$10] ; # X
  br label %$17
$16:
  %41 = phi i64 [%17, %$10] ; # X
; # (save @)
  %42 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %43 = load i64, i64* %42
  %44 = alloca i64, i64 2, align 16
  %45 = ptrtoint i64* %44 to i64
  %46 = inttoptr i64 %45 to i64*
  store i64 %38, i64* %46
  %47 = add i64 %45, 8
  %48 = inttoptr i64 %47 to i64*
  store i64 %43, i64* %48
  %49 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %45, i64* %49
  br label %$17
$17:
  %50 = phi i64 [%40, %$15], [%41, %$16] ; # X
  %51 = phi i64 [0, %$15], [%38, %$16] ; # ->
; # (prog1 (caar Q) (set Q (cdar Q)))
; # (caar Q)
  %52 = inttoptr i64 %13 to i64*
  %53 = load i64, i64* %52
  %54 = inttoptr i64 %53 to i64*
  %55 = load i64, i64* %54
; # (set Q (cdar Q))
; # (cdar Q)
  %56 = inttoptr i64 %13 to i64*
  %57 = load i64, i64* %56
  %58 = inttoptr i64 %57 to i64*
  %59 = getelementptr i64, i64* %58, i32 1
  %60 = load i64, i64* %59
  %61 = inttoptr i64 %13 to i64*
  store i64 %60, i64* %61
; # (++ P)
  %62 = inttoptr i64 %55 to i64*
  %63 = load i64, i64* %62
  %64 = getelementptr i64, i64* %62, i32 1
  %65 = load i64, i64* %64
; # (++ P)
  %66 = inttoptr i64 %65 to i64*
  %67 = load i64, i64* %66
  %68 = getelementptr i64, i64* %66, i32 1
  %69 = load i64, i64* %68
; # (push (++ P) NIL)
  %70 = alloca i64, i64 2, align 16
  %71 = ptrtoint i64* %70 to i64
  %72 = inttoptr i64 %71 to i64*
  store i64 %67, i64* %72
; # (link (push (++ P) NIL))
  %73 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %74 = load i64, i64* %73
  %75 = inttoptr i64 %71 to i64*
  %76 = getelementptr i64, i64* %75, i32 1
  store i64 %74, i64* %76
  %77 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %71, i64* %77
; # (++ P)
  %78 = inttoptr i64 %69 to i64*
  %79 = load i64, i64* %78
  %80 = getelementptr i64, i64* %78, i32 1
  %81 = load i64, i64* %80
; # (push (++ P) NIL)
  %82 = alloca i64, i64 2, align 16
  %83 = ptrtoint i64* %82 to i64
  %84 = inttoptr i64 %83 to i64*
  store i64 %79, i64* %84
; # (link (push (++ P) NIL))
  %85 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %86 = load i64, i64* %85
  %87 = inttoptr i64 %83 to i64*
  %88 = getelementptr i64, i64* %87, i32 1
  store i64 %86, i64* %88
  %89 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %83, i64* %89
; # (++ P)
  %90 = inttoptr i64 %81 to i64*
  %91 = load i64, i64* %90
  %92 = getelementptr i64, i64* %90, i32 1
  %93 = load i64, i64* %92
; # (push (++ P) NIL)
  %94 = alloca i64, i64 2, align 16
  %95 = ptrtoint i64* %94 to i64
  %96 = inttoptr i64 %95 to i64*
  store i64 %91, i64* %96
; # (link (push (++ P) NIL))
  %97 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %98 = load i64, i64* %97
  %99 = inttoptr i64 %95 to i64*
  %100 = getelementptr i64, i64* %99, i32 1
  store i64 %98, i64* %100
  %101 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %95, i64* %101
; # (++ P)
  %102 = inttoptr i64 %93 to i64*
  %103 = load i64, i64* %102
  %104 = getelementptr i64, i64* %102, i32 1
  %105 = load i64, i64* %104
; # (push (++ P) NIL)
  %106 = alloca i64, i64 2, align 16
  %107 = ptrtoint i64* %106 to i64
  %108 = inttoptr i64 %107 to i64*
  store i64 %103, i64* %108
; # (link (push (++ P) NIL))
  %109 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %110 = load i64, i64* %109
  %111 = inttoptr i64 %107 to i64*
  %112 = getelementptr i64, i64* %111, i32 1
  store i64 %110, i64* %112
  %113 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %107, i64* %113
; # (push P NIL)
  %114 = alloca i64, i64 2, align 16
  %115 = ptrtoint i64* %114 to i64
  %116 = inttoptr i64 %115 to i64*
  store i64 %105, i64* %116
; # (link (push P NIL))
  %117 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %118 = load i64, i64* %117
  %119 = inttoptr i64 %115 to i64*
  %120 = getelementptr i64, i64* %119, i32 1
  store i64 %118, i64* %120
  %121 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %115, i64* %121
; # (push $Nil NIL)
  %122 = alloca i64, i64 2, align 16
  %123 = ptrtoint i64* %122 to i64
  %124 = inttoptr i64 %123 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %124
; # (link (push $Nil NIL))
  %125 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %126 = load i64, i64* %125
  %127 = inttoptr i64 %123 to i64*
  %128 = getelementptr i64, i64* %127, i32 1
  store i64 %126, i64* %128
  %129 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %123, i64* %129
; # (val $At)
  %130 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  %131 = load i64, i64* %130
; # (save (val $At))
  %132 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %133 = load i64, i64* %132
  %134 = alloca i64, i64 2, align 16
  %135 = ptrtoint i64* %134 to i64
  %136 = inttoptr i64 %135 to i64*
  store i64 %131, i64* %136
  %137 = add i64 %135, 8
  %138 = inttoptr i64 %137 to i64*
  store i64 %133, i64* %138
  %139 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %135, i64* %139
; # (val $Penv)
  %140 = load i64, i64* @$Penv
; # (val $Pnl)
  %141 = load i64, i64* @$Pnl
; # (set $Penv Env $Pnl Nl)
  store i64 %115, i64* @$Penv
  store i64 %71, i64* @$Pnl
; # (while (or (pair (val Tp1)) (pair (val Tp2))) (sigChk Exe) (cond ...
  br label %$18
$18:
  %142 = phi i64 [%50, %$17], [%649, %$25] ; # X
  %143 = phi i64 [%105, %$17], [%650, %$25] ; # P
  %144 = phi i64 [%63, %$17], [%651, %$25] ; # N
; # (or (pair (val Tp1)) (pair (val Tp2)))
; # (val Tp1)
  %145 = inttoptr i64 %95 to i64*
  %146 = load i64, i64* %145
; # (pair (val Tp1))
  %147 = and i64 %146, 15
  %148 = icmp eq i64 %147, 0
  br i1 %148, label %$19, label %$20
$20:
  %149 = phi i64 [%142, %$18] ; # X
  %150 = phi i64 [%143, %$18] ; # P
  %151 = phi i64 [%144, %$18] ; # N
; # (val Tp2)
  %152 = inttoptr i64 %107 to i64*
  %153 = load i64, i64* %152
; # (pair (val Tp2))
  %154 = and i64 %153, 15
  %155 = icmp eq i64 %154, 0
  br label %$19
$19:
  %156 = phi i64 [%142, %$18], [%149, %$20] ; # X
  %157 = phi i64 [%143, %$18], [%150, %$20] ; # P
  %158 = phi i64 [%144, %$18], [%151, %$20] ; # N
  %159 = phi i1 [1, %$18], [%155, %$20] ; # ->
  br i1 %159, label %$21, label %$22
$21:
  %160 = phi i64 [%156, %$19] ; # X
  %161 = phi i64 [%157, %$19] ; # P
  %162 = phi i64 [%158, %$19] ; # N
; # (sigChk Exe)
  %163 = load volatile i32, i32* bitcast ([16 x i32]* @$Signal to i32*)
  %164 = icmp ne i32 %163, 0
  br i1 %164, label %$23, label %$24
$23:
  call void @sighandler(i64 %0)
  br label %$24
$24:
; # (cond ((pair (val Alt)) (set E (val Env)) (ifn (unify (car (val N...
; # (val Alt)
  %165 = inttoptr i64 %83 to i64*
  %166 = load i64, i64* %165
; # (pair (val Alt))
  %167 = and i64 %166, 15
  %168 = icmp eq i64 %167, 0
  br i1 %168, label %$27, label %$26
$27:
  %169 = phi i64 [%160, %$24] ; # X
  %170 = phi i64 [%161, %$24] ; # P
  %171 = phi i64 [%162, %$24] ; # N
; # (set E (val Env))
; # (val Env)
  %172 = inttoptr i64 %115 to i64*
  %173 = load i64, i64* %172
  %174 = inttoptr i64 %123 to i64*
  store i64 %173, i64* %174
; # (ifn (unify (car (val Nl)) (cdar (val Tp1)) N (caar (val Alt))) (...
; # (val Nl)
  %175 = inttoptr i64 %71 to i64*
  %176 = load i64, i64* %175
; # (car (val Nl))
  %177 = inttoptr i64 %176 to i64*
  %178 = load i64, i64* %177
; # (val Tp1)
  %179 = inttoptr i64 %95 to i64*
  %180 = load i64, i64* %179
; # (cdar (val Tp1))
  %181 = inttoptr i64 %180 to i64*
  %182 = load i64, i64* %181
  %183 = inttoptr i64 %182 to i64*
  %184 = getelementptr i64, i64* %183, i32 1
  %185 = load i64, i64* %184
; # (val Alt)
  %186 = inttoptr i64 %83 to i64*
  %187 = load i64, i64* %186
; # (caar (val Alt))
  %188 = inttoptr i64 %187 to i64*
  %189 = load i64, i64* %188
  %190 = inttoptr i64 %189 to i64*
  %191 = load i64, i64* %190
; # (unify (car (val Nl)) (cdar (val Tp1)) N (caar (val Alt)))
  %192 = call i1 @unify(i64 %178, i64 %185, i64 %171, i64 %191)
  br i1 %192, label %$29, label %$28
$28:
  %193 = phi i64 [%169, %$27] ; # X
  %194 = phi i64 [%170, %$27] ; # P
  %195 = phi i64 [%171, %$27] ; # N
; # (when (atom (set Alt (cdr (val Alt)))) (setq P (caar Q)) (set Q (...
; # (set Alt (cdr (val Alt)))
; # (val Alt)
  %196 = inttoptr i64 %83 to i64*
  %197 = load i64, i64* %196
; # (cdr (val Alt))
  %198 = inttoptr i64 %197 to i64*
  %199 = getelementptr i64, i64* %198, i32 1
  %200 = load i64, i64* %199
  %201 = inttoptr i64 %83 to i64*
  store i64 %200, i64* %201
; # (atom (set Alt (cdr (val Alt))))
  %202 = and i64 %200, 15
  %203 = icmp ne i64 %202, 0
  br i1 %203, label %$31, label %$32
$31:
  %204 = phi i64 [%193, %$28] ; # X
  %205 = phi i64 [%194, %$28] ; # P
  %206 = phi i64 [%195, %$28] ; # N
; # (caar Q)
  %207 = inttoptr i64 %13 to i64*
  %208 = load i64, i64* %207
  %209 = inttoptr i64 %208 to i64*
  %210 = load i64, i64* %209
; # (set Q (cdar Q))
; # (cdar Q)
  %211 = inttoptr i64 %13 to i64*
  %212 = load i64, i64* %211
  %213 = inttoptr i64 %212 to i64*
  %214 = getelementptr i64, i64* %213, i32 1
  %215 = load i64, i64* %214
  %216 = inttoptr i64 %13 to i64*
  store i64 %215, i64* %216
; # (++ P)
  %217 = inttoptr i64 %210 to i64*
  %218 = load i64, i64* %217
  %219 = getelementptr i64, i64* %217, i32 1
  %220 = load i64, i64* %219
; # (set Nl (++ P) Alt (++ P) Tp1 (++ P) Tp2 (++ P) Env P)
; # (++ P)
  %221 = inttoptr i64 %220 to i64*
  %222 = load i64, i64* %221
  %223 = getelementptr i64, i64* %221, i32 1
  %224 = load i64, i64* %223
  %225 = inttoptr i64 %71 to i64*
  store i64 %222, i64* %225
; # (++ P)
  %226 = inttoptr i64 %224 to i64*
  %227 = load i64, i64* %226
  %228 = getelementptr i64, i64* %226, i32 1
  %229 = load i64, i64* %228
  %230 = inttoptr i64 %83 to i64*
  store i64 %227, i64* %230
; # (++ P)
  %231 = inttoptr i64 %229 to i64*
  %232 = load i64, i64* %231
  %233 = getelementptr i64, i64* %231, i32 1
  %234 = load i64, i64* %233
  %235 = inttoptr i64 %95 to i64*
  store i64 %232, i64* %235
; # (++ P)
  %236 = inttoptr i64 %234 to i64*
  %237 = load i64, i64* %236
  %238 = getelementptr i64, i64* %236, i32 1
  %239 = load i64, i64* %238
  %240 = inttoptr i64 %107 to i64*
  store i64 %237, i64* %240
  %241 = inttoptr i64 %115 to i64*
  store i64 %239, i64* %241
  br label %$32
$32:
  %242 = phi i64 [%193, %$28], [%204, %$31] ; # X
  %243 = phi i64 [%194, %$28], [%239, %$31] ; # P
  %244 = phi i64 [%195, %$28], [%218, %$31] ; # N
  br label %$30
$29:
  %245 = phi i64 [%169, %$27] ; # X
  %246 = phi i64 [%170, %$27] ; # P
  %247 = phi i64 [%171, %$27] ; # N
; # (when Dbg (let Y (car (val Tp1)) (when (memq (car Y) Dbg) (let (L...
  %248 = icmp ne i64 %51, 0
  br i1 %248, label %$33, label %$34
$33:
  %249 = phi i64 [%245, %$29] ; # X
  %250 = phi i64 [%246, %$29] ; # P
  %251 = phi i64 [%247, %$29] ; # N
; # (let Y (car (val Tp1)) (when (memq (car Y) Dbg) (let (L (get (car...
; # (val Tp1)
  %252 = inttoptr i64 %95 to i64*
  %253 = load i64, i64* %252
; # (car (val Tp1))
  %254 = inttoptr i64 %253 to i64*
  %255 = load i64, i64* %254
; # (when (memq (car Y) Dbg) (let (L (get (car Y) $T) I 1) (until (eq...
; # (car Y)
  %256 = inttoptr i64 %255 to i64*
  %257 = load i64, i64* %256
; # (memq (car Y) Dbg)
  br label %$35
$35:
  %258 = phi i64 [%51, %$33], [%270, %$39] ; # L
  %259 = and i64 %258, 15
  %260 = icmp ne i64 %259, 0
  br i1 %260, label %$38, label %$36
$38:
  %261 = phi i64 [%258, %$35] ; # L
  br label %$37
$36:
  %262 = phi i64 [%258, %$35] ; # L
  %263 = inttoptr i64 %262 to i64*
  %264 = load i64, i64* %263
  %265 = icmp eq i64 %257, %264
  br i1 %265, label %$40, label %$39
$40:
  %266 = phi i64 [%262, %$36] ; # L
  br label %$37
$39:
  %267 = phi i64 [%262, %$36] ; # L
  %268 = inttoptr i64 %267 to i64*
  %269 = getelementptr i64, i64* %268, i32 1
  %270 = load i64, i64* %269
  br label %$35
$37:
  %271 = phi i64 [%261, %$38], [%266, %$40] ; # L
  %272 = phi i1 [0, %$38], [1, %$40] ; # ->
  br i1 %272, label %$41, label %$42
$41:
  %273 = phi i64 [%249, %$37] ; # X
  %274 = phi i64 [%250, %$37] ; # P
  %275 = phi i64 [%251, %$37] ; # N
; # (let (L (get (car Y) $T) I 1) (until (equal (car (val Alt)) (car ...
; # (car Y)
  %276 = inttoptr i64 %255 to i64*
  %277 = load i64, i64* %276
; # (get (car Y) $T)
  %278 = call i64 @get(i64 %277, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64))
; # (until (equal (car (val Alt)) (car L)) (inc 'I) (shift L))
  br label %$43
$43:
  %279 = phi i64 [%273, %$41], [%291, %$44] ; # X
  %280 = phi i64 [%274, %$41], [%292, %$44] ; # P
  %281 = phi i64 [%275, %$41], [%293, %$44] ; # N
  %282 = phi i64 [%278, %$41], [%299, %$44] ; # L
  %283 = phi i64 [1, %$41], [%296, %$44] ; # I
; # (val Alt)
  %284 = inttoptr i64 %83 to i64*
  %285 = load i64, i64* %284
; # (car (val Alt))
  %286 = inttoptr i64 %285 to i64*
  %287 = load i64, i64* %286
; # (car L)
  %288 = inttoptr i64 %282 to i64*
  %289 = load i64, i64* %288
; # (equal (car (val Alt)) (car L))
  %290 = call i1 @equal(i64 %287, i64 %289)
  br i1 %290, label %$45, label %$44
$44:
  %291 = phi i64 [%279, %$43] ; # X
  %292 = phi i64 [%280, %$43] ; # P
  %293 = phi i64 [%281, %$43] ; # N
  %294 = phi i64 [%282, %$43] ; # L
  %295 = phi i64 [%283, %$43] ; # I
; # (inc 'I)
  %296 = add i64 %295, 1
; # (shift L)
  %297 = inttoptr i64 %294 to i64*
  %298 = getelementptr i64, i64* %297, i32 1
  %299 = load i64, i64* %298
  br label %$43
$45:
  %300 = phi i64 [%279, %$43] ; # X
  %301 = phi i64 [%280, %$43] ; # P
  %302 = phi i64 [%281, %$43] ; # N
  %303 = phi i64 [%282, %$43] ; # L
  %304 = phi i64 [%283, %$43] ; # I
; # (outWord I)
  call void @outWord(i64 %304)
; # (space)
  call void @space()
; # (uniFill Y)
  %305 = call i64 @uniFill(i64 %255)
; # (print (uniFill Y))
  call void @print(i64 %305)
; # (newline)
  call void @newline()
  br label %$42
$42:
  %306 = phi i64 [%249, %$37], [%300, %$45] ; # X
  %307 = phi i64 [%250, %$37], [%301, %$45] ; # P
  %308 = phi i64 [%251, %$37], [%302, %$45] ; # N
  br label %$34
$34:
  %309 = phi i64 [%245, %$29], [%306, %$42] ; # X
  %310 = phi i64 [%246, %$29], [%307, %$42] ; # P
  %311 = phi i64 [%247, %$29], [%308, %$42] ; # N
; # (when (pair (cdr (val Alt))) (set Q (cons (cons N (cons (val Nl) ...
; # (val Alt)
  %312 = inttoptr i64 %83 to i64*
  %313 = load i64, i64* %312
; # (cdr (val Alt))
  %314 = inttoptr i64 %313 to i64*
  %315 = getelementptr i64, i64* %314, i32 1
  %316 = load i64, i64* %315
; # (pair (cdr (val Alt)))
  %317 = and i64 %316, 15
  %318 = icmp eq i64 %317, 0
  br i1 %318, label %$46, label %$47
$46:
  %319 = phi i64 [%309, %$34] ; # X
  %320 = phi i64 [%310, %$34] ; # P
  %321 = phi i64 [%311, %$34] ; # N
; # (set Q (cons (cons N (cons (val Nl) (cons @ (cons (val Tp1) (cons...
; # (val Nl)
  %322 = inttoptr i64 %71 to i64*
  %323 = load i64, i64* %322
; # (val Tp1)
  %324 = inttoptr i64 %95 to i64*
  %325 = load i64, i64* %324
; # (val Tp2)
  %326 = inttoptr i64 %107 to i64*
  %327 = load i64, i64* %326
; # (val E)
  %328 = inttoptr i64 %123 to i64*
  %329 = load i64, i64* %328
; # (cons (val Tp2) (val E))
  %330 = call i64 @cons(i64 %327, i64 %329)
; # (cons (val Tp1) (cons (val Tp2) (val E)))
  %331 = call i64 @cons(i64 %325, i64 %330)
; # (cons @ (cons (val Tp1) (cons (val Tp2) (val E))))
  %332 = call i64 @cons(i64 %316, i64 %331)
; # (cons (val Nl) (cons @ (cons (val Tp1) (cons (val Tp2) (val E))))...
  %333 = call i64 @cons(i64 %323, i64 %332)
; # (cons N (cons (val Nl) (cons @ (cons (val Tp1) (cons (val Tp2) (v...
  %334 = call i64 @cons(i64 %321, i64 %333)
; # (car Q)
  %335 = inttoptr i64 %13 to i64*
  %336 = load i64, i64* %335
; # (cons (cons N (cons (val Nl) (cons @ (cons (val Tp1) (cons (val T...
  %337 = call i64 @cons(i64 %334, i64 %336)
  %338 = inttoptr i64 %13 to i64*
  store i64 %337, i64* %338
  br label %$47
$47:
  %339 = phi i64 [%309, %$34], [%319, %$46] ; # X
  %340 = phi i64 [%310, %$34], [%320, %$46] ; # P
  %341 = phi i64 [%311, %$34], [%321, %$46] ; # N
; # (set Nl (cons N (val Nl)) Tp2 (cons (cdr (val Tp1)) (val Tp2)) Tp...
; # (val Nl)
  %342 = inttoptr i64 %71 to i64*
  %343 = load i64, i64* %342
; # (cons N (val Nl))
  %344 = call i64 @cons(i64 %341, i64 %343)
  %345 = inttoptr i64 %71 to i64*
  store i64 %344, i64* %345
; # (val Tp1)
  %346 = inttoptr i64 %95 to i64*
  %347 = load i64, i64* %346
; # (cdr (val Tp1))
  %348 = inttoptr i64 %347 to i64*
  %349 = getelementptr i64, i64* %348, i32 1
  %350 = load i64, i64* %349
; # (val Tp2)
  %351 = inttoptr i64 %107 to i64*
  %352 = load i64, i64* %351
; # (cons (cdr (val Tp1)) (val Tp2))
  %353 = call i64 @cons(i64 %350, i64 %352)
  %354 = inttoptr i64 %107 to i64*
  store i64 %353, i64* %354
; # (val Alt)
  %355 = inttoptr i64 %83 to i64*
  %356 = load i64, i64* %355
; # (cdar (val Alt))
  %357 = inttoptr i64 %356 to i64*
  %358 = load i64, i64* %357
  %359 = inttoptr i64 %358 to i64*
  %360 = getelementptr i64, i64* %359, i32 1
  %361 = load i64, i64* %360
  %362 = inttoptr i64 %95 to i64*
  store i64 %361, i64* %362
  %363 = inttoptr i64 %83 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %363
; # (inc 'N (hex "10"))
  %364 = add i64 %341, 16
  br label %$30
$30:
  %365 = phi i64 [%242, %$32], [%339, %$47] ; # X
  %366 = phi i64 [%243, %$32], [%340, %$47] ; # P
  %367 = phi i64 [%244, %$32], [%364, %$47] ; # N
  br label %$25
$26:
  %368 = phi i64 [%160, %$24] ; # X
  %369 = phi i64 [%161, %$24] ; # P
  %370 = phi i64 [%162, %$24] ; # N
; # (val Tp1)
  %371 = inttoptr i64 %95 to i64*
  %372 = load i64, i64* %371
; # (atom (setq X (val Tp1)))
  %373 = and i64 %372, 15
  %374 = icmp ne i64 %373, 0
  br i1 %374, label %$49, label %$48
$49:
  %375 = phi i64 [%372, %$26] ; # X
  %376 = phi i64 [%369, %$26] ; # P
  %377 = phi i64 [%370, %$26] ; # N
; # (set Tp1 (car (val Tp2)) Tp2 (cdr (val Tp2)) Nl (cdr (val Nl)))
; # (val Tp2)
  %378 = inttoptr i64 %107 to i64*
  %379 = load i64, i64* %378
; # (car (val Tp2))
  %380 = inttoptr i64 %379 to i64*
  %381 = load i64, i64* %380
  %382 = inttoptr i64 %95 to i64*
  store i64 %381, i64* %382
; # (val Tp2)
  %383 = inttoptr i64 %107 to i64*
  %384 = load i64, i64* %383
; # (cdr (val Tp2))
  %385 = inttoptr i64 %384 to i64*
  %386 = getelementptr i64, i64* %385, i32 1
  %387 = load i64, i64* %386
  %388 = inttoptr i64 %107 to i64*
  store i64 %387, i64* %388
; # (val Nl)
  %389 = inttoptr i64 %71 to i64*
  %390 = load i64, i64* %389
; # (cdr (val Nl))
  %391 = inttoptr i64 %390 to i64*
  %392 = getelementptr i64, i64* %391, i32 1
  %393 = load i64, i64* %392
  %394 = inttoptr i64 %71 to i64*
  store i64 %393, i64* %394
  br label %$25
$48:
  %395 = phi i64 [%372, %$26] ; # X
  %396 = phi i64 [%369, %$26] ; # P
  %397 = phi i64 [%370, %$26] ; # N
; # (car X)
  %398 = inttoptr i64 %395 to i64*
  %399 = load i64, i64* %398
; # (atom (car X))
  %400 = and i64 %399, 15
  %401 = icmp ne i64 %400, 0
  br i1 %401, label %$51, label %$50
$51:
  %402 = phi i64 [%395, %$48] ; # X
  %403 = phi i64 [%396, %$48] ; # P
  %404 = phi i64 [%397, %$48] ; # N
; # (while (and (pair (car Q)) (>= (caar @) (car (val Nl)))) (set Q (...
  br label %$52
$52:
  %405 = phi i64 [%402, %$51], [%428, %$55] ; # X
  %406 = phi i64 [%403, %$51], [%429, %$55] ; # P
  %407 = phi i64 [%404, %$51], [%430, %$55] ; # N
; # (and (pair (car Q)) (>= (caar @) (car (val Nl))))
; # (car Q)
  %408 = inttoptr i64 %13 to i64*
  %409 = load i64, i64* %408
; # (pair (car Q))
  %410 = and i64 %409, 15
  %411 = icmp eq i64 %410, 0
  br i1 %411, label %$54, label %$53
$54:
  %412 = phi i64 [%405, %$52] ; # X
  %413 = phi i64 [%406, %$52] ; # P
  %414 = phi i64 [%407, %$52] ; # N
; # (caar @)
  %415 = inttoptr i64 %409 to i64*
  %416 = load i64, i64* %415
  %417 = inttoptr i64 %416 to i64*
  %418 = load i64, i64* %417
; # (val Nl)
  %419 = inttoptr i64 %71 to i64*
  %420 = load i64, i64* %419
; # (car (val Nl))
  %421 = inttoptr i64 %420 to i64*
  %422 = load i64, i64* %421
; # (>= (caar @) (car (val Nl)))
  %423 = icmp uge i64 %418, %422
  br label %$53
$53:
  %424 = phi i64 [%405, %$52], [%412, %$54] ; # X
  %425 = phi i64 [%406, %$52], [%413, %$54] ; # P
  %426 = phi i64 [%407, %$52], [%414, %$54] ; # N
  %427 = phi i1 [0, %$52], [%423, %$54] ; # ->
  br i1 %427, label %$55, label %$56
$55:
  %428 = phi i64 [%424, %$53] ; # X
  %429 = phi i64 [%425, %$53] ; # P
  %430 = phi i64 [%426, %$53] ; # N
; # (set Q (cdar Q))
; # (cdar Q)
  %431 = inttoptr i64 %13 to i64*
  %432 = load i64, i64* %431
  %433 = inttoptr i64 %432 to i64*
  %434 = getelementptr i64, i64* %433, i32 1
  %435 = load i64, i64* %434
  %436 = inttoptr i64 %13 to i64*
  store i64 %435, i64* %436
  br label %$52
$56:
  %437 = phi i64 [%424, %$53] ; # X
  %438 = phi i64 [%425, %$53] ; # P
  %439 = phi i64 [%426, %$53] ; # N
; # (set Tp1 (cdr X))
; # (cdr X)
  %440 = inttoptr i64 %437 to i64*
  %441 = getelementptr i64, i64* %440, i32 1
  %442 = load i64, i64* %441
  %443 = inttoptr i64 %95 to i64*
  store i64 %442, i64* %443
  br label %$25
$50:
  %444 = phi i64 [%395, %$48] ; # X
  %445 = phi i64 [%396, %$48] ; # P
  %446 = phi i64 [%397, %$48] ; # N
; # (car @)
  %447 = inttoptr i64 %399 to i64*
  %448 = load i64, i64* %447
; # (cnt? (car @))
  %449 = and i64 %448, 2
  %450 = icmp ne i64 %449, 0
  br i1 %450, label %$58, label %$57
$58:
  %451 = phi i64 [%444, %$50] ; # X
  %452 = phi i64 [%445, %$50] ; # P
  %453 = phi i64 [%446, %$50] ; # N
; # (set E (uniRun (cdar X)))
; # (cdar X)
  %454 = inttoptr i64 %451 to i64*
  %455 = load i64, i64* %454
  %456 = inttoptr i64 %455 to i64*
  %457 = getelementptr i64, i64* %456, i32 1
  %458 = load i64, i64* %457
; # (uniRun (cdar X))
  %459 = call i64 @uniRun(i64 %458)
  %460 = inttoptr i64 %123 to i64*
  store i64 %459, i64* %460
; # (let (I (int (caar X)) Y (val Nl)) (while (gt0 (dec 'I)) (shift Y...
; # (caar X)
  %461 = inttoptr i64 %451 to i64*
  %462 = load i64, i64* %461
  %463 = inttoptr i64 %462 to i64*
  %464 = load i64, i64* %463
; # (int (caar X))
  %465 = lshr i64 %464, 4
; # (val Nl)
  %466 = inttoptr i64 %71 to i64*
  %467 = load i64, i64* %466
; # (while (gt0 (dec 'I)) (shift Y))
  br label %$59
$59:
  %468 = phi i64 [%451, %$58], [%475, %$60] ; # X
  %469 = phi i64 [%452, %$58], [%476, %$60] ; # P
  %470 = phi i64 [%453, %$58], [%477, %$60] ; # N
  %471 = phi i64 [%465, %$58], [%478, %$60] ; # I
  %472 = phi i64 [%467, %$58], [%482, %$60] ; # Y
; # (dec 'I)
  %473 = sub i64 %471, 1
; # (gt0 (dec 'I))
  %474 = icmp sgt i64 %473, 0
  br i1 %474, label %$60, label %$61
$60:
  %475 = phi i64 [%468, %$59] ; # X
  %476 = phi i64 [%469, %$59] ; # P
  %477 = phi i64 [%470, %$59] ; # N
  %478 = phi i64 [%473, %$59] ; # I
  %479 = phi i64 [%472, %$59] ; # Y
; # (shift Y)
  %480 = inttoptr i64 %479 to i64*
  %481 = getelementptr i64, i64* %480, i32 1
  %482 = load i64, i64* %481
  br label %$59
$61:
  %483 = phi i64 [%468, %$59] ; # X
  %484 = phi i64 [%469, %$59] ; # P
  %485 = phi i64 [%470, %$59] ; # N
  %486 = phi i64 [%473, %$59] ; # I
  %487 = phi i64 [%472, %$59] ; # Y
; # (set Nl (cons (car Y) (val Nl)) Tp2 (cons (cdr X) (val Tp2)) Tp1 ...
; # (car Y)
  %488 = inttoptr i64 %487 to i64*
  %489 = load i64, i64* %488
; # (val Nl)
  %490 = inttoptr i64 %71 to i64*
  %491 = load i64, i64* %490
; # (cons (car Y) (val Nl))
  %492 = call i64 @cons(i64 %489, i64 %491)
  %493 = inttoptr i64 %71 to i64*
  store i64 %492, i64* %493
; # (cdr X)
  %494 = inttoptr i64 %483 to i64*
  %495 = getelementptr i64, i64* %494, i32 1
  %496 = load i64, i64* %495
; # (val Tp2)
  %497 = inttoptr i64 %107 to i64*
  %498 = load i64, i64* %497
; # (cons (cdr X) (val Tp2))
  %499 = call i64 @cons(i64 %496, i64 %498)
  %500 = inttoptr i64 %107 to i64*
  store i64 %499, i64* %500
; # (val E)
  %501 = inttoptr i64 %123 to i64*
  %502 = load i64, i64* %501
  %503 = inttoptr i64 %95 to i64*
  store i64 %502, i64* %503
  br label %$25
$57:
  %504 = phi i64 [%444, %$50] ; # X
  %505 = phi i64 [%445, %$50] ; # P
  %506 = phi i64 [%446, %$50] ; # N
; # (== @ $Up)
  %507 = icmp eq i64 %448, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 728) to i64)
  br i1 %507, label %$63, label %$62
$63:
  %508 = phi i64 [%504, %$57] ; # X
  %509 = phi i64 [%505, %$57] ; # P
  %510 = phi i64 [%506, %$57] ; # N
; # (if (and (not (nil? (set E (uniRun (cddr (car X)))))) (unify (car...
; # (and (not (nil? (set E (uniRun (cddr (car X)))))) (unify (car (va...
; # (set E (uniRun (cddr (car X))))
; # (car X)
  %511 = inttoptr i64 %508 to i64*
  %512 = load i64, i64* %511
; # (cddr (car X))
  %513 = inttoptr i64 %512 to i64*
  %514 = getelementptr i64, i64* %513, i32 1
  %515 = load i64, i64* %514
  %516 = inttoptr i64 %515 to i64*
  %517 = getelementptr i64, i64* %516, i32 1
  %518 = load i64, i64* %517
; # (uniRun (cddr (car X)))
  %519 = call i64 @uniRun(i64 %518)
  %520 = inttoptr i64 %123 to i64*
  store i64 %519, i64* %520
; # (nil? (set E (uniRun (cddr (car X)))))
  %521 = icmp eq i64 %519, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
; # (not (nil? (set E (uniRun (cddr (car X))))))
  %522 = icmp eq i1 %521, 0
  br i1 %522, label %$65, label %$64
$65:
  %523 = phi i64 [%508, %$63] ; # X
  %524 = phi i64 [%509, %$63] ; # P
  %525 = phi i64 [%510, %$63] ; # N
; # (val Nl)
  %526 = inttoptr i64 %71 to i64*
  %527 = load i64, i64* %526
; # (car (val Nl))
  %528 = inttoptr i64 %527 to i64*
  %529 = load i64, i64* %528
; # (car X)
  %530 = inttoptr i64 %523 to i64*
  %531 = load i64, i64* %530
; # (cadr (car X))
  %532 = inttoptr i64 %531 to i64*
  %533 = getelementptr i64, i64* %532, i32 1
  %534 = load i64, i64* %533
  %535 = inttoptr i64 %534 to i64*
  %536 = load i64, i64* %535
; # (val Nl)
  %537 = inttoptr i64 %71 to i64*
  %538 = load i64, i64* %537
; # (car (val Nl))
  %539 = inttoptr i64 %538 to i64*
  %540 = load i64, i64* %539
; # (val E)
  %541 = inttoptr i64 %123 to i64*
  %542 = load i64, i64* %541
; # (unify (car (val Nl)) (cadr (car X)) (car (val Nl)) (val E))
  %543 = call i1 @unify(i64 %529, i64 %536, i64 %540, i64 %542)
  br label %$64
$64:
  %544 = phi i64 [%508, %$63], [%523, %$65] ; # X
  %545 = phi i64 [%509, %$63], [%524, %$65] ; # P
  %546 = phi i64 [%510, %$63], [%525, %$65] ; # N
  %547 = phi i1 [0, %$63], [%543, %$65] ; # ->
  br i1 %547, label %$66, label %$67
$66:
  %548 = phi i64 [%544, %$64] ; # X
  %549 = phi i64 [%545, %$64] ; # P
  %550 = phi i64 [%546, %$64] ; # N
; # (set Tp1 (cdr X))
; # (cdr X)
  %551 = inttoptr i64 %548 to i64*
  %552 = getelementptr i64, i64* %551, i32 1
  %553 = load i64, i64* %552
  %554 = inttoptr i64 %95 to i64*
  store i64 %553, i64* %554
  br label %$68
$67:
  %555 = phi i64 [%544, %$64] ; # X
  %556 = phi i64 [%545, %$64] ; # P
  %557 = phi i64 [%546, %$64] ; # N
; # (caar Q)
  %558 = inttoptr i64 %13 to i64*
  %559 = load i64, i64* %558
  %560 = inttoptr i64 %559 to i64*
  %561 = load i64, i64* %560
; # (set Q (cdar Q))
; # (cdar Q)
  %562 = inttoptr i64 %13 to i64*
  %563 = load i64, i64* %562
  %564 = inttoptr i64 %563 to i64*
  %565 = getelementptr i64, i64* %564, i32 1
  %566 = load i64, i64* %565
  %567 = inttoptr i64 %13 to i64*
  store i64 %566, i64* %567
; # (++ P)
  %568 = inttoptr i64 %561 to i64*
  %569 = load i64, i64* %568
  %570 = getelementptr i64, i64* %568, i32 1
  %571 = load i64, i64* %570
; # (set Nl (++ P) Alt (++ P) Tp1 (++ P) Tp2 (++ P) Env P)
; # (++ P)
  %572 = inttoptr i64 %571 to i64*
  %573 = load i64, i64* %572
  %574 = getelementptr i64, i64* %572, i32 1
  %575 = load i64, i64* %574
  %576 = inttoptr i64 %71 to i64*
  store i64 %573, i64* %576
; # (++ P)
  %577 = inttoptr i64 %575 to i64*
  %578 = load i64, i64* %577
  %579 = getelementptr i64, i64* %577, i32 1
  %580 = load i64, i64* %579
  %581 = inttoptr i64 %83 to i64*
  store i64 %578, i64* %581
; # (++ P)
  %582 = inttoptr i64 %580 to i64*
  %583 = load i64, i64* %582
  %584 = getelementptr i64, i64* %582, i32 1
  %585 = load i64, i64* %584
  %586 = inttoptr i64 %95 to i64*
  store i64 %583, i64* %586
; # (++ P)
  %587 = inttoptr i64 %585 to i64*
  %588 = load i64, i64* %587
  %589 = getelementptr i64, i64* %587, i32 1
  %590 = load i64, i64* %589
  %591 = inttoptr i64 %107 to i64*
  store i64 %588, i64* %591
  %592 = inttoptr i64 %115 to i64*
  store i64 %590, i64* %592
  br label %$68
$68:
  %593 = phi i64 [%548, %$66], [%555, %$67] ; # X
  %594 = phi i64 [%549, %$66], [%590, %$67] ; # P
  %595 = phi i64 [%550, %$66], [%569, %$67] ; # N
  %596 = phi i64 [%553, %$66], [%590, %$67] ; # ->
  br label %$25
$62:
  %597 = phi i64 [%504, %$57] ; # X
  %598 = phi i64 [%505, %$57] ; # P
  %599 = phi i64 [%506, %$57] ; # N
; # (set Alt (get (caar X) $T))
; # (caar X)
  %600 = inttoptr i64 %597 to i64*
  %601 = load i64, i64* %600
  %602 = inttoptr i64 %601 to i64*
  %603 = load i64, i64* %602
; # (get (caar X) $T)
  %604 = call i64 @get(i64 %603, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64))
  %605 = inttoptr i64 %83 to i64*
  store i64 %604, i64* %605
; # (atom (set Alt (get (caar X) $T)))
  %606 = and i64 %604, 15
  %607 = icmp ne i64 %606, 0
  br i1 %607, label %$70, label %$69
$70:
  %608 = phi i64 [%597, %$62] ; # X
  %609 = phi i64 [%598, %$62] ; # P
  %610 = phi i64 [%599, %$62] ; # N
; # (caar Q)
  %611 = inttoptr i64 %13 to i64*
  %612 = load i64, i64* %611
  %613 = inttoptr i64 %612 to i64*
  %614 = load i64, i64* %613
; # (set Q (cdar Q))
; # (cdar Q)
  %615 = inttoptr i64 %13 to i64*
  %616 = load i64, i64* %615
  %617 = inttoptr i64 %616 to i64*
  %618 = getelementptr i64, i64* %617, i32 1
  %619 = load i64, i64* %618
  %620 = inttoptr i64 %13 to i64*
  store i64 %619, i64* %620
; # (++ P)
  %621 = inttoptr i64 %614 to i64*
  %622 = load i64, i64* %621
  %623 = getelementptr i64, i64* %621, i32 1
  %624 = load i64, i64* %623
; # (set Nl (++ P) Alt (++ P) Tp1 (++ P) Tp2 (++ P) Env P)
; # (++ P)
  %625 = inttoptr i64 %624 to i64*
  %626 = load i64, i64* %625
  %627 = getelementptr i64, i64* %625, i32 1
  %628 = load i64, i64* %627
  %629 = inttoptr i64 %71 to i64*
  store i64 %626, i64* %629
; # (++ P)
  %630 = inttoptr i64 %628 to i64*
  %631 = load i64, i64* %630
  %632 = getelementptr i64, i64* %630, i32 1
  %633 = load i64, i64* %632
  %634 = inttoptr i64 %83 to i64*
  store i64 %631, i64* %634
; # (++ P)
  %635 = inttoptr i64 %633 to i64*
  %636 = load i64, i64* %635
  %637 = getelementptr i64, i64* %635, i32 1
  %638 = load i64, i64* %637
  %639 = inttoptr i64 %95 to i64*
  store i64 %636, i64* %639
; # (++ P)
  %640 = inttoptr i64 %638 to i64*
  %641 = load i64, i64* %640
  %642 = getelementptr i64, i64* %640, i32 1
  %643 = load i64, i64* %642
  %644 = inttoptr i64 %107 to i64*
  store i64 %641, i64* %644
  %645 = inttoptr i64 %115 to i64*
  store i64 %643, i64* %645
  br label %$25
$69:
  %646 = phi i64 [%597, %$62] ; # X
  %647 = phi i64 [%598, %$62] ; # P
  %648 = phi i64 [%599, %$62] ; # N
  br label %$25
$25:
  %649 = phi i64 [%365, %$30], [%375, %$49], [%437, %$56], [%483, %$61], [%593, %$68], [%608, %$70], [%646, %$69] ; # X
  %650 = phi i64 [%366, %$30], [%376, %$49], [%438, %$56], [%484, %$61], [%594, %$68], [%643, %$70], [%647, %$69] ; # P
  %651 = phi i64 [%367, %$30], [%377, %$49], [%439, %$56], [%485, %$61], [%595, %$68], [%622, %$70], [%648, %$69] ; # N
  br label %$18
$22:
  %652 = phi i64 [%156, %$19] ; # X
  %653 = phi i64 [%157, %$19] ; # P
  %654 = phi i64 [%158, %$19] ; # N
; # (set E $Nil)
  %655 = inttoptr i64 %123 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %655
; # (let Y (val Env) (while (pair (cdr Y)) (let Z (caar Y) (when (== ...
; # (val Env)
  %656 = inttoptr i64 %115 to i64*
  %657 = load i64, i64* %656
; # (while (pair (cdr Y)) (let Z (caar Y) (when (== (car Z) ZERO) (se...
  br label %$71
$71:
  %658 = phi i64 [%652, %$22], [%692, %$75] ; # X
  %659 = phi i64 [%653, %$22], [%693, %$75] ; # P
  %660 = phi i64 [%654, %$22], [%694, %$75] ; # N
  %661 = phi i64 [%657, %$22], [%699, %$75] ; # Y
; # (cdr Y)
  %662 = inttoptr i64 %661 to i64*
  %663 = getelementptr i64, i64* %662, i32 1
  %664 = load i64, i64* %663
; # (pair (cdr Y))
  %665 = and i64 %664, 15
  %666 = icmp eq i64 %665, 0
  br i1 %666, label %$72, label %$73
$72:
  %667 = phi i64 [%658, %$71] ; # X
  %668 = phi i64 [%659, %$71] ; # P
  %669 = phi i64 [%660, %$71] ; # N
  %670 = phi i64 [%661, %$71] ; # Y
; # (let Z (caar Y) (when (== (car Z) ZERO) (set E (cons (cons (shift...
; # (caar Y)
  %671 = inttoptr i64 %670 to i64*
  %672 = load i64, i64* %671
  %673 = inttoptr i64 %672 to i64*
  %674 = load i64, i64* %673
; # (when (== (car Z) ZERO) (set E (cons (cons (shift Z) (lookup ZERO...
; # (car Z)
  %675 = inttoptr i64 %674 to i64*
  %676 = load i64, i64* %675
; # (== (car Z) ZERO)
  %677 = icmp eq i64 %676, 2
  br i1 %677, label %$74, label %$75
$74:
  %678 = phi i64 [%667, %$72] ; # X
  %679 = phi i64 [%668, %$72] ; # P
  %680 = phi i64 [%669, %$72] ; # N
  %681 = phi i64 [%670, %$72] ; # Y
  %682 = phi i64 [%674, %$72] ; # Z
; # (set E (cons (cons (shift Z) (lookup ZERO Z)) (val E)))
; # (shift Z)
  %683 = inttoptr i64 %682 to i64*
  %684 = getelementptr i64, i64* %683, i32 1
  %685 = load i64, i64* %684
; # (lookup ZERO Z)
  %686 = call i64 @lookup(i64 2, i64 %685)
; # (cons (shift Z) (lookup ZERO Z))
  %687 = call i64 @cons(i64 %685, i64 %686)
; # (val E)
  %688 = inttoptr i64 %123 to i64*
  %689 = load i64, i64* %688
; # (cons (cons (shift Z) (lookup ZERO Z)) (val E))
  %690 = call i64 @cons(i64 %687, i64 %689)
  %691 = inttoptr i64 %123 to i64*
  store i64 %690, i64* %691
  br label %$75
$75:
  %692 = phi i64 [%667, %$72], [%678, %$74] ; # X
  %693 = phi i64 [%668, %$72], [%679, %$74] ; # P
  %694 = phi i64 [%669, %$72], [%680, %$74] ; # N
  %695 = phi i64 [%670, %$72], [%681, %$74] ; # Y
  %696 = phi i64 [%674, %$72], [%685, %$74] ; # Z
; # (shift Y)
  %697 = inttoptr i64 %695 to i64*
  %698 = getelementptr i64, i64* %697, i32 1
  %699 = load i64, i64* %698
  br label %$71
$73:
  %700 = phi i64 [%658, %$71] ; # X
  %701 = phi i64 [%659, %$71] ; # P
  %702 = phi i64 [%660, %$71] ; # N
  %703 = phi i64 [%661, %$71] ; # Y
; # (set $Pnl Pnl $Penv Penv $At At)
  store i64 %141, i64* @$Pnl
  store i64 %140, i64* @$Penv
  %704 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
  store i64 %131, i64* %704
; # (cond ((pair (val E)) @) ((pair (val Env)) $T) (T $Nil))
; # (val E)
  %705 = inttoptr i64 %123 to i64*
  %706 = load i64, i64* %705
; # (pair (val E))
  %707 = and i64 %706, 15
  %708 = icmp eq i64 %707, 0
  br i1 %708, label %$78, label %$77
$78:
  %709 = phi i64 [%700, %$73] ; # X
  %710 = phi i64 [%701, %$73] ; # P
  %711 = phi i64 [%702, %$73] ; # N
  br label %$76
$77:
  %712 = phi i64 [%700, %$73] ; # X
  %713 = phi i64 [%701, %$73] ; # P
  %714 = phi i64 [%702, %$73] ; # N
; # (val Env)
  %715 = inttoptr i64 %115 to i64*
  %716 = load i64, i64* %715
; # (pair (val Env))
  %717 = and i64 %716, 15
  %718 = icmp eq i64 %717, 0
  br i1 %718, label %$80, label %$79
$80:
  %719 = phi i64 [%712, %$77] ; # X
  %720 = phi i64 [%713, %$77] ; # P
  %721 = phi i64 [%714, %$77] ; # N
  br label %$76
$79:
  %722 = phi i64 [%712, %$77] ; # X
  %723 = phi i64 [%713, %$77] ; # P
  %724 = phi i64 [%714, %$77] ; # N
  br label %$76
$76:
  %725 = phi i64 [%709, %$78], [%719, %$80], [%722, %$79] ; # X
  %726 = phi i64 [%710, %$78], [%720, %$80], [%723, %$79] ; # P
  %727 = phi i64 [%711, %$78], [%721, %$80], [%724, %$79] ; # N
  %728 = phi i64 [%706, %$78], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$80], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$79] ; # ->
; # (drop *Safe)
  %729 = inttoptr i64 %21 to i64*
  %730 = getelementptr i64, i64* %729, i32 1
  %731 = load i64, i64* %730
  %732 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %731, i64* %732
  br label %$9
$9:
  %733 = phi i64 [%16, %$7], [%725, %$76] ; # X
  %734 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$7], [%728, %$76] ; # ->
  ret i64 %734
}

define i64 @_Arrow(i64) align 8 {
$1:
; # (let (X (cdr Exe) L (val (val $Pnl))) (when (cnt? (cadr X)) (let ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (val $Pnl)
  %4 = load i64, i64* @$Pnl
; # (val (val $Pnl))
  %5 = inttoptr i64 %4 to i64*
  %6 = load i64, i64* %5
; # (when (cnt? (cadr X)) (let I (int @) (while (gt0 (dec 'I)) (shift...
; # (cadr X)
  %7 = inttoptr i64 %3 to i64*
  %8 = getelementptr i64, i64* %7, i32 1
  %9 = load i64, i64* %8
  %10 = inttoptr i64 %9 to i64*
  %11 = load i64, i64* %10
; # (cnt? (cadr X))
  %12 = and i64 %11, 2
  %13 = icmp ne i64 %12, 0
  br i1 %13, label %$2, label %$3
$2:
  %14 = phi i64 [%6, %$1] ; # L
; # (let I (int @) (while (gt0 (dec 'I)) (shift L)))
; # (int @)
  %15 = lshr i64 %11, 4
; # (while (gt0 (dec 'I)) (shift L))
  br label %$4
$4:
  %16 = phi i64 [%14, %$2], [%24, %$5] ; # L
  %17 = phi i64 [%15, %$2], [%21, %$5] ; # I
; # (dec 'I)
  %18 = sub i64 %17, 1
; # (gt0 (dec 'I))
  %19 = icmp sgt i64 %18, 0
  br i1 %19, label %$5, label %$6
$5:
  %20 = phi i64 [%16, %$4] ; # L
  %21 = phi i64 [%18, %$4] ; # I
; # (shift L)
  %22 = inttoptr i64 %20 to i64*
  %23 = getelementptr i64, i64* %22, i32 1
  %24 = load i64, i64* %23
  br label %$4
$6:
  %25 = phi i64 [%16, %$4] ; # L
  %26 = phi i64 [%18, %$4] ; # I
  br label %$3
$3:
  %27 = phi i64 [%6, %$1], [%25, %$6] ; # L
; # (car L)
  %28 = inttoptr i64 %27 to i64*
  %29 = load i64, i64* %28
; # (car X)
  %30 = inttoptr i64 %3 to i64*
  %31 = load i64, i64* %30
; # (lookup (car L) (car X))
  %32 = call i64 @lookup(i64 %29, i64 %31)
  ret i64 %32
}

define i64 @_Unify(i64) align 8 {
$1:
; # (let (X (eval (cadr Exe)) Pnl (val (val $Pnl)) N (car Pnl)) (ifn ...
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (val $Pnl)
  %14 = load i64, i64* @$Pnl
; # (val (val $Pnl))
  %15 = inttoptr i64 %14 to i64*
  %16 = load i64, i64* %15
; # (car Pnl)
  %17 = inttoptr i64 %16 to i64*
  %18 = load i64, i64* %17
; # (ifn (cnt? X) (save X (if (unify (cadr Pnl) X N X) (val (val $Pen...
; # (cnt? X)
  %19 = and i64 %13, 2
  %20 = icmp ne i64 %19, 0
  br i1 %20, label %$8, label %$7
$7:
  %21 = phi i64 [%16, %$2] ; # Pnl
; # (save X (if (unify (cadr Pnl) X N X) (val (val $Penv)) $Nil))
  %22 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %23 = load i64, i64* %22
  %24 = alloca i64, i64 2, align 16
  %25 = ptrtoint i64* %24 to i64
  %26 = inttoptr i64 %25 to i64*
  store i64 %13, i64* %26
  %27 = add i64 %25, 8
  %28 = inttoptr i64 %27 to i64*
  store i64 %23, i64* %28
  %29 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %25, i64* %29
; # (if (unify (cadr Pnl) X N X) (val (val $Penv)) $Nil)
; # (cadr Pnl)
  %30 = inttoptr i64 %21 to i64*
  %31 = getelementptr i64, i64* %30, i32 1
  %32 = load i64, i64* %31
  %33 = inttoptr i64 %32 to i64*
  %34 = load i64, i64* %33
; # (unify (cadr Pnl) X N X)
  %35 = call i1 @unify(i64 %34, i64 %13, i64 %18, i64 %13)
  br i1 %35, label %$10, label %$11
$10:
  %36 = phi i64 [%21, %$7] ; # Pnl
; # (val $Penv)
  %37 = load i64, i64* @$Penv
; # (val (val $Penv))
  %38 = inttoptr i64 %37 to i64*
  %39 = load i64, i64* %38
  br label %$12
$11:
  %40 = phi i64 [%21, %$7] ; # Pnl
  br label %$12
$12:
  %41 = phi i64 [%36, %$10], [%40, %$11] ; # Pnl
  %42 = phi i64 [%39, %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$11] ; # ->
; # drop
  %43 = inttoptr i64 %25 to i64*
  %44 = getelementptr i64, i64* %43, i32 1
  %45 = load i64, i64* %44
  %46 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %45, i64* %46
  br label %$9
$8:
  %47 = phi i64 [%16, %$2] ; # Pnl
; # (let (I (int @) Penv (val (val $Penv))) (while (gt0 (dec 'I)) (sh...
; # (int @)
  %48 = lshr i64 %13, 4
; # (val $Penv)
  %49 = load i64, i64* @$Penv
; # (val (val $Penv))
  %50 = inttoptr i64 %49 to i64*
  %51 = load i64, i64* %50
; # (while (gt0 (dec 'I)) (shift Pnl))
  br label %$13
$13:
  %52 = phi i64 [%47, %$8], [%62, %$14] ; # Pnl
  %53 = phi i64 [%48, %$8], [%58, %$14] ; # I
  %54 = phi i64 [%51, %$8], [%59, %$14] ; # Penv
; # (dec 'I)
  %55 = sub i64 %53, 1
; # (gt0 (dec 'I))
  %56 = icmp sgt i64 %55, 0
  br i1 %56, label %$14, label %$15
$14:
  %57 = phi i64 [%52, %$13] ; # Pnl
  %58 = phi i64 [%55, %$13] ; # I
  %59 = phi i64 [%54, %$13] ; # Penv
; # (shift Pnl)
  %60 = inttoptr i64 %57 to i64*
  %61 = getelementptr i64, i64* %60, i32 1
  %62 = load i64, i64* %61
  br label %$13
$15:
  %63 = phi i64 [%52, %$13] ; # Pnl
  %64 = phi i64 [%55, %$13] ; # I
  %65 = phi i64 [%54, %$13] ; # Penv
; # (let M (car Pnl) (while (pair (car Penv)) (let Y (car @) (when (=...
; # (car Pnl)
  %66 = inttoptr i64 %63 to i64*
  %67 = load i64, i64* %66
; # (while (pair (car Penv)) (let Y (car @) (when (== (car Y) M) (let...
  br label %$16
$16:
  %68 = phi i64 [%63, %$15], [%90, %$20] ; # Pnl
  %69 = phi i64 [%64, %$15], [%91, %$20] ; # I
  %70 = phi i64 [%65, %$15], [%95, %$20] ; # Penv
; # (car Penv)
  %71 = inttoptr i64 %70 to i64*
  %72 = load i64, i64* %71
; # (pair (car Penv))
  %73 = and i64 %72, 15
  %74 = icmp eq i64 %73, 0
  br i1 %74, label %$17, label %$18
$17:
  %75 = phi i64 [%68, %$16] ; # Pnl
  %76 = phi i64 [%69, %$16] ; # I
  %77 = phi i64 [%70, %$16] ; # Penv
; # (let Y (car @) (when (== (car Y) M) (let S (cdr Y) (unify M S N S...
; # (car @)
  %78 = inttoptr i64 %72 to i64*
  %79 = load i64, i64* %78
; # (when (== (car Y) M) (let S (cdr Y) (unify M S N S)))
; # (car Y)
  %80 = inttoptr i64 %79 to i64*
  %81 = load i64, i64* %80
; # (== (car Y) M)
  %82 = icmp eq i64 %81, %67
  br i1 %82, label %$19, label %$20
$19:
  %83 = phi i64 [%75, %$17] ; # Pnl
  %84 = phi i64 [%76, %$17] ; # I
  %85 = phi i64 [%77, %$17] ; # Penv
; # (let S (cdr Y) (unify M S N S))
; # (cdr Y)
  %86 = inttoptr i64 %79 to i64*
  %87 = getelementptr i64, i64* %86, i32 1
  %88 = load i64, i64* %87
; # (unify M S N S)
  %89 = call i1 @unify(i64 %67, i64 %88, i64 %18, i64 %88)
  br label %$20
$20:
  %90 = phi i64 [%75, %$17], [%83, %$19] ; # Pnl
  %91 = phi i64 [%76, %$17], [%84, %$19] ; # I
  %92 = phi i64 [%77, %$17], [%85, %$19] ; # Penv
; # (shift Penv)
  %93 = inttoptr i64 %92 to i64*
  %94 = getelementptr i64, i64* %93, i32 1
  %95 = load i64, i64* %94
  br label %$16
$18:
  %96 = phi i64 [%68, %$16] ; # Pnl
  %97 = phi i64 [%69, %$16] ; # I
  %98 = phi i64 [%70, %$16] ; # Penv
  br label %$9
$9:
  %99 = phi i64 [%41, %$12], [%96, %$18] ; # Pnl
  %100 = phi i64 [%42, %$12], [%13, %$18] ; # ->
  ret i64 %100
}

define i64 @_Group(i64) align 8 {
$1:
; # (let X (save (eval (cadr Exe))) (if (atom X) $Nil (let Y (cons (c...
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (save (eval (cadr Exe)))
  %14 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %15 = load i64, i64* %14
  %16 = alloca i64, i64 2, align 16
  %17 = ptrtoint i64* %16 to i64
  %18 = inttoptr i64 %17 to i64*
  store i64 %13, i64* %18
  %19 = add i64 %17, 8
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %17, i64* %21
; # (if (atom X) $Nil (let Y (cons (cdar X) $Nil) (setq Y (cons (cons...
; # (atom X)
  %22 = and i64 %13, 15
  %23 = icmp ne i64 %22, 0
  br i1 %23, label %$7, label %$8
$7:
  %24 = phi i64 [%13, %$2] ; # X
  br label %$9
$8:
  %25 = phi i64 [%13, %$2] ; # X
; # (let Y (cons (cdar X) $Nil) (setq Y (cons (cons (caar X) (cons Y ...
; # (cdar X)
  %26 = inttoptr i64 %25 to i64*
  %27 = load i64, i64* %26
  %28 = inttoptr i64 %27 to i64*
  %29 = getelementptr i64, i64* %28, i32 1
  %30 = load i64, i64* %29
; # (cons (cdar X) $Nil)
  %31 = call i64 @cons(i64 %30, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (caar X)
  %32 = inttoptr i64 %25 to i64*
  %33 = load i64, i64* %32
  %34 = inttoptr i64 %33 to i64*
  %35 = load i64, i64* %34
; # (cons Y Y)
  %36 = call i64 @cons(i64 %31, i64 %31)
; # (cons (caar X) (cons Y Y))
  %37 = call i64 @cons(i64 %35, i64 %36)
; # (cons (cons (caar X) (cons Y Y)) $Nil)
  %38 = call i64 @cons(i64 %37, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (let R (save Y) (while (pair (shift X)) (let (L (car X) K (car L)...
; # (save Y)
  %39 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %40 = load i64, i64* %39
  %41 = alloca i64, i64 2, align 16
  %42 = ptrtoint i64* %41 to i64
  %43 = inttoptr i64 %42 to i64*
  store i64 %38, i64* %43
  %44 = add i64 %42, 8
  %45 = inttoptr i64 %44 to i64*
  store i64 %40, i64* %45
  %46 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %42, i64* %46
; # (while (pair (shift X)) (let (L (car X) K (car L)) (setq Y (cons ...
  br label %$10
$10:
  %47 = phi i64 [%25, %$8], [%106, %$15] ; # X
  %48 = phi i64 [%38, %$8], [%107, %$15] ; # Y
; # (shift X)
  %49 = inttoptr i64 %47 to i64*
  %50 = getelementptr i64, i64* %49, i32 1
  %51 = load i64, i64* %50
; # (pair (shift X))
  %52 = and i64 %51, 15
  %53 = icmp eq i64 %52, 0
  br i1 %53, label %$11, label %$12
$11:
  %54 = phi i64 [%51, %$10] ; # X
  %55 = phi i64 [%48, %$10] ; # Y
; # (let (L (car X) K (car L)) (setq Y (cons (cdr L) $Nil)) (let Z R ...
; # (car X)
  %56 = inttoptr i64 %54 to i64*
  %57 = load i64, i64* %56
; # (car L)
  %58 = inttoptr i64 %57 to i64*
  %59 = load i64, i64* %58
; # (cdr L)
  %60 = inttoptr i64 %57 to i64*
  %61 = getelementptr i64, i64* %60, i32 1
  %62 = load i64, i64* %61
; # (cons (cdr L) $Nil)
  %63 = call i64 @cons(i64 %62, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (let Z R (loop (let V (car Z) (? (equal K (car V)) (set (shift V)...
; # (loop (let V (car Z) (? (equal K (car V)) (set (shift V) (set 2 (...
  br label %$13
$13:
  %64 = phi i64 [%54, %$11], [%102, %$17] ; # X
  %65 = phi i64 [%63, %$11], [%103, %$17] ; # Y
  %66 = phi i64 [%38, %$11], [%90, %$17] ; # Z
; # (let V (car Z) (? (equal K (car V)) (set (shift V) (set 2 (car V)...
; # (car Z)
  %67 = inttoptr i64 %66 to i64*
  %68 = load i64, i64* %67
; # (? (equal K (car V)) (set (shift V) (set 2 (car V) Y)))
; # (car V)
  %69 = inttoptr i64 %68 to i64*
  %70 = load i64, i64* %69
; # (equal K (car V))
  %71 = call i1 @equal(i64 %59, i64 %70)
  br i1 %71, label %$16, label %$14
$16:
  %72 = phi i64 [%64, %$13] ; # X
  %73 = phi i64 [%65, %$13] ; # Y
  %74 = phi i64 [%66, %$13] ; # Z
  %75 = phi i64 [%68, %$13] ; # V
; # (set (shift V) (set 2 (car V) Y))
; # (shift V)
  %76 = inttoptr i64 %75 to i64*
  %77 = getelementptr i64, i64* %76, i32 1
  %78 = load i64, i64* %77
; # (set 2 (car V) Y)
; # (car V)
  %79 = inttoptr i64 %78 to i64*
  %80 = load i64, i64* %79
  %81 = inttoptr i64 %80 to i64*
  %82 = getelementptr i64, i64* %81, i32 1
  store i64 %73, i64* %82
  %83 = inttoptr i64 %78 to i64*
  store i64 %73, i64* %83
  br label %$15
$14:
  %84 = phi i64 [%64, %$13] ; # X
  %85 = phi i64 [%65, %$13] ; # Y
  %86 = phi i64 [%66, %$13] ; # Z
  %87 = phi i64 [%68, %$13] ; # V
; # (? (atom (cdr Z)) (set 2 Z (cons (cons K (cons Y Y)) $Nil)))
; # (cdr Z)
  %88 = inttoptr i64 %86 to i64*
  %89 = getelementptr i64, i64* %88, i32 1
  %90 = load i64, i64* %89
; # (atom (cdr Z))
  %91 = and i64 %90, 15
  %92 = icmp ne i64 %91, 0
  br i1 %92, label %$18, label %$17
$18:
  %93 = phi i64 [%84, %$14] ; # X
  %94 = phi i64 [%85, %$14] ; # Y
  %95 = phi i64 [%86, %$14] ; # Z
  %96 = phi i64 [%87, %$14] ; # V
; # (set 2 Z (cons (cons K (cons Y Y)) $Nil))
; # (cons Y Y)
  %97 = call i64 @cons(i64 %94, i64 %94)
; # (cons K (cons Y Y))
  %98 = call i64 @cons(i64 %59, i64 %97)
; # (cons (cons K (cons Y Y)) $Nil)
  %99 = call i64 @cons(i64 %98, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %100 = inttoptr i64 %95 to i64*
  %101 = getelementptr i64, i64* %100, i32 1
  store i64 %99, i64* %101
  br label %$15
$17:
  %102 = phi i64 [%84, %$14] ; # X
  %103 = phi i64 [%85, %$14] ; # Y
  %104 = phi i64 [%86, %$14] ; # Z
  %105 = phi i64 [%87, %$14] ; # V
  br label %$13
$15:
  %106 = phi i64 [%72, %$16], [%93, %$18] ; # X
  %107 = phi i64 [%73, %$16], [%94, %$18] ; # Y
  %108 = phi i64 [%74, %$16], [%95, %$18] ; # Z
  %109 = phi i64 [%73, %$16], [%99, %$18] ; # ->
  br label %$10
$12:
  %110 = phi i64 [%51, %$10] ; # X
  %111 = phi i64 [%48, %$10] ; # Y
; # (let Z R (loop (let V (car Z) (set 2 V (cddr V))) (? (atom (shift...
; # (loop (let V (car Z) (set 2 V (cddr V))) (? (atom (shift Z))))
  br label %$19
$19:
  %112 = phi i64 [%110, %$12], [%130, %$20] ; # X
  %113 = phi i64 [%111, %$12], [%131, %$20] ; # Y
  %114 = phi i64 [%38, %$12], [%132, %$20] ; # Z
; # (let V (car Z) (set 2 V (cddr V)))
; # (car Z)
  %115 = inttoptr i64 %114 to i64*
  %116 = load i64, i64* %115
; # (set 2 V (cddr V))
; # (cddr V)
  %117 = inttoptr i64 %116 to i64*
  %118 = getelementptr i64, i64* %117, i32 1
  %119 = load i64, i64* %118
  %120 = inttoptr i64 %119 to i64*
  %121 = getelementptr i64, i64* %120, i32 1
  %122 = load i64, i64* %121
  %123 = inttoptr i64 %116 to i64*
  %124 = getelementptr i64, i64* %123, i32 1
  store i64 %122, i64* %124
; # (? (atom (shift Z)))
; # (shift Z)
  %125 = inttoptr i64 %114 to i64*
  %126 = getelementptr i64, i64* %125, i32 1
  %127 = load i64, i64* %126
; # (atom (shift Z))
  %128 = and i64 %127, 15
  %129 = icmp ne i64 %128, 0
  br i1 %129, label %$21, label %$20
$20:
  %130 = phi i64 [%112, %$19] ; # X
  %131 = phi i64 [%113, %$19] ; # Y
  %132 = phi i64 [%127, %$19] ; # Z
  br label %$19
$21:
  %133 = phi i64 [%112, %$19] ; # X
  %134 = phi i64 [%113, %$19] ; # Y
  %135 = phi i64 [%127, %$19] ; # Z
  %136 = phi i64 [0, %$19] ; # ->
  br label %$9
$9:
  %137 = phi i64 [%24, %$7], [%133, %$21] ; # X
  %138 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$7], [%38, %$21] ; # ->
; # (drop *Safe)
  %139 = inttoptr i64 %17 to i64*
  %140 = getelementptr i64, i64* %139, i32 1
  %141 = load i64, i64* %140
  %142 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %141, i64* %142
  ret i64 %138
}

define i64 @_Sort(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (eval (++ X))) (cond ((atom Y) @) ((atom X) (...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (cond ((atom Y) @) ((atom X) (let (Out0 Y Out1 $Nil) (loop (let (...
; # (atom Y)
  %16 = and i64 %15, 15
  %17 = icmp ne i64 %16, 0
  br i1 %17, label %$9, label %$8
$9:
  br label %$7
$8:
; # (atom X)
  %18 = and i64 %7, 15
  %19 = icmp ne i64 %18, 0
  br i1 %19, label %$11, label %$10
$11:
; # (let (Out0 Y Out1 $Nil) (loop (let (In0 Out0 In1 Out1 P) (if (and...
; # (loop (let (In0 Out0 In1 Out1 P) (if (and (pair In1) (ge0 (compar...
  br label %$12
$12:
  %20 = phi i64 [%15, %$11], [%375, %$47] ; # Out0
  %21 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$11], [%376, %$47] ; # Out1
; # (let (In0 Out0 In1 Out1 P) (if (and (pair In1) (ge0 (compare (car...
; # (if (and (pair In1) (ge0 (compare (car In0) (car In1)))) (setq In...
; # (and (pair In1) (ge0 (compare (car In0) (car In1))))
; # (pair In1)
  %22 = and i64 %21, 15
  %23 = icmp eq i64 %22, 0
  br i1 %23, label %$14, label %$13
$14:
  %24 = phi i64 [%20, %$12] ; # Out0
  %25 = phi i64 [%21, %$12] ; # Out1
  %26 = phi i64 [%20, %$12] ; # In0
  %27 = phi i64 [%21, %$12] ; # In1
; # (car In0)
  %28 = inttoptr i64 %26 to i64*
  %29 = load i64, i64* %28
; # (car In1)
  %30 = inttoptr i64 %27 to i64*
  %31 = load i64, i64* %30
; # (compare (car In0) (car In1))
  %32 = call i64 @compare(i64 %29, i64 %31)
; # (ge0 (compare (car In0) (car In1)))
  %33 = icmp sge i64 %32, 0
  br label %$13
$13:
  %34 = phi i64 [%20, %$12], [%24, %$14] ; # Out0
  %35 = phi i64 [%21, %$12], [%25, %$14] ; # Out1
  %36 = phi i64 [%20, %$12], [%26, %$14] ; # In0
  %37 = phi i64 [%21, %$12], [%27, %$14] ; # In1
  %38 = phi i1 [0, %$12], [%33, %$14] ; # ->
  br i1 %38, label %$15, label %$16
$15:
  %39 = phi i64 [%34, %$13] ; # Out0
  %40 = phi i64 [%35, %$13] ; # Out1
  %41 = phi i64 [%36, %$13] ; # In0
  %42 = phi i64 [%37, %$13] ; # In1
; # (cdr (setq P In1))
  %43 = inttoptr i64 %42 to i64*
  %44 = getelementptr i64, i64* %43, i32 1
  %45 = load i64, i64* %44
  br label %$17
$16:
  %46 = phi i64 [%34, %$13] ; # Out0
  %47 = phi i64 [%35, %$13] ; # Out1
  %48 = phi i64 [%36, %$13] ; # In0
  %49 = phi i64 [%37, %$13] ; # In1
; # (cdr (setq P In0))
  %50 = inttoptr i64 %48 to i64*
  %51 = getelementptr i64, i64* %50, i32 1
  %52 = load i64, i64* %51
  br label %$17
$17:
  %53 = phi i64 [%39, %$15], [%46, %$16] ; # Out0
  %54 = phi i64 [%40, %$15], [%47, %$16] ; # Out1
  %55 = phi i64 [%41, %$15], [%52, %$16] ; # In0
  %56 = phi i64 [%45, %$15], [%49, %$16] ; # In1
  %57 = phi i64 [%42, %$15], [%48, %$16] ; # P
  %58 = phi i64 [%45, %$15], [%52, %$16] ; # ->
; # (let (Tail0 (ofs P 1) Tail1 0 Last (car P)) (setq Out0 P Out1 $Ni...
; # (ofs P 1)
  %59 = add i64 %57, 8
; # (car P)
  %60 = inttoptr i64 %57 to i64*
  %61 = load i64, i64* %60
; # (set 2 P $Nil)
  %62 = inttoptr i64 %57 to i64*
  %63 = getelementptr i64, i64* %62, i32 1
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %63
; # (while (or (pair In0) (pair In1)) (cond ((atom In1) (setq In0 (cd...
  br label %$18
$18:
  %64 = phi i64 [%57, %$17], [%349, %$46] ; # Out0
  %65 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$17], [%350, %$46] ; # Out1
  %66 = phi i64 [%55, %$17], [%351, %$46] ; # In0
  %67 = phi i64 [%56, %$17], [%352, %$46] ; # In1
  %68 = phi i64 [%57, %$17], [%353, %$46] ; # P
  %69 = phi i64 [%59, %$17], [%358, %$46] ; # Tail0
  %70 = phi i64 [0, %$17], [%355, %$46] ; # Tail1
  %71 = phi i64 [%61, %$17], [%362, %$46] ; # Last
; # (or (pair In0) (pair In1))
; # (pair In0)
  %72 = and i64 %66, 15
  %73 = icmp eq i64 %72, 0
  br i1 %73, label %$19, label %$20
$20:
  %74 = phi i64 [%64, %$18] ; # Out0
  %75 = phi i64 [%65, %$18] ; # Out1
  %76 = phi i64 [%66, %$18] ; # In0
  %77 = phi i64 [%67, %$18] ; # In1
  %78 = phi i64 [%68, %$18] ; # P
  %79 = phi i64 [%69, %$18] ; # Tail0
  %80 = phi i64 [%70, %$18] ; # Tail1
  %81 = phi i64 [%71, %$18] ; # Last
; # (pair In1)
  %82 = and i64 %77, 15
  %83 = icmp eq i64 %82, 0
  br label %$19
$19:
  %84 = phi i64 [%64, %$18], [%74, %$20] ; # Out0
  %85 = phi i64 [%65, %$18], [%75, %$20] ; # Out1
  %86 = phi i64 [%66, %$18], [%76, %$20] ; # In0
  %87 = phi i64 [%67, %$18], [%77, %$20] ; # In1
  %88 = phi i64 [%68, %$18], [%78, %$20] ; # P
  %89 = phi i64 [%69, %$18], [%79, %$20] ; # Tail0
  %90 = phi i64 [%70, %$18], [%80, %$20] ; # Tail1
  %91 = phi i64 [%71, %$18], [%81, %$20] ; # Last
  %92 = phi i1 [1, %$18], [%83, %$20] ; # ->
  br i1 %92, label %$21, label %$22
$21:
  %93 = phi i64 [%84, %$19] ; # Out0
  %94 = phi i64 [%85, %$19] ; # Out1
  %95 = phi i64 [%86, %$19] ; # In0
  %96 = phi i64 [%87, %$19] ; # In1
  %97 = phi i64 [%88, %$19] ; # P
  %98 = phi i64 [%89, %$19] ; # Tail0
  %99 = phi i64 [%90, %$19] ; # Tail1
  %100 = phi i64 [%91, %$19] ; # Last
; # (cond ((atom In1) (setq In0 (cdr (setq P In0))) (when (lt0 (compa...
; # (atom In1)
  %101 = and i64 %96, 15
  %102 = icmp ne i64 %101, 0
  br i1 %102, label %$25, label %$24
$25:
  %103 = phi i64 [%93, %$21] ; # Out0
  %104 = phi i64 [%94, %$21] ; # Out1
  %105 = phi i64 [%95, %$21] ; # In0
  %106 = phi i64 [%96, %$21] ; # In1
  %107 = phi i64 [%97, %$21] ; # P
  %108 = phi i64 [%98, %$21] ; # Tail0
  %109 = phi i64 [%99, %$21] ; # Tail1
  %110 = phi i64 [%100, %$21] ; # Last
; # (cdr (setq P In0))
  %111 = inttoptr i64 %105 to i64*
  %112 = getelementptr i64, i64* %111, i32 1
  %113 = load i64, i64* %112
; # (when (lt0 (compare (car P) Last)) (xchg 'Tail0 'Tail1))
; # (car P)
  %114 = inttoptr i64 %105 to i64*
  %115 = load i64, i64* %114
; # (compare (car P) Last)
  %116 = call i64 @compare(i64 %115, i64 %110)
; # (lt0 (compare (car P) Last))
  %117 = icmp slt i64 %116, 0
  br i1 %117, label %$26, label %$27
$26:
  %118 = phi i64 [%103, %$25] ; # Out0
  %119 = phi i64 [%104, %$25] ; # Out1
  %120 = phi i64 [%113, %$25] ; # In0
  %121 = phi i64 [%106, %$25] ; # In1
  %122 = phi i64 [%105, %$25] ; # P
  %123 = phi i64 [%108, %$25] ; # Tail0
  %124 = phi i64 [%109, %$25] ; # Tail1
  %125 = phi i64 [%110, %$25] ; # Last
; # (xchg 'Tail0 'Tail1)
  br label %$27
$27:
  %126 = phi i64 [%103, %$25], [%118, %$26] ; # Out0
  %127 = phi i64 [%104, %$25], [%119, %$26] ; # Out1
  %128 = phi i64 [%113, %$25], [%120, %$26] ; # In0
  %129 = phi i64 [%106, %$25], [%121, %$26] ; # In1
  %130 = phi i64 [%105, %$25], [%122, %$26] ; # P
  %131 = phi i64 [%108, %$25], [%124, %$26] ; # Tail0
  %132 = phi i64 [%109, %$25], [%123, %$26] ; # Tail1
  %133 = phi i64 [%110, %$25], [%125, %$26] ; # Last
  br label %$23
$24:
  %134 = phi i64 [%93, %$21] ; # Out0
  %135 = phi i64 [%94, %$21] ; # Out1
  %136 = phi i64 [%95, %$21] ; # In0
  %137 = phi i64 [%96, %$21] ; # In1
  %138 = phi i64 [%97, %$21] ; # P
  %139 = phi i64 [%98, %$21] ; # Tail0
  %140 = phi i64 [%99, %$21] ; # Tail1
  %141 = phi i64 [%100, %$21] ; # Last
; # (atom In0)
  %142 = and i64 %136, 15
  %143 = icmp ne i64 %142, 0
  br i1 %143, label %$29, label %$28
$29:
  %144 = phi i64 [%134, %$24] ; # Out0
  %145 = phi i64 [%135, %$24] ; # Out1
  %146 = phi i64 [%136, %$24] ; # In0
  %147 = phi i64 [%137, %$24] ; # In1
  %148 = phi i64 [%138, %$24] ; # P
  %149 = phi i64 [%139, %$24] ; # Tail0
  %150 = phi i64 [%140, %$24] ; # Tail1
  %151 = phi i64 [%141, %$24] ; # Last
; # (cdr (setq P In1))
  %152 = inttoptr i64 %147 to i64*
  %153 = getelementptr i64, i64* %152, i32 1
  %154 = load i64, i64* %153
; # (when (lt0 (compare (car P) Last)) (xchg 'Tail0 'Tail1))
; # (car P)
  %155 = inttoptr i64 %147 to i64*
  %156 = load i64, i64* %155
; # (compare (car P) Last)
  %157 = call i64 @compare(i64 %156, i64 %151)
; # (lt0 (compare (car P) Last))
  %158 = icmp slt i64 %157, 0
  br i1 %158, label %$30, label %$31
$30:
  %159 = phi i64 [%144, %$29] ; # Out0
  %160 = phi i64 [%145, %$29] ; # Out1
  %161 = phi i64 [%146, %$29] ; # In0
  %162 = phi i64 [%154, %$29] ; # In1
  %163 = phi i64 [%147, %$29] ; # P
  %164 = phi i64 [%149, %$29] ; # Tail0
  %165 = phi i64 [%150, %$29] ; # Tail1
  %166 = phi i64 [%151, %$29] ; # Last
; # (xchg 'Tail0 'Tail1)
  br label %$31
$31:
  %167 = phi i64 [%144, %$29], [%159, %$30] ; # Out0
  %168 = phi i64 [%145, %$29], [%160, %$30] ; # Out1
  %169 = phi i64 [%146, %$29], [%161, %$30] ; # In0
  %170 = phi i64 [%154, %$29], [%162, %$30] ; # In1
  %171 = phi i64 [%147, %$29], [%163, %$30] ; # P
  %172 = phi i64 [%149, %$29], [%165, %$30] ; # Tail0
  %173 = phi i64 [%150, %$29], [%164, %$30] ; # Tail1
  %174 = phi i64 [%151, %$29], [%166, %$30] ; # Last
  br label %$23
$28:
  %175 = phi i64 [%134, %$24] ; # Out0
  %176 = phi i64 [%135, %$24] ; # Out1
  %177 = phi i64 [%136, %$24] ; # In0
  %178 = phi i64 [%137, %$24] ; # In1
  %179 = phi i64 [%138, %$24] ; # P
  %180 = phi i64 [%139, %$24] ; # Tail0
  %181 = phi i64 [%140, %$24] ; # Tail1
  %182 = phi i64 [%141, %$24] ; # Last
; # (car In0)
  %183 = inttoptr i64 %177 to i64*
  %184 = load i64, i64* %183
; # (compare (car In0) Last)
  %185 = call i64 @compare(i64 %184, i64 %182)
; # (lt0 (compare (car In0) Last))
  %186 = icmp slt i64 %185, 0
  br i1 %186, label %$33, label %$32
$33:
  %187 = phi i64 [%175, %$28] ; # Out0
  %188 = phi i64 [%176, %$28] ; # Out1
  %189 = phi i64 [%177, %$28] ; # In0
  %190 = phi i64 [%178, %$28] ; # In1
  %191 = phi i64 [%179, %$28] ; # P
  %192 = phi i64 [%180, %$28] ; # Tail0
  %193 = phi i64 [%181, %$28] ; # Tail1
  %194 = phi i64 [%182, %$28] ; # Last
; # (if (ge0 (compare (car In1) Last)) (setq In1 (cdr (setq P In1))) ...
; # (car In1)
  %195 = inttoptr i64 %190 to i64*
  %196 = load i64, i64* %195
; # (compare (car In1) Last)
  %197 = call i64 @compare(i64 %196, i64 %194)
; # (ge0 (compare (car In1) Last))
  %198 = icmp sge i64 %197, 0
  br i1 %198, label %$34, label %$35
$34:
  %199 = phi i64 [%187, %$33] ; # Out0
  %200 = phi i64 [%188, %$33] ; # Out1
  %201 = phi i64 [%189, %$33] ; # In0
  %202 = phi i64 [%190, %$33] ; # In1
  %203 = phi i64 [%191, %$33] ; # P
  %204 = phi i64 [%192, %$33] ; # Tail0
  %205 = phi i64 [%193, %$33] ; # Tail1
  %206 = phi i64 [%194, %$33] ; # Last
; # (cdr (setq P In1))
  %207 = inttoptr i64 %202 to i64*
  %208 = getelementptr i64, i64* %207, i32 1
  %209 = load i64, i64* %208
  br label %$36
$35:
  %210 = phi i64 [%187, %$33] ; # Out0
  %211 = phi i64 [%188, %$33] ; # Out1
  %212 = phi i64 [%189, %$33] ; # In0
  %213 = phi i64 [%190, %$33] ; # In1
  %214 = phi i64 [%191, %$33] ; # P
  %215 = phi i64 [%192, %$33] ; # Tail0
  %216 = phi i64 [%193, %$33] ; # Tail1
  %217 = phi i64 [%194, %$33] ; # Last
; # (if (lt0 (compare (car In0) (car In1))) (setq In0 (cdr (setq P In...
; # (car In0)
  %218 = inttoptr i64 %212 to i64*
  %219 = load i64, i64* %218
; # (car In1)
  %220 = inttoptr i64 %213 to i64*
  %221 = load i64, i64* %220
; # (compare (car In0) (car In1))
  %222 = call i64 @compare(i64 %219, i64 %221)
; # (lt0 (compare (car In0) (car In1)))
  %223 = icmp slt i64 %222, 0
  br i1 %223, label %$37, label %$38
$37:
  %224 = phi i64 [%210, %$35] ; # Out0
  %225 = phi i64 [%211, %$35] ; # Out1
  %226 = phi i64 [%212, %$35] ; # In0
  %227 = phi i64 [%213, %$35] ; # In1
  %228 = phi i64 [%214, %$35] ; # P
  %229 = phi i64 [%215, %$35] ; # Tail0
  %230 = phi i64 [%216, %$35] ; # Tail1
  %231 = phi i64 [%217, %$35] ; # Last
; # (cdr (setq P In0))
  %232 = inttoptr i64 %226 to i64*
  %233 = getelementptr i64, i64* %232, i32 1
  %234 = load i64, i64* %233
  br label %$39
$38:
  %235 = phi i64 [%210, %$35] ; # Out0
  %236 = phi i64 [%211, %$35] ; # Out1
  %237 = phi i64 [%212, %$35] ; # In0
  %238 = phi i64 [%213, %$35] ; # In1
  %239 = phi i64 [%214, %$35] ; # P
  %240 = phi i64 [%215, %$35] ; # Tail0
  %241 = phi i64 [%216, %$35] ; # Tail1
  %242 = phi i64 [%217, %$35] ; # Last
; # (cdr (setq P In1))
  %243 = inttoptr i64 %238 to i64*
  %244 = getelementptr i64, i64* %243, i32 1
  %245 = load i64, i64* %244
  br label %$39
$39:
  %246 = phi i64 [%224, %$37], [%235, %$38] ; # Out0
  %247 = phi i64 [%225, %$37], [%236, %$38] ; # Out1
  %248 = phi i64 [%234, %$37], [%237, %$38] ; # In0
  %249 = phi i64 [%227, %$37], [%245, %$38] ; # In1
  %250 = phi i64 [%226, %$37], [%238, %$38] ; # P
  %251 = phi i64 [%229, %$37], [%240, %$38] ; # Tail0
  %252 = phi i64 [%230, %$37], [%241, %$38] ; # Tail1
  %253 = phi i64 [%231, %$37], [%242, %$38] ; # Last
  %254 = phi i64 [%234, %$37], [%245, %$38] ; # ->
; # (xchg 'Tail0 'Tail1)
  br label %$36
$36:
  %255 = phi i64 [%199, %$34], [%246, %$39] ; # Out0
  %256 = phi i64 [%200, %$34], [%247, %$39] ; # Out1
  %257 = phi i64 [%201, %$34], [%248, %$39] ; # In0
  %258 = phi i64 [%209, %$34], [%249, %$39] ; # In1
  %259 = phi i64 [%202, %$34], [%250, %$39] ; # P
  %260 = phi i64 [%204, %$34], [%252, %$39] ; # Tail0
  %261 = phi i64 [%205, %$34], [%251, %$39] ; # Tail1
  %262 = phi i64 [%206, %$34], [%253, %$39] ; # Last
  %263 = phi i64 [%209, %$34], [%251, %$39] ; # ->
  br label %$23
$32:
  %264 = phi i64 [%175, %$28] ; # Out0
  %265 = phi i64 [%176, %$28] ; # Out1
  %266 = phi i64 [%177, %$28] ; # In0
  %267 = phi i64 [%178, %$28] ; # In1
  %268 = phi i64 [%179, %$28] ; # P
  %269 = phi i64 [%180, %$28] ; # Tail0
  %270 = phi i64 [%181, %$28] ; # Tail1
  %271 = phi i64 [%182, %$28] ; # Last
; # (car In1)
  %272 = inttoptr i64 %267 to i64*
  %273 = load i64, i64* %272
; # (compare (car In1) Last)
  %274 = call i64 @compare(i64 %273, i64 %271)
; # (lt0 (compare (car In1) Last))
  %275 = icmp slt i64 %274, 0
  br i1 %275, label %$41, label %$40
$41:
  %276 = phi i64 [%264, %$32] ; # Out0
  %277 = phi i64 [%265, %$32] ; # Out1
  %278 = phi i64 [%266, %$32] ; # In0
  %279 = phi i64 [%267, %$32] ; # In1
  %280 = phi i64 [%268, %$32] ; # P
  %281 = phi i64 [%269, %$32] ; # Tail0
  %282 = phi i64 [%270, %$32] ; # Tail1
  %283 = phi i64 [%271, %$32] ; # Last
; # (cdr (setq P In0))
  %284 = inttoptr i64 %278 to i64*
  %285 = getelementptr i64, i64* %284, i32 1
  %286 = load i64, i64* %285
  br label %$23
$40:
  %287 = phi i64 [%264, %$32] ; # Out0
  %288 = phi i64 [%265, %$32] ; # Out1
  %289 = phi i64 [%266, %$32] ; # In0
  %290 = phi i64 [%267, %$32] ; # In1
  %291 = phi i64 [%268, %$32] ; # P
  %292 = phi i64 [%269, %$32] ; # Tail0
  %293 = phi i64 [%270, %$32] ; # Tail1
  %294 = phi i64 [%271, %$32] ; # Last
; # (car In0)
  %295 = inttoptr i64 %289 to i64*
  %296 = load i64, i64* %295
; # (car In1)
  %297 = inttoptr i64 %290 to i64*
  %298 = load i64, i64* %297
; # (compare (car In0) (car In1))
  %299 = call i64 @compare(i64 %296, i64 %298)
; # (lt0 (compare (car In0) (car In1)))
  %300 = icmp slt i64 %299, 0
  br i1 %300, label %$43, label %$42
$43:
  %301 = phi i64 [%287, %$40] ; # Out0
  %302 = phi i64 [%288, %$40] ; # Out1
  %303 = phi i64 [%289, %$40] ; # In0
  %304 = phi i64 [%290, %$40] ; # In1
  %305 = phi i64 [%291, %$40] ; # P
  %306 = phi i64 [%292, %$40] ; # Tail0
  %307 = phi i64 [%293, %$40] ; # Tail1
  %308 = phi i64 [%294, %$40] ; # Last
; # (cdr (setq P In0))
  %309 = inttoptr i64 %303 to i64*
  %310 = getelementptr i64, i64* %309, i32 1
  %311 = load i64, i64* %310
  br label %$23
$42:
  %312 = phi i64 [%287, %$40] ; # Out0
  %313 = phi i64 [%288, %$40] ; # Out1
  %314 = phi i64 [%289, %$40] ; # In0
  %315 = phi i64 [%290, %$40] ; # In1
  %316 = phi i64 [%291, %$40] ; # P
  %317 = phi i64 [%292, %$40] ; # Tail0
  %318 = phi i64 [%293, %$40] ; # Tail1
  %319 = phi i64 [%294, %$40] ; # Last
; # (cdr (setq P In1))
  %320 = inttoptr i64 %315 to i64*
  %321 = getelementptr i64, i64* %320, i32 1
  %322 = load i64, i64* %321
  br label %$23
$23:
  %323 = phi i64 [%126, %$27], [%167, %$31], [%255, %$36], [%276, %$41], [%301, %$43], [%312, %$42] ; # Out0
  %324 = phi i64 [%127, %$27], [%168, %$31], [%256, %$36], [%277, %$41], [%302, %$43], [%313, %$42] ; # Out1
  %325 = phi i64 [%128, %$27], [%169, %$31], [%257, %$36], [%286, %$41], [%311, %$43], [%314, %$42] ; # In0
  %326 = phi i64 [%129, %$27], [%170, %$31], [%258, %$36], [%279, %$41], [%304, %$43], [%322, %$42] ; # In1
  %327 = phi i64 [%130, %$27], [%171, %$31], [%259, %$36], [%278, %$41], [%303, %$43], [%315, %$42] ; # P
  %328 = phi i64 [%131, %$27], [%172, %$31], [%260, %$36], [%281, %$41], [%306, %$43], [%317, %$42] ; # Tail0
  %329 = phi i64 [%132, %$27], [%173, %$31], [%261, %$36], [%282, %$41], [%307, %$43], [%318, %$42] ; # Tail1
  %330 = phi i64 [%133, %$27], [%174, %$31], [%262, %$36], [%283, %$41], [%308, %$43], [%319, %$42] ; # Last
; # (if Tail0 (set Tail0 P) (setq Out1 P))
  %331 = icmp ne i64 %328, 0
  br i1 %331, label %$44, label %$45
$44:
  %332 = phi i64 [%323, %$23] ; # Out0
  %333 = phi i64 [%324, %$23] ; # Out1
  %334 = phi i64 [%325, %$23] ; # In0
  %335 = phi i64 [%326, %$23] ; # In1
  %336 = phi i64 [%327, %$23] ; # P
  %337 = phi i64 [%328, %$23] ; # Tail0
  %338 = phi i64 [%329, %$23] ; # Tail1
  %339 = phi i64 [%330, %$23] ; # Last
; # (set Tail0 P)
  %340 = inttoptr i64 %337 to i64*
  store i64 %336, i64* %340
  br label %$46
$45:
  %341 = phi i64 [%323, %$23] ; # Out0
  %342 = phi i64 [%324, %$23] ; # Out1
  %343 = phi i64 [%325, %$23] ; # In0
  %344 = phi i64 [%326, %$23] ; # In1
  %345 = phi i64 [%327, %$23] ; # P
  %346 = phi i64 [%328, %$23] ; # Tail0
  %347 = phi i64 [%329, %$23] ; # Tail1
  %348 = phi i64 [%330, %$23] ; # Last
  br label %$46
$46:
  %349 = phi i64 [%332, %$44], [%341, %$45] ; # Out0
  %350 = phi i64 [%333, %$44], [%345, %$45] ; # Out1
  %351 = phi i64 [%334, %$44], [%343, %$45] ; # In0
  %352 = phi i64 [%335, %$44], [%344, %$45] ; # In1
  %353 = phi i64 [%336, %$44], [%345, %$45] ; # P
  %354 = phi i64 [%337, %$44], [%346, %$45] ; # Tail0
  %355 = phi i64 [%338, %$44], [%347, %$45] ; # Tail1
  %356 = phi i64 [%339, %$44], [%348, %$45] ; # Last
  %357 = phi i64 [%336, %$44], [%345, %$45] ; # ->
; # (ofs (if Tail0 (set Tail0 P) (setq Out1 P)) 1)
  %358 = add i64 %357, 8
; # (set 2 P $Nil)
  %359 = inttoptr i64 %353 to i64*
  %360 = getelementptr i64, i64* %359, i32 1
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %360
; # (car P)
  %361 = inttoptr i64 %353 to i64*
  %362 = load i64, i64* %361
  br label %$18
$22:
  %363 = phi i64 [%84, %$19] ; # Out0
  %364 = phi i64 [%85, %$19] ; # Out1
  %365 = phi i64 [%86, %$19] ; # In0
  %366 = phi i64 [%87, %$19] ; # In1
  %367 = phi i64 [%88, %$19] ; # P
  %368 = phi i64 [%89, %$19] ; # Tail0
  %369 = phi i64 [%90, %$19] ; # Tail1
  %370 = phi i64 [%91, %$19] ; # Last
; # (? (atom Out1) Out0)
; # (atom Out1)
  %371 = and i64 %364, 15
  %372 = icmp ne i64 %371, 0
  br i1 %372, label %$49, label %$47
$49:
  %373 = phi i64 [%363, %$22] ; # Out0
  %374 = phi i64 [%364, %$22] ; # Out1
  br label %$48
$47:
  %375 = phi i64 [%363, %$22] ; # Out0
  %376 = phi i64 [%364, %$22] ; # Out1
  br label %$12
$48:
  %377 = phi i64 [%373, %$49] ; # Out0
  %378 = phi i64 [%374, %$49] ; # Out1
  %379 = phi i64 [%373, %$49] ; # ->
  br label %$7
$10:
; # (let (Out0 (link (push Y NIL) T) Out1 (link (push $Nil NIL)) In0 ...
; # (push Y NIL)
  %380 = alloca i64, i64 2, align 16
  %381 = ptrtoint i64* %380 to i64
  %382 = inttoptr i64 %381 to i64*
  store i64 %15, i64* %382
; # (link (push Y NIL) T)
  %383 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %384 = load i64, i64* %383
  %385 = inttoptr i64 %381 to i64*
  %386 = getelementptr i64, i64* %385, i32 1
  store i64 %384, i64* %386
  %387 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %381, i64* %387
; # (push $Nil NIL)
  %388 = alloca i64, i64 2, align 16
  %389 = ptrtoint i64* %388 to i64
  %390 = inttoptr i64 %389 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %390
; # (link (push $Nil NIL))
  %391 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %392 = load i64, i64* %391
  %393 = inttoptr i64 %389 to i64*
  %394 = getelementptr i64, i64* %393, i32 1
  store i64 %392, i64* %394
  %395 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %389, i64* %395
; # (push -ZERO NIL)
  %396 = alloca i64, i64 2, align 16
  %397 = ptrtoint i64* %396 to i64
  %398 = inttoptr i64 %397 to i64*
  store i64 10, i64* %398
; # (link (push -ZERO NIL))
  %399 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %400 = load i64, i64* %399
  %401 = inttoptr i64 %397 to i64*
  %402 = getelementptr i64, i64* %401, i32 1
  store i64 %400, i64* %402
  %403 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %397, i64* %403
; # (push -ZERO NIL)
  %404 = alloca i64, i64 2, align 16
  %405 = ptrtoint i64* %404 to i64
  %406 = inttoptr i64 %405 to i64*
  store i64 10, i64* %406
; # (link (push -ZERO NIL))
  %407 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %408 = load i64, i64* %407
  %409 = inttoptr i64 %405 to i64*
  %410 = getelementptr i64, i64* %409, i32 1
  store i64 %408, i64* %410
  %411 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %405, i64* %411
; # (push -ZERO NIL)
  %412 = alloca i64, i64 2, align 16
  %413 = ptrtoint i64* %412 to i64
  %414 = inttoptr i64 %413 to i64*
  store i64 10, i64* %414
; # (link (push -ZERO NIL))
  %415 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %416 = load i64, i64* %415
  %417 = inttoptr i64 %413 to i64*
  %418 = getelementptr i64, i64* %417, i32 1
  store i64 %416, i64* %418
  %419 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %413, i64* %419
; # (push NIL $Nil ZERO NIL NIL)
  %420 = alloca i64, i64 5, align 16
  %421 = ptrtoint i64* %420 to i64
  %422 = add i64 %421, 8
  %423 = inttoptr i64 %422 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %423
  %424 = add i64 %421, 16
  %425 = inttoptr i64 %424 to i64*
  store i64 2, i64* %425
; # (push NIL B ZERO NIL NIL)
  %426 = alloca i64, i64 5, align 16
  %427 = ptrtoint i64* %426 to i64
  %428 = add i64 %427, 8
  %429 = inttoptr i64 %428 to i64*
  store i64 %421, i64* %429
  %430 = add i64 %427, 16
  %431 = inttoptr i64 %430 to i64*
  store i64 2, i64* %431
; # (car X)
  %432 = inttoptr i64 %7 to i64*
  %433 = load i64, i64* %432
; # (eval (car X))
  %434 = and i64 %433, 6
  %435 = icmp ne i64 %434, 0
  br i1 %435, label %$52, label %$51
$52:
  br label %$50
$51:
  %436 = and i64 %433, 8
  %437 = icmp ne i64 %436, 0
  br i1 %437, label %$54, label %$53
$54:
  %438 = inttoptr i64 %433 to i64*
  %439 = load i64, i64* %438
  br label %$50
$53:
  %440 = call i64 @evList(i64 %433)
  br label %$50
$50:
  %441 = phi i64 [%433, %$52], [%439, %$54], [%440, %$53] ; # ->
; # (push NIL A ZERO (eval (car X)) NIL)
  %442 = alloca i64, i64 5, align 16
  %443 = ptrtoint i64* %442 to i64
  %444 = add i64 %443, 8
  %445 = inttoptr i64 %444 to i64*
  store i64 %427, i64* %445
  %446 = add i64 %443, 16
  %447 = inttoptr i64 %446 to i64*
  store i64 2, i64* %447
  %448 = add i64 %443, 24
  %449 = inttoptr i64 %448 to i64*
  store i64 %441, i64* %449
; # (set B (link (ofs B 3)) A (link (ofs A 3)) E (link (ofs E 3)))
; # (ofs B 3)
  %450 = add i64 %421, 24
; # (link (ofs B 3))
  %451 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %452 = load i64, i64* %451
  %453 = inttoptr i64 %450 to i64*
  %454 = getelementptr i64, i64* %453, i32 1
  store i64 %452, i64* %454
  %455 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %450, i64* %455
  %456 = inttoptr i64 %421 to i64*
  store i64 %450, i64* %456
; # (ofs A 3)
  %457 = add i64 %427, 24
; # (link (ofs A 3))
  %458 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %459 = load i64, i64* %458
  %460 = inttoptr i64 %457 to i64*
  %461 = getelementptr i64, i64* %460, i32 1
  store i64 %459, i64* %461
  %462 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %457, i64* %462
  %463 = inttoptr i64 %427 to i64*
  store i64 %457, i64* %463
; # (ofs E 3)
  %464 = add i64 %443, 24
; # (link (ofs E 3))
  %465 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %466 = load i64, i64* %465
  %467 = inttoptr i64 %464 to i64*
  %468 = getelementptr i64, i64* %467, i32 1
  store i64 %466, i64* %468
  %469 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %464, i64* %469
  %470 = inttoptr i64 %443 to i64*
  store i64 %464, i64* %470
; # (loop (set In0 (val Out0) In1 (val Out1)) (if (and (pair (val In1...
  br label %$55
$55:
  %471 = phi i64 [%421, %$50], [%913, %$114] ; # B
  %472 = phi i64 [%427, %$50], [%914, %$114] ; # A
  %473 = phi i64 [%443, %$50], [%915, %$114] ; # E
; # (set In0 (val Out0) In1 (val Out1))
; # (val Out0)
  %474 = inttoptr i64 %381 to i64*
  %475 = load i64, i64* %474
  %476 = inttoptr i64 %397 to i64*
  store i64 %475, i64* %476
; # (val Out1)
  %477 = inttoptr i64 %389 to i64*
  %478 = load i64, i64* %477
  %479 = inttoptr i64 %405 to i64*
  store i64 %478, i64* %479
; # (if (and (pair (val In1)) (ge0 (cmpSort (caar In0) (caar In1)))) ...
; # (and (pair (val In1)) (ge0 (cmpSort (caar In0) (caar In1))))
; # (val In1)
  %480 = inttoptr i64 %405 to i64*
  %481 = load i64, i64* %480
; # (pair (val In1))
  %482 = and i64 %481, 15
  %483 = icmp eq i64 %482, 0
  br i1 %483, label %$57, label %$56
$57:
  %484 = phi i64 [%471, %$55] ; # B
  %485 = phi i64 [%472, %$55] ; # A
  %486 = phi i64 [%473, %$55] ; # E
; # (caar In0)
  %487 = inttoptr i64 %397 to i64*
  %488 = load i64, i64* %487
  %489 = inttoptr i64 %488 to i64*
  %490 = load i64, i64* %489
; # (caar In1)
  %491 = inttoptr i64 %405 to i64*
  %492 = load i64, i64* %491
  %493 = inttoptr i64 %492 to i64*
  %494 = load i64, i64* %493
; # (cmpSort (caar In0) (caar In1))
  %495 = inttoptr i64 %485 to i64*
  %496 = getelementptr i64, i64* %495, i32 3
  store i64 %490, i64* %496
  %497 = inttoptr i64 %484 to i64*
  %498 = getelementptr i64, i64* %497, i32 3
  store i64 %494, i64* %498
  %499 = call i64 @evList(i64 %486)
  %500 = icmp eq i64 %499, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %500, label %$58, label %$59
$58:
  br label %$60
$59:
  br label %$60
$60:
  %501 = phi i64 [0, %$58], [-1, %$59] ; # ->
; # (ge0 (cmpSort (caar In0) (caar In1)))
  %502 = icmp sge i64 %501, 0
  br label %$56
$56:
  %503 = phi i64 [%471, %$55], [%484, %$60] ; # B
  %504 = phi i64 [%472, %$55], [%485, %$60] ; # A
  %505 = phi i64 [%473, %$55], [%486, %$60] ; # E
  %506 = phi i1 [0, %$55], [%502, %$60] ; # ->
  br i1 %506, label %$61, label %$62
$61:
  %507 = phi i64 [%503, %$56] ; # B
  %508 = phi i64 [%504, %$56] ; # A
  %509 = phi i64 [%505, %$56] ; # E
; # (set In1 (cdr (set P (val In1))))
; # (set P (val In1))
; # (val In1)
  %510 = inttoptr i64 %405 to i64*
  %511 = load i64, i64* %510
  %512 = inttoptr i64 %413 to i64*
  store i64 %511, i64* %512
; # (cdr (set P (val In1)))
  %513 = inttoptr i64 %511 to i64*
  %514 = getelementptr i64, i64* %513, i32 1
  %515 = load i64, i64* %514
  %516 = inttoptr i64 %405 to i64*
  store i64 %515, i64* %516
  br label %$63
$62:
  %517 = phi i64 [%503, %$56] ; # B
  %518 = phi i64 [%504, %$56] ; # A
  %519 = phi i64 [%505, %$56] ; # E
; # (set In0 (cdr (set P (val In0))))
; # (set P (val In0))
; # (val In0)
  %520 = inttoptr i64 %397 to i64*
  %521 = load i64, i64* %520
  %522 = inttoptr i64 %413 to i64*
  store i64 %521, i64* %522
; # (cdr (set P (val In0)))
  %523 = inttoptr i64 %521 to i64*
  %524 = getelementptr i64, i64* %523, i32 1
  %525 = load i64, i64* %524
  %526 = inttoptr i64 %397 to i64*
  store i64 %525, i64* %526
  br label %$63
$63:
  %527 = phi i64 [%507, %$61], [%517, %$62] ; # B
  %528 = phi i64 [%508, %$61], [%518, %$62] ; # A
  %529 = phi i64 [%509, %$61], [%519, %$62] ; # E
  %530 = phi i64 [%515, %$61], [%525, %$62] ; # ->
; # (let (Tail0 (ofs (val P) 1) Tail1 0 Last (caar P)) (set Out0 (val...
; # (val P)
  %531 = inttoptr i64 %413 to i64*
  %532 = load i64, i64* %531
; # (ofs (val P) 1)
  %533 = add i64 %532, 8
; # (caar P)
  %534 = inttoptr i64 %413 to i64*
  %535 = load i64, i64* %534
  %536 = inttoptr i64 %535 to i64*
  %537 = load i64, i64* %536
; # (set Out0 (val P) Out1 $Nil)
; # (val P)
  %538 = inttoptr i64 %413 to i64*
  %539 = load i64, i64* %538
  %540 = inttoptr i64 %381 to i64*
  store i64 %539, i64* %540
  %541 = inttoptr i64 %389 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %541
; # (set 2 (val P) $Nil)
; # (val P)
  %542 = inttoptr i64 %413 to i64*
  %543 = load i64, i64* %542
  %544 = inttoptr i64 %543 to i64*
  %545 = getelementptr i64, i64* %544, i32 1
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %545
; # (while (or (pair (val In0)) (pair (val In1))) (cond ((atom (val I...
  br label %$64
$64:
  %546 = phi i64 [%527, %$63], [%882, %$113] ; # B
  %547 = phi i64 [%528, %$63], [%883, %$113] ; # A
  %548 = phi i64 [%529, %$63], [%884, %$113] ; # E
  %549 = phi i64 [%533, %$63], [%889, %$113] ; # Tail0
  %550 = phi i64 [0, %$63], [%886, %$113] ; # Tail1
  %551 = phi i64 [%537, %$63], [%897, %$113] ; # Last
; # (or (pair (val In0)) (pair (val In1)))
; # (val In0)
  %552 = inttoptr i64 %397 to i64*
  %553 = load i64, i64* %552
; # (pair (val In0))
  %554 = and i64 %553, 15
  %555 = icmp eq i64 %554, 0
  br i1 %555, label %$65, label %$66
$66:
  %556 = phi i64 [%546, %$64] ; # B
  %557 = phi i64 [%547, %$64] ; # A
  %558 = phi i64 [%548, %$64] ; # E
  %559 = phi i64 [%549, %$64] ; # Tail0
  %560 = phi i64 [%550, %$64] ; # Tail1
  %561 = phi i64 [%551, %$64] ; # Last
; # (val In1)
  %562 = inttoptr i64 %405 to i64*
  %563 = load i64, i64* %562
; # (pair (val In1))
  %564 = and i64 %563, 15
  %565 = icmp eq i64 %564, 0
  br label %$65
$65:
  %566 = phi i64 [%546, %$64], [%556, %$66] ; # B
  %567 = phi i64 [%547, %$64], [%557, %$66] ; # A
  %568 = phi i64 [%548, %$64], [%558, %$66] ; # E
  %569 = phi i64 [%549, %$64], [%559, %$66] ; # Tail0
  %570 = phi i64 [%550, %$64], [%560, %$66] ; # Tail1
  %571 = phi i64 [%551, %$64], [%561, %$66] ; # Last
  %572 = phi i1 [1, %$64], [%565, %$66] ; # ->
  br i1 %572, label %$67, label %$68
$67:
  %573 = phi i64 [%566, %$65] ; # B
  %574 = phi i64 [%567, %$65] ; # A
  %575 = phi i64 [%568, %$65] ; # E
  %576 = phi i64 [%569, %$65] ; # Tail0
  %577 = phi i64 [%570, %$65] ; # Tail1
  %578 = phi i64 [%571, %$65] ; # Last
; # (cond ((atom (val In1)) (set In0 (cdr (set P (val In0)))) (when (...
; # (val In1)
  %579 = inttoptr i64 %405 to i64*
  %580 = load i64, i64* %579
; # (atom (val In1))
  %581 = and i64 %580, 15
  %582 = icmp ne i64 %581, 0
  br i1 %582, label %$71, label %$70
$71:
  %583 = phi i64 [%573, %$67] ; # B
  %584 = phi i64 [%574, %$67] ; # A
  %585 = phi i64 [%575, %$67] ; # E
  %586 = phi i64 [%576, %$67] ; # Tail0
  %587 = phi i64 [%577, %$67] ; # Tail1
  %588 = phi i64 [%578, %$67] ; # Last
; # (set In0 (cdr (set P (val In0))))
; # (set P (val In0))
; # (val In0)
  %589 = inttoptr i64 %397 to i64*
  %590 = load i64, i64* %589
  %591 = inttoptr i64 %413 to i64*
  store i64 %590, i64* %591
; # (cdr (set P (val In0)))
  %592 = inttoptr i64 %590 to i64*
  %593 = getelementptr i64, i64* %592, i32 1
  %594 = load i64, i64* %593
  %595 = inttoptr i64 %397 to i64*
  store i64 %594, i64* %595
; # (when (lt0 (cmpSort (caar P) Last)) (xchg 'Tail0 'Tail1))
; # (caar P)
  %596 = inttoptr i64 %413 to i64*
  %597 = load i64, i64* %596
  %598 = inttoptr i64 %597 to i64*
  %599 = load i64, i64* %598
; # (cmpSort (caar P) Last)
  %600 = inttoptr i64 %584 to i64*
  %601 = getelementptr i64, i64* %600, i32 3
  store i64 %599, i64* %601
  %602 = inttoptr i64 %583 to i64*
  %603 = getelementptr i64, i64* %602, i32 3
  store i64 %588, i64* %603
  %604 = call i64 @evList(i64 %585)
  %605 = icmp eq i64 %604, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %605, label %$72, label %$73
$72:
  br label %$74
$73:
  br label %$74
$74:
  %606 = phi i64 [0, %$72], [-1, %$73] ; # ->
; # (lt0 (cmpSort (caar P) Last))
  %607 = icmp slt i64 %606, 0
  br i1 %607, label %$75, label %$76
$75:
  %608 = phi i64 [%583, %$74] ; # B
  %609 = phi i64 [%584, %$74] ; # A
  %610 = phi i64 [%585, %$74] ; # E
  %611 = phi i64 [%586, %$74] ; # Tail0
  %612 = phi i64 [%587, %$74] ; # Tail1
  %613 = phi i64 [%588, %$74] ; # Last
; # (xchg 'Tail0 'Tail1)
  br label %$76
$76:
  %614 = phi i64 [%583, %$74], [%608, %$75] ; # B
  %615 = phi i64 [%584, %$74], [%609, %$75] ; # A
  %616 = phi i64 [%585, %$74], [%610, %$75] ; # E
  %617 = phi i64 [%586, %$74], [%612, %$75] ; # Tail0
  %618 = phi i64 [%587, %$74], [%611, %$75] ; # Tail1
  %619 = phi i64 [%588, %$74], [%613, %$75] ; # Last
  br label %$69
$70:
  %620 = phi i64 [%573, %$67] ; # B
  %621 = phi i64 [%574, %$67] ; # A
  %622 = phi i64 [%575, %$67] ; # E
  %623 = phi i64 [%576, %$67] ; # Tail0
  %624 = phi i64 [%577, %$67] ; # Tail1
  %625 = phi i64 [%578, %$67] ; # Last
; # (val In0)
  %626 = inttoptr i64 %397 to i64*
  %627 = load i64, i64* %626
; # (atom (val In0))
  %628 = and i64 %627, 15
  %629 = icmp ne i64 %628, 0
  br i1 %629, label %$78, label %$77
$78:
  %630 = phi i64 [%620, %$70] ; # B
  %631 = phi i64 [%621, %$70] ; # A
  %632 = phi i64 [%622, %$70] ; # E
  %633 = phi i64 [%623, %$70] ; # Tail0
  %634 = phi i64 [%624, %$70] ; # Tail1
  %635 = phi i64 [%625, %$70] ; # Last
; # (set In1 (cdr (set P (val In1))))
; # (set P (val In1))
; # (val In1)
  %636 = inttoptr i64 %405 to i64*
  %637 = load i64, i64* %636
  %638 = inttoptr i64 %413 to i64*
  store i64 %637, i64* %638
; # (cdr (set P (val In1)))
  %639 = inttoptr i64 %637 to i64*
  %640 = getelementptr i64, i64* %639, i32 1
  %641 = load i64, i64* %640
  %642 = inttoptr i64 %405 to i64*
  store i64 %641, i64* %642
; # (when (lt0 (cmpSort (caar P) Last)) (xchg 'Tail0 'Tail1))
; # (caar P)
  %643 = inttoptr i64 %413 to i64*
  %644 = load i64, i64* %643
  %645 = inttoptr i64 %644 to i64*
  %646 = load i64, i64* %645
; # (cmpSort (caar P) Last)
  %647 = inttoptr i64 %631 to i64*
  %648 = getelementptr i64, i64* %647, i32 3
  store i64 %646, i64* %648
  %649 = inttoptr i64 %630 to i64*
  %650 = getelementptr i64, i64* %649, i32 3
  store i64 %635, i64* %650
  %651 = call i64 @evList(i64 %632)
  %652 = icmp eq i64 %651, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %652, label %$79, label %$80
$79:
  br label %$81
$80:
  br label %$81
$81:
  %653 = phi i64 [0, %$79], [-1, %$80] ; # ->
; # (lt0 (cmpSort (caar P) Last))
  %654 = icmp slt i64 %653, 0
  br i1 %654, label %$82, label %$83
$82:
  %655 = phi i64 [%630, %$81] ; # B
  %656 = phi i64 [%631, %$81] ; # A
  %657 = phi i64 [%632, %$81] ; # E
  %658 = phi i64 [%633, %$81] ; # Tail0
  %659 = phi i64 [%634, %$81] ; # Tail1
  %660 = phi i64 [%635, %$81] ; # Last
; # (xchg 'Tail0 'Tail1)
  br label %$83
$83:
  %661 = phi i64 [%630, %$81], [%655, %$82] ; # B
  %662 = phi i64 [%631, %$81], [%656, %$82] ; # A
  %663 = phi i64 [%632, %$81], [%657, %$82] ; # E
  %664 = phi i64 [%633, %$81], [%659, %$82] ; # Tail0
  %665 = phi i64 [%634, %$81], [%658, %$82] ; # Tail1
  %666 = phi i64 [%635, %$81], [%660, %$82] ; # Last
  br label %$69
$77:
  %667 = phi i64 [%620, %$70] ; # B
  %668 = phi i64 [%621, %$70] ; # A
  %669 = phi i64 [%622, %$70] ; # E
  %670 = phi i64 [%623, %$70] ; # Tail0
  %671 = phi i64 [%624, %$70] ; # Tail1
  %672 = phi i64 [%625, %$70] ; # Last
; # (caar In0)
  %673 = inttoptr i64 %397 to i64*
  %674 = load i64, i64* %673
  %675 = inttoptr i64 %674 to i64*
  %676 = load i64, i64* %675
; # (cmpSort (caar In0) Last)
  %677 = inttoptr i64 %668 to i64*
  %678 = getelementptr i64, i64* %677, i32 3
  store i64 %676, i64* %678
  %679 = inttoptr i64 %667 to i64*
  %680 = getelementptr i64, i64* %679, i32 3
  store i64 %672, i64* %680
  %681 = call i64 @evList(i64 %669)
  %682 = icmp eq i64 %681, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %682, label %$84, label %$85
$84:
  br label %$86
$85:
  br label %$86
$86:
  %683 = phi i64 [0, %$84], [-1, %$85] ; # ->
; # (lt0 (cmpSort (caar In0) Last))
  %684 = icmp slt i64 %683, 0
  br i1 %684, label %$88, label %$87
$88:
  %685 = phi i64 [%667, %$86] ; # B
  %686 = phi i64 [%668, %$86] ; # A
  %687 = phi i64 [%669, %$86] ; # E
  %688 = phi i64 [%670, %$86] ; # Tail0
  %689 = phi i64 [%671, %$86] ; # Tail1
  %690 = phi i64 [%672, %$86] ; # Last
; # (if (ge0 (cmpSort (caar In1) Last)) (set In1 (cdr (set P (val In1...
; # (caar In1)
  %691 = inttoptr i64 %405 to i64*
  %692 = load i64, i64* %691
  %693 = inttoptr i64 %692 to i64*
  %694 = load i64, i64* %693
; # (cmpSort (caar In1) Last)
  %695 = inttoptr i64 %686 to i64*
  %696 = getelementptr i64, i64* %695, i32 3
  store i64 %694, i64* %696
  %697 = inttoptr i64 %685 to i64*
  %698 = getelementptr i64, i64* %697, i32 3
  store i64 %690, i64* %698
  %699 = call i64 @evList(i64 %687)
  %700 = icmp eq i64 %699, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %700, label %$89, label %$90
$89:
  br label %$91
$90:
  br label %$91
$91:
  %701 = phi i64 [0, %$89], [-1, %$90] ; # ->
; # (ge0 (cmpSort (caar In1) Last))
  %702 = icmp sge i64 %701, 0
  br i1 %702, label %$92, label %$93
$92:
  %703 = phi i64 [%685, %$91] ; # B
  %704 = phi i64 [%686, %$91] ; # A
  %705 = phi i64 [%687, %$91] ; # E
  %706 = phi i64 [%688, %$91] ; # Tail0
  %707 = phi i64 [%689, %$91] ; # Tail1
  %708 = phi i64 [%690, %$91] ; # Last
; # (set In1 (cdr (set P (val In1))))
; # (set P (val In1))
; # (val In1)
  %709 = inttoptr i64 %405 to i64*
  %710 = load i64, i64* %709
  %711 = inttoptr i64 %413 to i64*
  store i64 %710, i64* %711
; # (cdr (set P (val In1)))
  %712 = inttoptr i64 %710 to i64*
  %713 = getelementptr i64, i64* %712, i32 1
  %714 = load i64, i64* %713
  %715 = inttoptr i64 %405 to i64*
  store i64 %714, i64* %715
  br label %$94
$93:
  %716 = phi i64 [%685, %$91] ; # B
  %717 = phi i64 [%686, %$91] ; # A
  %718 = phi i64 [%687, %$91] ; # E
  %719 = phi i64 [%688, %$91] ; # Tail0
  %720 = phi i64 [%689, %$91] ; # Tail1
  %721 = phi i64 [%690, %$91] ; # Last
; # (if (lt0 (cmpSort (caar In0) (caar In1))) (set In0 (cdr (set P (v...
; # (caar In0)
  %722 = inttoptr i64 %397 to i64*
  %723 = load i64, i64* %722
  %724 = inttoptr i64 %723 to i64*
  %725 = load i64, i64* %724
; # (caar In1)
  %726 = inttoptr i64 %405 to i64*
  %727 = load i64, i64* %726
  %728 = inttoptr i64 %727 to i64*
  %729 = load i64, i64* %728
; # (cmpSort (caar In0) (caar In1))
  %730 = inttoptr i64 %717 to i64*
  %731 = getelementptr i64, i64* %730, i32 3
  store i64 %725, i64* %731
  %732 = inttoptr i64 %716 to i64*
  %733 = getelementptr i64, i64* %732, i32 3
  store i64 %729, i64* %733
  %734 = call i64 @evList(i64 %718)
  %735 = icmp eq i64 %734, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %735, label %$95, label %$96
$95:
  br label %$97
$96:
  br label %$97
$97:
  %736 = phi i64 [0, %$95], [-1, %$96] ; # ->
; # (lt0 (cmpSort (caar In0) (caar In1)))
  %737 = icmp slt i64 %736, 0
  br i1 %737, label %$98, label %$99
$98:
  %738 = phi i64 [%716, %$97] ; # B
  %739 = phi i64 [%717, %$97] ; # A
  %740 = phi i64 [%718, %$97] ; # E
  %741 = phi i64 [%719, %$97] ; # Tail0
  %742 = phi i64 [%720, %$97] ; # Tail1
  %743 = phi i64 [%721, %$97] ; # Last
; # (set In0 (cdr (set P (val In0))))
; # (set P (val In0))
; # (val In0)
  %744 = inttoptr i64 %397 to i64*
  %745 = load i64, i64* %744
  %746 = inttoptr i64 %413 to i64*
  store i64 %745, i64* %746
; # (cdr (set P (val In0)))
  %747 = inttoptr i64 %745 to i64*
  %748 = getelementptr i64, i64* %747, i32 1
  %749 = load i64, i64* %748
  %750 = inttoptr i64 %397 to i64*
  store i64 %749, i64* %750
  br label %$100
$99:
  %751 = phi i64 [%716, %$97] ; # B
  %752 = phi i64 [%717, %$97] ; # A
  %753 = phi i64 [%718, %$97] ; # E
  %754 = phi i64 [%719, %$97] ; # Tail0
  %755 = phi i64 [%720, %$97] ; # Tail1
  %756 = phi i64 [%721, %$97] ; # Last
; # (set In1 (cdr (set P (val In1))))
; # (set P (val In1))
; # (val In1)
  %757 = inttoptr i64 %405 to i64*
  %758 = load i64, i64* %757
  %759 = inttoptr i64 %413 to i64*
  store i64 %758, i64* %759
; # (cdr (set P (val In1)))
  %760 = inttoptr i64 %758 to i64*
  %761 = getelementptr i64, i64* %760, i32 1
  %762 = load i64, i64* %761
  %763 = inttoptr i64 %405 to i64*
  store i64 %762, i64* %763
  br label %$100
$100:
  %764 = phi i64 [%738, %$98], [%751, %$99] ; # B
  %765 = phi i64 [%739, %$98], [%752, %$99] ; # A
  %766 = phi i64 [%740, %$98], [%753, %$99] ; # E
  %767 = phi i64 [%741, %$98], [%754, %$99] ; # Tail0
  %768 = phi i64 [%742, %$98], [%755, %$99] ; # Tail1
  %769 = phi i64 [%743, %$98], [%756, %$99] ; # Last
  %770 = phi i64 [%749, %$98], [%762, %$99] ; # ->
; # (xchg 'Tail0 'Tail1)
  br label %$94
$94:
  %771 = phi i64 [%703, %$92], [%764, %$100] ; # B
  %772 = phi i64 [%704, %$92], [%765, %$100] ; # A
  %773 = phi i64 [%705, %$92], [%766, %$100] ; # E
  %774 = phi i64 [%706, %$92], [%768, %$100] ; # Tail0
  %775 = phi i64 [%707, %$92], [%767, %$100] ; # Tail1
  %776 = phi i64 [%708, %$92], [%769, %$100] ; # Last
  %777 = phi i64 [%714, %$92], [%767, %$100] ; # ->
  br label %$69
$87:
  %778 = phi i64 [%667, %$86] ; # B
  %779 = phi i64 [%668, %$86] ; # A
  %780 = phi i64 [%669, %$86] ; # E
  %781 = phi i64 [%670, %$86] ; # Tail0
  %782 = phi i64 [%671, %$86] ; # Tail1
  %783 = phi i64 [%672, %$86] ; # Last
; # (caar In1)
  %784 = inttoptr i64 %405 to i64*
  %785 = load i64, i64* %784
  %786 = inttoptr i64 %785 to i64*
  %787 = load i64, i64* %786
; # (cmpSort (caar In1) Last)
  %788 = inttoptr i64 %779 to i64*
  %789 = getelementptr i64, i64* %788, i32 3
  store i64 %787, i64* %789
  %790 = inttoptr i64 %778 to i64*
  %791 = getelementptr i64, i64* %790, i32 3
  store i64 %783, i64* %791
  %792 = call i64 @evList(i64 %780)
  %793 = icmp eq i64 %792, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %793, label %$101, label %$102
$101:
  br label %$103
$102:
  br label %$103
$103:
  %794 = phi i64 [0, %$101], [-1, %$102] ; # ->
; # (lt0 (cmpSort (caar In1) Last))
  %795 = icmp slt i64 %794, 0
  br i1 %795, label %$105, label %$104
$105:
  %796 = phi i64 [%778, %$103] ; # B
  %797 = phi i64 [%779, %$103] ; # A
  %798 = phi i64 [%780, %$103] ; # E
  %799 = phi i64 [%781, %$103] ; # Tail0
  %800 = phi i64 [%782, %$103] ; # Tail1
  %801 = phi i64 [%783, %$103] ; # Last
; # (set In0 (cdr (set P (val In0))))
; # (set P (val In0))
; # (val In0)
  %802 = inttoptr i64 %397 to i64*
  %803 = load i64, i64* %802
  %804 = inttoptr i64 %413 to i64*
  store i64 %803, i64* %804
; # (cdr (set P (val In0)))
  %805 = inttoptr i64 %803 to i64*
  %806 = getelementptr i64, i64* %805, i32 1
  %807 = load i64, i64* %806
  %808 = inttoptr i64 %397 to i64*
  store i64 %807, i64* %808
  br label %$69
$104:
  %809 = phi i64 [%778, %$103] ; # B
  %810 = phi i64 [%779, %$103] ; # A
  %811 = phi i64 [%780, %$103] ; # E
  %812 = phi i64 [%781, %$103] ; # Tail0
  %813 = phi i64 [%782, %$103] ; # Tail1
  %814 = phi i64 [%783, %$103] ; # Last
; # (caar In0)
  %815 = inttoptr i64 %397 to i64*
  %816 = load i64, i64* %815
  %817 = inttoptr i64 %816 to i64*
  %818 = load i64, i64* %817
; # (caar In1)
  %819 = inttoptr i64 %405 to i64*
  %820 = load i64, i64* %819
  %821 = inttoptr i64 %820 to i64*
  %822 = load i64, i64* %821
; # (cmpSort (caar In0) (caar In1))
  %823 = inttoptr i64 %810 to i64*
  %824 = getelementptr i64, i64* %823, i32 3
  store i64 %818, i64* %824
  %825 = inttoptr i64 %809 to i64*
  %826 = getelementptr i64, i64* %825, i32 3
  store i64 %822, i64* %826
  %827 = call i64 @evList(i64 %811)
  %828 = icmp eq i64 %827, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %828, label %$106, label %$107
$106:
  br label %$108
$107:
  br label %$108
$108:
  %829 = phi i64 [0, %$106], [-1, %$107] ; # ->
; # (lt0 (cmpSort (caar In0) (caar In1)))
  %830 = icmp slt i64 %829, 0
  br i1 %830, label %$110, label %$109
$110:
  %831 = phi i64 [%809, %$108] ; # B
  %832 = phi i64 [%810, %$108] ; # A
  %833 = phi i64 [%811, %$108] ; # E
  %834 = phi i64 [%812, %$108] ; # Tail0
  %835 = phi i64 [%813, %$108] ; # Tail1
  %836 = phi i64 [%814, %$108] ; # Last
; # (set In0 (cdr (set P (val In0))))
; # (set P (val In0))
; # (val In0)
  %837 = inttoptr i64 %397 to i64*
  %838 = load i64, i64* %837
  %839 = inttoptr i64 %413 to i64*
  store i64 %838, i64* %839
; # (cdr (set P (val In0)))
  %840 = inttoptr i64 %838 to i64*
  %841 = getelementptr i64, i64* %840, i32 1
  %842 = load i64, i64* %841
  %843 = inttoptr i64 %397 to i64*
  store i64 %842, i64* %843
  br label %$69
$109:
  %844 = phi i64 [%809, %$108] ; # B
  %845 = phi i64 [%810, %$108] ; # A
  %846 = phi i64 [%811, %$108] ; # E
  %847 = phi i64 [%812, %$108] ; # Tail0
  %848 = phi i64 [%813, %$108] ; # Tail1
  %849 = phi i64 [%814, %$108] ; # Last
; # (set In1 (cdr (set P (val In1))))
; # (set P (val In1))
; # (val In1)
  %850 = inttoptr i64 %405 to i64*
  %851 = load i64, i64* %850
  %852 = inttoptr i64 %413 to i64*
  store i64 %851, i64* %852
; # (cdr (set P (val In1)))
  %853 = inttoptr i64 %851 to i64*
  %854 = getelementptr i64, i64* %853, i32 1
  %855 = load i64, i64* %854
  %856 = inttoptr i64 %405 to i64*
  store i64 %855, i64* %856
  br label %$69
$69:
  %857 = phi i64 [%614, %$76], [%661, %$83], [%771, %$94], [%796, %$105], [%831, %$110], [%844, %$109] ; # B
  %858 = phi i64 [%615, %$76], [%662, %$83], [%772, %$94], [%797, %$105], [%832, %$110], [%845, %$109] ; # A
  %859 = phi i64 [%616, %$76], [%663, %$83], [%773, %$94], [%798, %$105], [%833, %$110], [%846, %$109] ; # E
  %860 = phi i64 [%617, %$76], [%664, %$83], [%774, %$94], [%799, %$105], [%834, %$110], [%847, %$109] ; # Tail0
  %861 = phi i64 [%618, %$76], [%665, %$83], [%775, %$94], [%800, %$105], [%835, %$110], [%848, %$109] ; # Tail1
  %862 = phi i64 [%619, %$76], [%666, %$83], [%776, %$94], [%801, %$105], [%836, %$110], [%849, %$109] ; # Last
; # (if Tail0 (set Tail0 (val P)) (set Out1 (val P)))
  %863 = icmp ne i64 %860, 0
  br i1 %863, label %$111, label %$112
$111:
  %864 = phi i64 [%857, %$69] ; # B
  %865 = phi i64 [%858, %$69] ; # A
  %866 = phi i64 [%859, %$69] ; # E
  %867 = phi i64 [%860, %$69] ; # Tail0
  %868 = phi i64 [%861, %$69] ; # Tail1
  %869 = phi i64 [%862, %$69] ; # Last
; # (set Tail0 (val P))
; # (val P)
  %870 = inttoptr i64 %413 to i64*
  %871 = load i64, i64* %870
  %872 = inttoptr i64 %867 to i64*
  store i64 %871, i64* %872
  br label %$113
$112:
  %873 = phi i64 [%857, %$69] ; # B
  %874 = phi i64 [%858, %$69] ; # A
  %875 = phi i64 [%859, %$69] ; # E
  %876 = phi i64 [%860, %$69] ; # Tail0
  %877 = phi i64 [%861, %$69] ; # Tail1
  %878 = phi i64 [%862, %$69] ; # Last
; # (set Out1 (val P))
; # (val P)
  %879 = inttoptr i64 %413 to i64*
  %880 = load i64, i64* %879
  %881 = inttoptr i64 %389 to i64*
  store i64 %880, i64* %881
  br label %$113
$113:
  %882 = phi i64 [%864, %$111], [%873, %$112] ; # B
  %883 = phi i64 [%865, %$111], [%874, %$112] ; # A
  %884 = phi i64 [%866, %$111], [%875, %$112] ; # E
  %885 = phi i64 [%867, %$111], [%876, %$112] ; # Tail0
  %886 = phi i64 [%868, %$111], [%877, %$112] ; # Tail1
  %887 = phi i64 [%869, %$111], [%878, %$112] ; # Last
  %888 = phi i64 [%871, %$111], [%880, %$112] ; # ->
; # (ofs (if Tail0 (set Tail0 (val P)) (set Out1 (val P))) 1)
  %889 = add i64 %888, 8
; # (set 2 (val P) $Nil)
; # (val P)
  %890 = inttoptr i64 %413 to i64*
  %891 = load i64, i64* %890
  %892 = inttoptr i64 %891 to i64*
  %893 = getelementptr i64, i64* %892, i32 1
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %893
; # (caar P)
  %894 = inttoptr i64 %413 to i64*
  %895 = load i64, i64* %894
  %896 = inttoptr i64 %895 to i64*
  %897 = load i64, i64* %896
  br label %$64
$68:
  %898 = phi i64 [%566, %$65] ; # B
  %899 = phi i64 [%567, %$65] ; # A
  %900 = phi i64 [%568, %$65] ; # E
  %901 = phi i64 [%569, %$65] ; # Tail0
  %902 = phi i64 [%570, %$65] ; # Tail1
  %903 = phi i64 [%571, %$65] ; # Last
; # (? (atom (val Out1)) (val Out0))
; # (val Out1)
  %904 = inttoptr i64 %389 to i64*
  %905 = load i64, i64* %904
; # (atom (val Out1))
  %906 = and i64 %905, 15
  %907 = icmp ne i64 %906, 0
  br i1 %907, label %$116, label %$114
$116:
  %908 = phi i64 [%898, %$68] ; # B
  %909 = phi i64 [%899, %$68] ; # A
  %910 = phi i64 [%900, %$68] ; # E
; # (val Out0)
  %911 = inttoptr i64 %381 to i64*
  %912 = load i64, i64* %911
  br label %$115
$114:
  %913 = phi i64 [%898, %$68] ; # B
  %914 = phi i64 [%899, %$68] ; # A
  %915 = phi i64 [%900, %$68] ; # E
  br label %$55
$115:
  %916 = phi i64 [%908, %$116] ; # B
  %917 = phi i64 [%909, %$116] ; # A
  %918 = phi i64 [%910, %$116] ; # E
  %919 = phi i64 [%912, %$116] ; # ->
; # (drop *Safe)
  %920 = inttoptr i64 %381 to i64*
  %921 = getelementptr i64, i64* %920, i32 1
  %922 = load i64, i64* %921
  %923 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %922, i64* %923
  br label %$7
$7:
  %924 = phi i64 [%15, %$9], [%379, %$48], [%919, %$115] ; # ->
  ret i64 %924
}

define i64 @_Quit(i64) align 8 {
$1:
; # (let (X (cdr Exe) Nm (xName (evSym X)) Msg (bufString Nm (b8 (buf...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (evSym X)
  %4 = call i64 @evSym(i64 %3)
; # (xName (evSym X))
  %5 = call i64 @xName(i64 %4)
; # (bufSize Nm)
  %6 = call i64 @bufSize(i64 %5)
; # (b8 (bufSize Nm))
  %7 = alloca i8, i64 %6
; # (bufString Nm (b8 (bufSize Nm)))
  %8 = call i8* @bufString(i64 %5, i8* %7)
; # (if (atom (shift X)) 0 (eval (car X)))
; # (shift X)
  %9 = inttoptr i64 %3 to i64*
  %10 = getelementptr i64, i64* %9, i32 1
  %11 = load i64, i64* %10
; # (atom (shift X))
  %12 = and i64 %11, 15
  %13 = icmp ne i64 %12, 0
  br i1 %13, label %$2, label %$3
$2:
  %14 = phi i64 [%11, %$1] ; # X
  br label %$4
$3:
  %15 = phi i64 [%11, %$1] ; # X
; # (car X)
  %16 = inttoptr i64 %15 to i64*
  %17 = load i64, i64* %16
; # (eval (car X))
  %18 = and i64 %17, 6
  %19 = icmp ne i64 %18, 0
  br i1 %19, label %$7, label %$6
$7:
  br label %$5
$6:
  %20 = and i64 %17, 8
  %21 = icmp ne i64 %20, 0
  br i1 %21, label %$9, label %$8
$9:
  %22 = inttoptr i64 %17 to i64*
  %23 = load i64, i64* %22
  br label %$5
$8:
  %24 = call i64 @evList(i64 %17)
  br label %$5
$5:
  %25 = phi i64 [%17, %$7], [%23, %$9], [%24, %$8] ; # ->
  br label %$4
$4:
  %26 = phi i64 [%14, %$2], [%15, %$5] ; # X
  %27 = phi i64 [0, %$2], [%25, %$5] ; # ->
; # (err 0 (if (atom (shift X)) 0 (eval (car X))) ($ "%s") Msg)
  call void @err(i64 0, i64 %27, i8* bitcast ([3 x i8]* @$89 to i8*), i8* %8)
  unreachable
}

define i64 @_Sys(i64) align 8 {
$1:
; # (let (X (cdr Exe) Nm (xName (evSym X)) S (bufString Nm (b8 (bufSi...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (evSym X)
  %4 = call i64 @evSym(i64 %3)
; # (xName (evSym X))
  %5 = call i64 @xName(i64 %4)
; # (bufSize Nm)
  %6 = call i64 @bufSize(i64 %5)
; # (b8 (bufSize Nm))
  %7 = alloca i8, i64 %6
; # (bufString Nm (b8 (bufSize Nm)))
  %8 = call i8* @bufString(i64 %5, i8* %7)
; # (if (atom (shift X)) (mkStr (getenv S)) (let (Y (evSym X) Nm2 (xN...
; # (shift X)
  %9 = inttoptr i64 %3 to i64*
  %10 = getelementptr i64, i64* %9, i32 1
  %11 = load i64, i64* %10
; # (atom (shift X))
  %12 = and i64 %11, 15
  %13 = icmp ne i64 %12, 0
  br i1 %13, label %$2, label %$3
$2:
  %14 = phi i64 [%11, %$1] ; # X
; # (getenv S)
  %15 = call i8* @getenv(i8* %8)
; # (mkStr (getenv S))
  %16 = call i64 @mkStr(i8* %15)
  br label %$4
$3:
  %17 = phi i64 [%11, %$1] ; # X
; # (let (Y (evSym X) Nm2 (xName Y)) (if (setenv S (bufString Nm2 (b8...
; # (evSym X)
  %18 = call i64 @evSym(i64 %17)
; # (xName Y)
  %19 = call i64 @xName(i64 %18)
; # (if (setenv S (bufString Nm2 (b8 (bufSize Nm2))) 1) $Nil Y)
; # (bufSize Nm2)
  %20 = call i64 @bufSize(i64 %19)
; # (b8 (bufSize Nm2))
  %21 = alloca i8, i64 %20
; # (bufString Nm2 (b8 (bufSize Nm2)))
  %22 = call i8* @bufString(i64 %19, i8* %21)
; # (setenv S (bufString Nm2 (b8 (bufSize Nm2))) 1)
  %23 = call i32 @setenv(i8* %8, i8* %22, i32 1)
  %24 = icmp ne i32 %23, 0
  br i1 %24, label %$5, label %$6
$5:
  %25 = phi i64 [%17, %$3] ; # X
  br label %$7
$6:
  %26 = phi i64 [%17, %$3] ; # X
  br label %$7
$7:
  %27 = phi i64 [%25, %$5], [%26, %$6] ; # X
  %28 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$5], [%18, %$6] ; # ->
  br label %$4
$4:
  %29 = phi i64 [%14, %$2], [%27, %$7] ; # X
  %30 = phi i64 [%16, %$2], [%28, %$7] ; # ->
  ret i64 %30
}

define i64 @_Pwd(i64) align 8 {
$1:
; # (let P (getcwd null 0) (if P (prog1 (mkStr P) (free P)) $Nil))
; # (getcwd null 0)
  %1 = call i8* @getcwd(i8* null, i64 0)
; # (if P (prog1 (mkStr P) (free P)) $Nil)
  %2 = icmp ne i8* %1, null
  br i1 %2, label %$2, label %$3
$2:
; # (prog1 (mkStr P) (free P))
; # (mkStr P)
  %3 = call i64 @mkStr(i8* %1)
; # (free P)
  call void @free(i8* %1)
  br label %$4
$3:
  br label %$4
$4:
  %4 = phi i64 [%3, %$2], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$3] ; # ->
  ret i64 %4
}

define i64 @_Cd(i64) align 8 {
$1:
; # (let (Nm (xName (evSym (cdr Exe))) P (getcwd null 0)) (if P (prog...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (evSym (cdr Exe))
  %4 = call i64 @evSym(i64 %3)
; # (xName (evSym (cdr Exe)))
  %5 = call i64 @xName(i64 %4)
; # (getcwd null 0)
  %6 = call i8* @getcwd(i8* null, i64 0)
; # (if P (prog1 (if (lt0 (chdir (dirString Nm (b8 (pathSize Nm))))) ...
  %7 = icmp ne i8* %6, null
  br i1 %7, label %$2, label %$3
$2:
; # (prog1 (if (lt0 (chdir (dirString Nm (b8 (pathSize Nm))))) $Nil (...
; # (if (lt0 (chdir (dirString Nm (b8 (pathSize Nm))))) $Nil (mkStr P...
; # (pathSize Nm)
  %8 = call i64 @pathSize(i64 %5)
; # (b8 (pathSize Nm))
  %9 = alloca i8, i64 %8
; # (dirString Nm (b8 (pathSize Nm)))
  %10 = call i8* @dirString(i64 %5, i8* %9)
; # (chdir (dirString Nm (b8 (pathSize Nm))))
  %11 = call i32 @chdir(i8* %10)
; # (lt0 (chdir (dirString Nm (b8 (pathSize Nm)))))
  %12 = icmp slt i32 %11, 0
  br i1 %12, label %$5, label %$6
$5:
  br label %$7
$6:
; # (mkStr P)
  %13 = call i64 @mkStr(i8* %6)
  br label %$7
$7:
  %14 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$5], [%13, %$6] ; # ->
; # (free P)
  call void @free(i8* %6)
  br label %$4
$3:
  br label %$4
$4:
  %15 = phi i64 [%14, %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$3] ; # ->
  ret i64 %15
}

define i64 @_Ctty(i64) align 8 {
$1:
; # (let X (eval (cadr Exe)) (cond ((cnt? X) (set $TtyPid (i32 (int @...
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (cond ((cnt? X) (set $TtyPid (i32 (int @))) X) ((nil? X) (let Pty...
; # (cnt? X)
  %14 = and i64 %13, 2
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$9, label %$8
$9:
; # (set $TtyPid (i32 (int @)))
; # (int @)
  %16 = lshr i64 %13, 4
; # (i32 (int @))
  %17 = trunc i64 %16 to i32
  store i32 %17, i32* @$TtyPid
  br label %$7
$8:
; # (nil? X)
  %18 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %18, label %$11, label %$10
$11:
; # (let Pty (b32 2) (when (lt0 (openpty Pty (ofs Pty 1) null null nu...
; # (b32 2)
  %19 = alloca i32, i64 2
; # (when (lt0 (openpty Pty (ofs Pty 1) null null null)) (err Exe 0 (...
; # (ofs Pty 1)
  %20 = getelementptr i32, i32* %19, i32 1
; # (openpty Pty (ofs Pty 1) null null null)
  %21 = call i32 @openpty(i32* %19, i32* %20, i8* null, i8* null, i8* null)
; # (lt0 (openpty Pty (ofs Pty 1) null null null))
  %22 = icmp slt i32 %21, 0
  br i1 %22, label %$12, label %$13
$12:
; # (strErrno)
  %23 = call i8* @strErrno()
; # (err Exe 0 ($ "Can't open PTY: %s") (strErrno))
  call void @err(i64 %0, i64 0, i8* bitcast ([19 x i8]* @$90 to i8*), i8* %23)
  unreachable
$13:
; # (cond ((lt0 (fork)) (forkErr Exe)) ((=0 @) (close (val 2 Pty)) (l...
; # (fork)
  %24 = call i32 @fork()
; # (lt0 (fork))
  %25 = icmp slt i32 %24, 0
  br i1 %25, label %$16, label %$15
$16:
; # (forkErr Exe)
  call void @forkErr(i64 %0)
  unreachable
$15:
; # (=0 @)
  %26 = icmp eq i32 %24, 0
  br i1 %26, label %$18, label %$17
$18:
; # (val 2 Pty)
  %27 = getelementptr i32, i32* %19, i32 1
  %28 = load i32, i32* %27
; # (close (val 2 Pty))
  %29 = call i32 @close(i32 %28)
; # (let (Fd (val Pty) Poll (b64 2) Buf (b8 BUFSIZ)) (loop (pollIn 0 ...
; # (val Pty)
  %30 = load i32, i32* %19
; # (b64 2)
  %31 = alloca i64, i64 2
; # (b8 BUFSIZ)
  %32 = alloca i8, i64 4096
; # (loop (pollIn 0 Poll) (pollIn Fd (ofs Poll 1)) (if (lt0 (poll Pol...
  br label %$19
$19:
; # (pollIn 0 Poll)
  call void @pollIn(i32 0, i64* %31)
; # (ofs Poll 1)
  %33 = getelementptr i64, i64* %31, i32 1
; # (pollIn Fd (ofs Poll 1))
  call void @pollIn(i32 %30, i64* %33)
; # (if (lt0 (poll Poll 2 -1)) (? (<> (gErrno) EINTR)) (when (readyIn...
; # (poll Poll 2 -1)
  %34 = call i32 @poll(i64* %31, i32 2, i64 -1)
; # (lt0 (poll Poll 2 -1))
  %35 = icmp slt i32 %34, 0
  br i1 %35, label %$20, label %$21
$20:
; # (? (<> (gErrno) EINTR))
; # (gErrno)
  %36 = call i32 @gErrno()
; # (<> (gErrno) EINTR)
  %37 = icmp ne i32 %36, 2
  br i1 %37, label %$24, label %$23
$23:
  br label %$22
$21:
; # (when (readyIn Poll) (let N (read 0 Buf BUFSIZ) (? (le0 N)) (writ...
; # (readyIn Poll)
  %38 = call i1 @readyIn(i64* %31)
  br i1 %38, label %$25, label %$26
$25:
; # (let N (read 0 Buf BUFSIZ) (? (le0 N)) (write Fd Buf N))
; # (read 0 Buf BUFSIZ)
  %39 = call i64 @read(i32 0, i8* %32, i64 4096)
; # (? (le0 N))
; # (le0 N)
  %40 = icmp sle i64 %39, 0
  br i1 %40, label %$24, label %$27
$27:
; # (write Fd Buf N)
  %41 = call i64 @write(i32 %30, i8* %32, i64 %39)
  br label %$26
$26:
; # (when (readyIn (ofs Poll 1)) (let N (read Fd Buf BUFSIZ) (? (le0 ...
; # (ofs Poll 1)
  %42 = getelementptr i64, i64* %31, i32 1
; # (readyIn (ofs Poll 1))
  %43 = call i1 @readyIn(i64* %42)
  br i1 %43, label %$28, label %$29
$28:
; # (let N (read Fd Buf BUFSIZ) (? (le0 N)) (write 1 Buf N))
; # (read Fd Buf BUFSIZ)
  %44 = call i64 @read(i32 %30, i8* %32, i64 4096)
; # (? (le0 N))
; # (le0 N)
  %45 = icmp sle i64 %44, 0
  br i1 %45, label %$24, label %$30
$30:
; # (write 1 Buf N)
  %46 = call i64 @write(i32 1, i8* %32, i64 %44)
  br label %$29
$29:
  br label %$22
$22:
  br label %$19
$24:
  %47 = phi i64 [0, %$20], [0, %$25], [0, %$28] ; # ->
; # (exit 0)
  call void @exit(i32 0)
  unreachable
$17:
  br label %$14
$14:
  %48 = phi i64 [0, %$17] ; # ->
; # (val Pty)
  %49 = load i32, i32* %19
; # (close (val Pty))
  %50 = call i32 @close(i32 %49)
; # (val 2 Pty)
  %51 = getelementptr i32, i32* %19, i32 1
  %52 = load i32, i32* %51
; # (login_tty (val 2 Pty))
  %53 = call i32 @login_tty(i32 %52)
; # (val SIGINT Sig)
  %54 = getelementptr i32, i32* @Sig, i32 1
  %55 = load i32, i32* %54
; # (val SigIgn)
  %56 = load i8*, i8** @SigIgn
; # (signal (val SIGINT Sig) (val SigIgn))
  %57 = call i8* @signal(i32 %55, i8* %56)
; # (val $InFiles)
  %58 = load i8**, i8*** @$InFiles
; # (val (val $InFiles))
  %59 = load i8*, i8** %58
; # ((inFile (val (val $InFiles))) tty YES)
  %60 = getelementptr i8, i8* %59, i32 4128
  %61 = bitcast i8* %60 to i1*
  store i1 1, i1* %61
; # (val $OutFiles)
  %62 = load i8**, i8*** @$OutFiles
; # (val 2 (val $OutFiles))
  %63 = getelementptr i8*, i8** %62, i32 1
  %64 = load i8*, i8** %63
; # ((outFile (val 2 (val $OutFiles))) tty YES)
  %65 = getelementptr i8, i8* %64, i32 4104
  %66 = bitcast i8* %65 to i1*
  store i1 1, i1* %66
; # (val $OutFiles)
  %67 = load i8**, i8*** @$OutFiles
; # (val 3 (val $OutFiles))
  %68 = getelementptr i8*, i8** %67, i32 2
  %69 = load i8*, i8** %68
; # ((outFile (val 3 (val $OutFiles))) tty YES)
  %70 = getelementptr i8, i8* %69, i32 4104
  %71 = bitcast i8* %70 to i1*
  store i1 1, i1* %71
; # (set Tio (=0 (tcgetattr 0 OrgTermio)))
; # (tcgetattr 0 OrgTermio)
  %72 = call i32 @tcgetattr(i32 0, i8* @OrgTermio)
; # (=0 (tcgetattr 0 OrgTermio))
  %73 = icmp eq i32 %72, 0
  store i1 %73, i1* @Tio
  br label %$7
$10:
; # (let Nm (xName (xSym X)) (if (reopenTty (bufString Nm (b8 (bufSiz...
; # (xSym X)
  %74 = call i64 @xSym(i64 %13)
; # (xName (xSym X))
  %75 = call i64 @xName(i64 %74)
; # (if (reopenTty (bufString Nm (b8 (bufSize Nm)))) (let (In: (inFil...
; # (bufSize Nm)
  %76 = call i64 @bufSize(i64 %75)
; # (b8 (bufSize Nm))
  %77 = alloca i8, i64 %76
; # (bufString Nm (b8 (bufSize Nm)))
  %78 = call i8* @bufString(i64 %75, i8* %77)
; # (reopenTty (bufString Nm (b8 (bufSize Nm))))
  %79 = call i1 @reopenTty(i8* %78)
  br i1 %79, label %$31, label %$32
$31:
; # (let (In: (inFile (val (val $InFiles))) Out: (outFile (val 2 (val...
; # (val $InFiles)
  %80 = load i8**, i8*** @$InFiles
; # (val (val $InFiles))
  %81 = load i8*, i8** %80
; # (val $OutFiles)
  %82 = load i8**, i8*** @$OutFiles
; # (val 2 (val $OutFiles))
  %83 = getelementptr i8*, i8** %82, i32 1
  %84 = load i8*, i8** %83
; # (In: chr 0)
  %85 = getelementptr i8, i8* %81, i32 12
  %86 = bitcast i8* %85 to i32*
  store i32 0, i32* %86
; # (In: ix (In: cnt 0))
  %87 = getelementptr i8, i8* %81, i32 24
  %88 = bitcast i8* %87 to i32*
  %89 = getelementptr i8, i8* %81, i32 28
  %90 = bitcast i8* %89 to i32*
  store i32 0, i32* %90
  store i32 0, i32* %88
; # (In: tty YES)
  %91 = getelementptr i8, i8* %81, i32 4128
  %92 = bitcast i8* %91 to i1*
  store i1 1, i1* %92
; # (set Tio (=0 (tcgetattr 0 OrgTermio)))
; # (tcgetattr 0 OrgTermio)
  %93 = call i32 @tcgetattr(i32 0, i8* @OrgTermio)
; # (=0 (tcgetattr 0 OrgTermio))
  %94 = icmp eq i32 %93, 0
  store i1 %94, i1* @Tio
; # (Out: ix 0)
  %95 = getelementptr i8, i8* %84, i32 4
  %96 = bitcast i8* %95 to i32*
  store i32 0, i32* %96
; # (Out: tty YES)
  %97 = getelementptr i8, i8* %84, i32 4104
  %98 = bitcast i8* %97 to i1*
  store i1 1, i1* %98
; # (val $OutFiles)
  %99 = load i8**, i8*** @$OutFiles
; # (val 3 (val $OutFiles))
  %100 = getelementptr i8*, i8** %99, i32 2
  %101 = load i8*, i8** %100
; # ((outFile (val 3 (val $OutFiles))) tty YES)
  %102 = getelementptr i8, i8* %101, i32 4104
  %103 = bitcast i8* %102 to i1*
  store i1 1, i1* %103
  br label %$33
$32:
  br label %$33
$33:
  %104 = phi i64 [%13, %$31], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$32] ; # ->
  br label %$7
$7:
  %105 = phi i64 [%13, %$9], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$14], [%104, %$33] ; # ->
  ret i64 %105
}

define i64 @_Cmd(i64) align 8 {
$1:
; # (if (nil? (evSym (cdr Exe))) (mkStr (val $AV0)) (bufString (xName...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (evSym (cdr Exe))
  %4 = call i64 @evSym(i64 %3)
; # (nil? (evSym (cdr Exe)))
  %5 = icmp eq i64 %4, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %5, label %$2, label %$3
$2:
; # (val $AV0)
  %6 = load i8*, i8** @$AV0
; # (mkStr (val $AV0))
  %7 = call i64 @mkStr(i8* %6)
  br label %$4
$3:
; # (xName @)
  %8 = call i64 @xName(i64 %4)
; # (val $AV0)
  %9 = load i8*, i8** @$AV0
; # (bufString (xName @) (val $AV0))
  %10 = call i8* @bufString(i64 %8, i8* %9)
  br label %$4
$4:
  %11 = phi i64 [%7, %$2], [%4, %$3] ; # ->
  ret i64 %11
}

define i64 @_Dir(i64) align 8 {
$1:
; # (let X (cdr Exe) (if (getDir (let Nm (xName (evSym X)) (dirString...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (if (getDir (let Nm (xName (evSym X)) (dirString Nm (b8 (pathSize...
; # (let Nm (xName (evSym X)) (dirString Nm (b8 (pathSize Nm))))
; # (evSym X)
  %4 = call i64 @evSym(i64 %3)
; # (xName (evSym X))
  %5 = call i64 @xName(i64 %4)
; # (pathSize Nm)
  %6 = call i64 @pathSize(i64 %5)
; # (b8 (pathSize Nm))
  %7 = alloca i8, i64 %6
; # (dirString Nm (b8 (pathSize Nm)))
  %8 = call i8* @dirString(i64 %5, i8* %7)
; # (getDir (let Nm (xName (evSym X)) (dirString Nm (b8 (pathSize Nm)...
  %9 = call i8* @getDir(i8* %8)
  %10 = icmp ne i8* %9, null
  br i1 %10, label %$2, label %$3
$2:
  %11 = phi i64 [%3, %$1] ; # X
; # (let (P @ F (eval (car (shift X)))) (when (nil? F) (while (== (va...
; # (shift X)
  %12 = inttoptr i64 %11 to i64*
  %13 = getelementptr i64, i64* %12, i32 1
  %14 = load i64, i64* %13
; # (car (shift X))
  %15 = inttoptr i64 %14 to i64*
  %16 = load i64, i64* %15
; # (eval (car (shift X)))
  %17 = and i64 %16, 6
  %18 = icmp ne i64 %17, 0
  br i1 %18, label %$7, label %$6
$7:
  br label %$5
$6:
  %19 = and i64 %16, 8
  %20 = icmp ne i64 %19, 0
  br i1 %20, label %$9, label %$8
$9:
  %21 = inttoptr i64 %16 to i64*
  %22 = load i64, i64* %21
  br label %$5
$8:
  %23 = call i64 @evList(i64 %16)
  br label %$5
$5:
  %24 = phi i64 [%16, %$7], [%22, %$9], [%23, %$8] ; # ->
; # (when (nil? F) (while (== (val P) (char ".")) (unless (setq P (ge...
; # (nil? F)
  %25 = icmp eq i64 %24, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %25, label %$10, label %$11
$10:
  %26 = phi i64 [%14, %$5] ; # X
  %27 = phi i8* [%9, %$5] ; # P
; # (while (== (val P) (char ".")) (unless (setq P (getDir null)) (re...
  br label %$12
$12:
  %28 = phi i64 [%26, %$10], [%38, %$16] ; # X
  %29 = phi i8* [%27, %$10], [%39, %$16] ; # P
; # (val P)
  %30 = load i8, i8* %29
; # (== (val P) (char "."))
  %31 = icmp eq i8 %30, 46
  br i1 %31, label %$13, label %$14
$13:
  %32 = phi i64 [%28, %$12] ; # X
  %33 = phi i8* [%29, %$12] ; # P
; # (unless (setq P (getDir null)) (ret $Nil))
; # (getDir null)
  %34 = call i8* @getDir(i8* null)
  %35 = icmp ne i8* %34, null
  br i1 %35, label %$16, label %$15
$15:
  %36 = phi i64 [%32, %$13] ; # X
  %37 = phi i8* [%34, %$13] ; # P
; # (ret $Nil)
  ret i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
$16:
  %38 = phi i64 [%32, %$13] ; # X
  %39 = phi i8* [%34, %$13] ; # P
  br label %$12
$14:
  %40 = phi i64 [%28, %$12] ; # X
  %41 = phi i8* [%29, %$12] ; # P
  br label %$11
$11:
  %42 = phi i64 [%14, %$5], [%40, %$14] ; # X
  %43 = phi i8* [%9, %$5], [%41, %$14] ; # P
; # (let (Y (cons (mkStr P) $Nil) R (save Y)) (while (setq P (getDir ...
; # (mkStr P)
  %44 = call i64 @mkStr(i8* %43)
; # (cons (mkStr P) $Nil)
  %45 = call i64 @cons(i64 %44, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (save Y)
  %46 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %47 = load i64, i64* %46
  %48 = alloca i64, i64 2, align 16
  %49 = ptrtoint i64* %48 to i64
  %50 = inttoptr i64 %49 to i64*
  store i64 %45, i64* %50
  %51 = add i64 %49, 8
  %52 = inttoptr i64 %51 to i64*
  store i64 %47, i64* %52
  %53 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %49, i64* %53
; # (while (setq P (getDir null)) (unless (and (nil? F) (== (val P) (...
  br label %$17
$17:
  %54 = phi i64 [%42, %$11], [%79, %$23] ; # X
  %55 = phi i8* [%43, %$11], [%80, %$23] ; # P
  %56 = phi i64 [%45, %$11], [%81, %$23] ; # Y
; # (getDir null)
  %57 = call i8* @getDir(i8* null)
  %58 = icmp ne i8* %57, null
  br i1 %58, label %$18, label %$19
$18:
  %59 = phi i64 [%54, %$17] ; # X
  %60 = phi i8* [%57, %$17] ; # P
  %61 = phi i64 [%56, %$17] ; # Y
; # (unless (and (nil? F) (== (val P) (char "."))) (setq Y (set 2 Y (...
; # (and (nil? F) (== (val P) (char ".")))
; # (nil? F)
  %62 = icmp eq i64 %24, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %62, label %$21, label %$20
$21:
  %63 = phi i64 [%59, %$18] ; # X
  %64 = phi i8* [%60, %$18] ; # P
  %65 = phi i64 [%61, %$18] ; # Y
; # (val P)
  %66 = load i8, i8* %64
; # (== (val P) (char "."))
  %67 = icmp eq i8 %66, 46
  br label %$20
$20:
  %68 = phi i64 [%59, %$18], [%63, %$21] ; # X
  %69 = phi i8* [%60, %$18], [%64, %$21] ; # P
  %70 = phi i64 [%61, %$18], [%65, %$21] ; # Y
  %71 = phi i1 [0, %$18], [%67, %$21] ; # ->
  br i1 %71, label %$23, label %$22
$22:
  %72 = phi i64 [%68, %$20] ; # X
  %73 = phi i8* [%69, %$20] ; # P
  %74 = phi i64 [%70, %$20] ; # Y
; # (set 2 Y (cons (mkStr P) $Nil))
; # (mkStr P)
  %75 = call i64 @mkStr(i8* %73)
; # (cons (mkStr P) $Nil)
  %76 = call i64 @cons(i64 %75, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %77 = inttoptr i64 %74 to i64*
  %78 = getelementptr i64, i64* %77, i32 1
  store i64 %76, i64* %78
  br label %$23
$23:
  %79 = phi i64 [%68, %$20], [%72, %$22] ; # X
  %80 = phi i8* [%69, %$20], [%73, %$22] ; # P
  %81 = phi i64 [%70, %$20], [%76, %$22] ; # Y
  br label %$17
$19:
  %82 = phi i64 [%54, %$17] ; # X
  %83 = phi i8* [%57, %$17] ; # P
  %84 = phi i64 [%56, %$17] ; # Y
; # (drop *Safe)
  %85 = inttoptr i64 %49 to i64*
  %86 = getelementptr i64, i64* %85, i32 1
  %87 = load i64, i64* %86
  %88 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %87, i64* %88
  br label %$4
$3:
  %89 = phi i64 [%3, %$1] ; # X
  br label %$4
$4:
  %90 = phi i64 [%82, %$19], [%89, %$3] ; # X
  %91 = phi i64 [%45, %$19], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$3] ; # ->
  ret i64 %91
}

define i64 @_Info(i64) align 8 {
$1:
; # (let (X (cdr Exe) Nm (xName (set $At2 (evSym X))) Size (b64 1)) (...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (set $At2 (evSym X))
; # (evSym X)
  %4 = call i64 @evSym(i64 %3)
  %5 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 456) to i64) to i64*
  store i64 %4, i64* %5
; # (xName (set $At2 (evSym X)))
  %6 = call i64 @xName(i64 %4)
; # (b64 1)
  %7 = alloca i64, i64 1
; # (if (lt0 (fileInfo (nil? (eval (car (shift X)))) (== ZERO @) (dir...
; # (shift X)
  %8 = inttoptr i64 %3 to i64*
  %9 = getelementptr i64, i64* %8, i32 1
  %10 = load i64, i64* %9
; # (car (shift X))
  %11 = inttoptr i64 %10 to i64*
  %12 = load i64, i64* %11
; # (eval (car (shift X)))
  %13 = and i64 %12, 6
  %14 = icmp ne i64 %13, 0
  br i1 %14, label %$4, label %$3
$4:
  br label %$2
$3:
  %15 = and i64 %12, 8
  %16 = icmp ne i64 %15, 0
  br i1 %16, label %$6, label %$5
$6:
  %17 = inttoptr i64 %12 to i64*
  %18 = load i64, i64* %17
  br label %$2
$5:
  %19 = call i64 @evList(i64 %12)
  br label %$2
$2:
  %20 = phi i64 [%12, %$4], [%18, %$6], [%19, %$5] ; # ->
; # (nil? (eval (car (shift X))))
  %21 = icmp eq i64 %20, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
; # (== ZERO @)
  %22 = icmp eq i64 2, %20
; # (pathSize Nm)
  %23 = call i64 @pathSize(i64 %6)
; # (b8 (pathSize Nm))
  %24 = alloca i8, i64 %23
; # (dirString Nm (b8 (pathSize Nm)))
  %25 = call i8* @dirString(i64 %6, i8* %24)
; # (fileInfo (nil? (eval (car (shift X)))) (== ZERO @) (dirString Nm...
  %26 = call i64 @fileInfo(i1 %21, i1 %22, i8* %25, i64* %7)
; # (lt0 (fileInfo (nil? (eval (car (shift X)))) (== ZERO @) (dirStri...
  %27 = icmp slt i64 %26, 0
  br i1 %27, label %$7, label %$8
$7:
  %28 = phi i64 [%10, %$2] ; # X
  br label %$9
$8:
  %29 = phi i64 [%10, %$2] ; # X
; # (let N @ (cons (case (& N 3) (1 $T) (2 $Nil) (T (box64 (val Size)...
; # (case (& N 3) (1 $T) (2 $Nil) (T (box64 (val Size))))
; # (& N 3)
  %30 = and i64 %26, 3
  switch i64 %30, label %$10 [
    i64 1, label %$12
    i64 2, label %$13
  ]
$12:
  %31 = phi i64 [%29, %$8] ; # X
  %32 = phi i64 [%26, %$8] ; # N
  br label %$11
$13:
  %33 = phi i64 [%29, %$8] ; # X
  %34 = phi i64 [%26, %$8] ; # N
  br label %$11
$10:
  %35 = phi i64 [%29, %$8] ; # X
  %36 = phi i64 [%26, %$8] ; # N
; # (val Size)
  %37 = load i64, i64* %7
; # (box64 (val Size))
  %38 = and i64 %37, 17293822569102704640
  %39 = icmp ne i64 %38, 0
  br i1 %39, label %$14, label %$15
$14:
  %40 = call i64 @boxNum(i64 %37)
  br label %$16
$15:
  %41 = shl i64 %37, 4
  %42 = or i64 %41, 2
  br label %$16
$16:
  %43 = phi i64 [%40, %$14], [%42, %$15] ; # ->
  br label %$11
$11:
  %44 = phi i64 [%31, %$12], [%33, %$13], [%35, %$16] ; # X
  %45 = phi i64 [%32, %$12], [%34, %$13], [%36, %$16] ; # N
  %46 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$12], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$13], [%43, %$16] ; # ->
; # (shr N 2)
  %47 = lshr i64 %45, 2
; # (& (setq N (shr N 2)) (hex "FFFF"))
  %48 = and i64 %47, 65535
; # (shr N 16)
  %49 = lshr i64 %47, 16
; # (& (setq N (shr N 16)) (hex "FF"))
  %50 = and i64 %49, 255
; # (shr N 8)
  %51 = lshr i64 %49, 8
; # (& (setq N (shr N 8)) (hex "FF"))
  %52 = and i64 %51, 255
; # (tmDate (& (setq N (shr N 2)) (hex "FFFF")) (& (setq N (shr N 16)...
  %53 = call i64 @tmDate(i64 %48, i64 %50, i64 %52)
; # (shr N 8)
  %54 = lshr i64 %51, 8
; # (cnt (shr N 8))
  %55 = shl i64 %54, 4
  %56 = or i64 %55, 2
; # (cons (tmDate (& (setq N (shr N 2)) (hex "FFFF")) (& (setq N (shr...
  %57 = call i64 @cons(i64 %53, i64 %56)
; # (cons (case (& N 3) (1 $T) (2 $Nil) (T (box64 (val Size)))) (cons...
  %58 = call i64 @cons(i64 %46, i64 %57)
  br label %$9
$9:
  %59 = phi i64 [%28, %$7], [%44, %$11] ; # X
  %60 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$7], [%58, %$11] ; # ->
  ret i64 %60
}

define i64 @_File(i64) align 8 {
$1:
; # (let In: (inFile (val $InFile)) (ifn (and (In:) (In: name)) $Nil ...
; # (val $InFile)
  %1 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 72) to i8**)
; # (ifn (and (In:) (In: name)) $Nil (let (N (cnt (i64 (In: src))) S ...
; # (and (In:) (In: name))
; # (In:)
  %2 = icmp ne i8* %1, null
  br i1 %2, label %$3, label %$2
$3:
; # (In: name)
  %3 = bitcast i8* %1 to i8**
  %4 = load i8*, i8** %3
  %5 = icmp ne i8* %4, null
  br label %$2
$2:
  %6 = phi i1 [0, %$1], [%5, %$3] ; # ->
  br i1 %6, label %$5, label %$4
$4:
  br label %$6
$5:
; # (let (N (cnt (i64 (In: src))) S (In: name) P (strrchr S (char "/"...
; # (In: src)
  %7 = getelementptr i8, i8* %1, i32 20
  %8 = bitcast i8* %7 to i32*
  %9 = load i32, i32* %8
; # (i64 (In: src))
  %10 = sext i32 %9 to i64
; # (cnt (i64 (In: src)))
  %11 = shl i64 %10, 4
  %12 = or i64 %11, 2
; # (In: name)
  %13 = bitcast i8* %1 to i8**
  %14 = load i8*, i8** %13
; # (strrchr S (char "/"))
  %15 = call i8* @strrchr(i8* %14, i32 47)
; # (if P (let X (save (mkStrE S (inc 'P))) (cons X (cons (mkStr P) N...
  %16 = icmp ne i8* %15, null
  br i1 %16, label %$7, label %$8
$7:
  %17 = phi i8* [%15, %$5] ; # P
; # (let X (save (mkStrE S (inc 'P))) (cons X (cons (mkStr P) N)))
; # (inc 'P)
  %18 = getelementptr i8, i8* %17, i32 1
; # (mkStrE S (inc 'P))
  %19 = call i64 @mkStrE(i8* %14, i8* %18)
; # (save (mkStrE S (inc 'P)))
  %20 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %21 = load i64, i64* %20
  %22 = alloca i64, i64 2, align 16
  %23 = ptrtoint i64* %22 to i64
  %24 = inttoptr i64 %23 to i64*
  store i64 %19, i64* %24
  %25 = add i64 %23, 8
  %26 = inttoptr i64 %25 to i64*
  store i64 %21, i64* %26
  %27 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %23, i64* %27
; # (mkStr P)
  %28 = call i64 @mkStr(i8* %18)
; # (cons (mkStr P) N)
  %29 = call i64 @cons(i64 %28, i64 %12)
; # (cons X (cons (mkStr P) N))
  %30 = call i64 @cons(i64 %19, i64 %29)
; # (drop *Safe)
  %31 = inttoptr i64 %23 to i64*
  %32 = getelementptr i64, i64* %31, i32 1
  %33 = load i64, i64* %32
  %34 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %33, i64* %34
  br label %$9
$8:
  %35 = phi i8* [%15, %$5] ; # P
; # (mkStr S)
  %36 = call i64 @mkStr(i8* %14)
; # (cons (mkStr S) N)
  %37 = call i64 @cons(i64 %36, i64 %12)
; # (cons $Nil (cons (mkStr S) N))
  %38 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64 %37)
  br label %$9
$9:
  %39 = phi i8* [%18, %$7], [%35, %$8] ; # P
  %40 = phi i64 [%30, %$7], [%38, %$8] ; # ->
  br label %$6
$6:
  %41 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$4], [%40, %$9] ; # ->
  ret i64 %41
}

define i64 @_Argv(i64) align 8 {
$1:
; # (let (X (cdr Exe) A (val $AV) P (val A)) (when (and P (== (val P)...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (val $AV)
  %4 = load i8**, i8*** @$AV
; # (val A)
  %5 = load i8*, i8** %4
; # (when (and P (== (val P) (char "-")) (=0 (val 2 P))) (inc 'A))
; # (and P (== (val P) (char "-")) (=0 (val 2 P)))
  %6 = icmp ne i8* %5, null
  br i1 %6, label %$3, label %$2
$3:
  %7 = phi i64 [%3, %$1] ; # X
  %8 = phi i8** [%4, %$1] ; # A
  %9 = phi i8* [%5, %$1] ; # P
; # (val P)
  %10 = load i8, i8* %9
; # (== (val P) (char "-"))
  %11 = icmp eq i8 %10, 45
  br i1 %11, label %$4, label %$2
$4:
  %12 = phi i64 [%7, %$3] ; # X
  %13 = phi i8** [%8, %$3] ; # A
  %14 = phi i8* [%9, %$3] ; # P
; # (val 2 P)
  %15 = getelementptr i8, i8* %14, i32 1
  %16 = load i8, i8* %15
; # (=0 (val 2 P))
  %17 = icmp eq i8 %16, 0
  br label %$2
$2:
  %18 = phi i64 [%3, %$1], [%7, %$3], [%12, %$4] ; # X
  %19 = phi i8** [%4, %$1], [%8, %$3], [%13, %$4] ; # A
  %20 = phi i8* [%5, %$1], [%9, %$3], [%14, %$4] ; # P
  %21 = phi i1 [0, %$1], [0, %$3], [%17, %$4] ; # ->
  br i1 %21, label %$5, label %$6
$5:
  %22 = phi i64 [%18, %$2] ; # X
  %23 = phi i8** [%19, %$2] ; # A
  %24 = phi i8* [%20, %$2] ; # P
; # (inc 'A)
  %25 = getelementptr i8*, i8** %23, i32 1
  br label %$6
$6:
  %26 = phi i64 [%18, %$2], [%22, %$5] ; # X
  %27 = phi i8** [%19, %$2], [%25, %$5] ; # A
  %28 = phi i8* [%20, %$2], [%24, %$5] ; # P
; # (if (nil? X) (if (setq P (val A)) (let (Y (cons (mkStr P) $Nil) R...
; # (nil? X)
  %29 = icmp eq i64 %26, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %29, label %$7, label %$8
$7:
  %30 = phi i64 [%26, %$6] ; # X
  %31 = phi i8** [%27, %$6] ; # A
  %32 = phi i8* [%28, %$6] ; # P
; # (if (setq P (val A)) (let (Y (cons (mkStr P) $Nil) R (save Y)) (w...
; # (val A)
  %33 = load i8*, i8** %31
  %34 = icmp ne i8* %33, null
  br i1 %34, label %$10, label %$11
$10:
  %35 = phi i64 [%30, %$7] ; # X
  %36 = phi i8** [%31, %$7] ; # A
  %37 = phi i8* [%33, %$7] ; # P
; # (let (Y (cons (mkStr P) $Nil) R (save Y)) (while (setq P (val (in...
; # (mkStr P)
  %38 = call i64 @mkStr(i8* %37)
; # (cons (mkStr P) $Nil)
  %39 = call i64 @cons(i64 %38, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (save Y)
  %40 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %41 = load i64, i64* %40
  %42 = alloca i64, i64 2, align 16
  %43 = ptrtoint i64* %42 to i64
  %44 = inttoptr i64 %43 to i64*
  store i64 %39, i64* %44
  %45 = add i64 %43, 8
  %46 = inttoptr i64 %45 to i64*
  store i64 %41, i64* %46
  %47 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %43, i64* %47
; # (while (setq P (val (inc 'A))) (setq Y (set 2 Y (cons (mkStr P) $...
  br label %$13
$13:
  %48 = phi i64 [%35, %$10], [%55, %$14] ; # X
  %49 = phi i8** [%36, %$10], [%56, %$14] ; # A
  %50 = phi i8* [%37, %$10], [%57, %$14] ; # P
  %51 = phi i64 [%39, %$10], [%60, %$14] ; # Y
; # (inc 'A)
  %52 = getelementptr i8*, i8** %49, i32 1
; # (val (inc 'A))
  %53 = load i8*, i8** %52
  %54 = icmp ne i8* %53, null
  br i1 %54, label %$14, label %$15
$14:
  %55 = phi i64 [%48, %$13] ; # X
  %56 = phi i8** [%52, %$13] ; # A
  %57 = phi i8* [%53, %$13] ; # P
  %58 = phi i64 [%51, %$13] ; # Y
; # (set 2 Y (cons (mkStr P) $Nil))
; # (mkStr P)
  %59 = call i64 @mkStr(i8* %57)
; # (cons (mkStr P) $Nil)
  %60 = call i64 @cons(i64 %59, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %61 = inttoptr i64 %58 to i64*
  %62 = getelementptr i64, i64* %61, i32 1
  store i64 %60, i64* %62
  br label %$13
$15:
  %63 = phi i64 [%48, %$13] ; # X
  %64 = phi i8** [%52, %$13] ; # A
  %65 = phi i8* [%53, %$13] ; # P
  %66 = phi i64 [%51, %$13] ; # Y
; # (drop *Safe)
  %67 = inttoptr i64 %43 to i64*
  %68 = getelementptr i64, i64* %67, i32 1
  %69 = load i64, i64* %68
  %70 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %69, i64* %70
  br label %$12
$11:
  %71 = phi i64 [%30, %$7] ; # X
  %72 = phi i8** [%31, %$7] ; # A
  %73 = phi i8* [%33, %$7] ; # P
  br label %$12
$12:
  %74 = phi i64 [%63, %$15], [%71, %$11] ; # X
  %75 = phi i8** [%64, %$15], [%72, %$11] ; # A
  %76 = phi i8* [%65, %$15], [%73, %$11] ; # P
  %77 = phi i64 [%39, %$15], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$11] ; # ->
  br label %$9
$8:
  %78 = phi i64 [%26, %$6] ; # X
  %79 = phi i8** [%27, %$6] ; # A
  %80 = phi i8* [%28, %$6] ; # P
; # (loop (? (atom X) (set (needChkVar Exe X) (if (setq P (val A)) (l...
  br label %$16
$16:
  %81 = phi i64 [%78, %$8], [%171, %$41] ; # X
  %82 = phi i8** [%79, %$8], [%172, %$41] ; # A
  %83 = phi i8* [%80, %$8], [%173, %$41] ; # P
; # (? (atom X) (set (needChkVar Exe X) (if (setq P (val A)) (let (Y ...
; # (atom X)
  %84 = and i64 %81, 15
  %85 = icmp ne i64 %84, 0
  br i1 %85, label %$19, label %$17
$19:
  %86 = phi i64 [%81, %$16] ; # X
  %87 = phi i8** [%82, %$16] ; # A
  %88 = phi i8* [%83, %$16] ; # P
; # (set (needChkVar Exe X) (if (setq P (val A)) (let (Y (cons (mkStr...
; # (needChkVar Exe X)
  %89 = and i64 %86, 6
  %90 = icmp ne i64 %89, 0
  br i1 %90, label %$20, label %$21
$20:
  call void @varErr(i64 %0, i64 %86)
  unreachable
$21:
  %91 = icmp uge i64 %86, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %91, label %$23, label %$22
$23:
  %92 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %86
  br label %$22
$22:
  %93 = phi i1 [0, %$21], [%92, %$23] ; # ->
  br i1 %93, label %$24, label %$25
$24:
  call void @protErr(i64 %0, i64 %86)
  unreachable
$25:
; # (if (setq P (val A)) (let (Y (cons (mkStr P) $Nil) R Y) (save R (...
; # (val A)
  %94 = load i8*, i8** %87
  %95 = icmp ne i8* %94, null
  br i1 %95, label %$26, label %$27
$26:
  %96 = phi i64 [%86, %$25] ; # X
  %97 = phi i8** [%87, %$25] ; # A
  %98 = phi i8* [%94, %$25] ; # P
; # (let (Y (cons (mkStr P) $Nil) R Y) (save R (while (setq P (val (i...
; # (mkStr P)
  %99 = call i64 @mkStr(i8* %98)
; # (cons (mkStr P) $Nil)
  %100 = call i64 @cons(i64 %99, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (save R (while (setq P (val (inc 'A))) (setq Y (set 2 Y (cons (mk...
  %101 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %102 = load i64, i64* %101
  %103 = alloca i64, i64 2, align 16
  %104 = ptrtoint i64* %103 to i64
  %105 = inttoptr i64 %104 to i64*
  store i64 %100, i64* %105
  %106 = add i64 %104, 8
  %107 = inttoptr i64 %106 to i64*
  store i64 %102, i64* %107
  %108 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %104, i64* %108
; # (while (setq P (val (inc 'A))) (setq Y (set 2 Y (cons (mkStr P) $...
  br label %$29
$29:
  %109 = phi i64 [%96, %$26], [%116, %$30] ; # X
  %110 = phi i8** [%97, %$26], [%117, %$30] ; # A
  %111 = phi i8* [%98, %$26], [%118, %$30] ; # P
  %112 = phi i64 [%100, %$26], [%121, %$30] ; # Y
; # (inc 'A)
  %113 = getelementptr i8*, i8** %110, i32 1
; # (val (inc 'A))
  %114 = load i8*, i8** %113
  %115 = icmp ne i8* %114, null
  br i1 %115, label %$30, label %$31
$30:
  %116 = phi i64 [%109, %$29] ; # X
  %117 = phi i8** [%113, %$29] ; # A
  %118 = phi i8* [%114, %$29] ; # P
  %119 = phi i64 [%112, %$29] ; # Y
; # (set 2 Y (cons (mkStr P) $Nil))
; # (mkStr P)
  %120 = call i64 @mkStr(i8* %118)
; # (cons (mkStr P) $Nil)
  %121 = call i64 @cons(i64 %120, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %122 = inttoptr i64 %119 to i64*
  %123 = getelementptr i64, i64* %122, i32 1
  store i64 %121, i64* %123
  br label %$29
$31:
  %124 = phi i64 [%109, %$29] ; # X
  %125 = phi i8** [%113, %$29] ; # A
  %126 = phi i8* [%114, %$29] ; # P
  %127 = phi i64 [%112, %$29] ; # Y
; # drop
  %128 = inttoptr i64 %104 to i64*
  %129 = getelementptr i64, i64* %128, i32 1
  %130 = load i64, i64* %129
  %131 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %130, i64* %131
  br label %$28
$27:
  %132 = phi i64 [%86, %$25] ; # X
  %133 = phi i8** [%87, %$25] ; # A
  %134 = phi i8* [%94, %$25] ; # P
  br label %$28
$28:
  %135 = phi i64 [%124, %$31], [%132, %$27] ; # X
  %136 = phi i8** [%125, %$31], [%133, %$27] ; # A
  %137 = phi i8* [%126, %$31], [%134, %$27] ; # P
  %138 = phi i64 [%100, %$31], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$27] ; # ->
  %139 = inttoptr i64 %86 to i64*
  store i64 %138, i64* %139
  br label %$18
$17:
  %140 = phi i64 [%81, %$16] ; # X
  %141 = phi i8** [%82, %$16] ; # A
  %142 = phi i8* [%83, %$16] ; # P
; # (let Y (ifn (setq P (val A)) $Nil (inc 'A) (mkStr P)) (set (needC...
; # (ifn (setq P (val A)) $Nil (inc 'A) (mkStr P))
; # (val A)
  %143 = load i8*, i8** %141
  %144 = icmp ne i8* %143, null
  br i1 %144, label %$33, label %$32
$32:
  %145 = phi i64 [%140, %$17] ; # X
  %146 = phi i8** [%141, %$17] ; # A
  %147 = phi i8* [%143, %$17] ; # P
  br label %$34
$33:
  %148 = phi i64 [%140, %$17] ; # X
  %149 = phi i8** [%141, %$17] ; # A
  %150 = phi i8* [%143, %$17] ; # P
; # (inc 'A)
  %151 = getelementptr i8*, i8** %149, i32 1
; # (mkStr P)
  %152 = call i64 @mkStr(i8* %150)
  br label %$34
$34:
  %153 = phi i64 [%145, %$32], [%148, %$33] ; # X
  %154 = phi i8** [%146, %$32], [%151, %$33] ; # A
  %155 = phi i8* [%147, %$32], [%150, %$33] ; # P
  %156 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$32], [%152, %$33] ; # ->
; # (set (needChkVar Exe (++ X)) Y)
; # (++ X)
  %157 = inttoptr i64 %153 to i64*
  %158 = load i64, i64* %157
  %159 = getelementptr i64, i64* %157, i32 1
  %160 = load i64, i64* %159
; # (needChkVar Exe (++ X))
  %161 = and i64 %158, 6
  %162 = icmp ne i64 %161, 0
  br i1 %162, label %$35, label %$36
$35:
  call void @varErr(i64 %0, i64 %158)
  unreachable
$36:
  %163 = icmp uge i64 %158, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %163, label %$38, label %$37
$38:
  %164 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %158
  br label %$37
$37:
  %165 = phi i1 [0, %$36], [%164, %$38] ; # ->
  br i1 %165, label %$39, label %$40
$39:
  call void @protErr(i64 %0, i64 %158)
  unreachable
$40:
  %166 = inttoptr i64 %158 to i64*
  store i64 %156, i64* %166
; # (? (nil? X) Y)
; # (nil? X)
  %167 = icmp eq i64 %160, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %167, label %$42, label %$41
$42:
  %168 = phi i64 [%160, %$40] ; # X
  %169 = phi i8** [%154, %$40] ; # A
  %170 = phi i8* [%155, %$40] ; # P
  br label %$18
$41:
  %171 = phi i64 [%160, %$40] ; # X
  %172 = phi i8** [%154, %$40] ; # A
  %173 = phi i8* [%155, %$40] ; # P
  br label %$16
$18:
  %174 = phi i64 [%135, %$28], [%168, %$42] ; # X
  %175 = phi i8** [%136, %$28], [%169, %$42] ; # A
  %176 = phi i8* [%137, %$28], [%170, %$42] ; # P
  %177 = phi i64 [%138, %$28], [%156, %$42] ; # ->
  br label %$9
$9:
  %178 = phi i64 [%74, %$12], [%174, %$18] ; # X
  %179 = phi i8** [%75, %$12], [%175, %$18] ; # A
  %180 = phi i8* [%76, %$12], [%176, %$18] ; # P
  %181 = phi i64 [%77, %$12], [%177, %$18] ; # ->
  ret i64 %181
}

define i64 @_Opt(i64) align 8 {
$1:
; # (let (A (val $AV) P (val A)) (if (or (=0 P) (and (== (val P) (cha...
; # (val $AV)
  %1 = load i8**, i8*** @$AV
; # (val A)
  %2 = load i8*, i8** %1
; # (if (or (=0 P) (and (== (val P) (char "-")) (=0 (val 2 P)))) $Nil...
; # (or (=0 P) (and (== (val P) (char "-")) (=0 (val 2 P))))
; # (=0 P)
  %3 = icmp eq i8* %2, null
  br i1 %3, label %$2, label %$3
$3:
; # (and (== (val P) (char "-")) (=0 (val 2 P)))
; # (val P)
  %4 = load i8, i8* %2
; # (== (val P) (char "-"))
  %5 = icmp eq i8 %4, 45
  br i1 %5, label %$5, label %$4
$5:
; # (val 2 P)
  %6 = getelementptr i8, i8* %2, i32 1
  %7 = load i8, i8* %6
; # (=0 (val 2 P))
  %8 = icmp eq i8 %7, 0
  br label %$4
$4:
  %9 = phi i1 [0, %$3], [%8, %$5] ; # ->
  br label %$2
$2:
  %10 = phi i1 [1, %$1], [%9, %$4] ; # ->
  br i1 %10, label %$6, label %$7
$6:
  br label %$8
$7:
; # (set $AV (inc A))
; # (inc A)
  %11 = getelementptr i8*, i8** %1, i32 1
  store i8** %11, i8*** @$AV
; # (mkStr P)
  %12 = call i64 @mkStr(i8* %2)
  br label %$8
$8:
  %13 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$6], [%12, %$7] ; # ->
  ret i64 %13
}

define i64 @_Errno(i64) align 8 {
$1:
; # (nErrno)
  %1 = call i32 @nErrno()
; # (i64 (nErrno))
  %2 = sext i32 %1 to i64
; # (cnt (i64 (nErrno)))
  %3 = shl i64 %2, 4
  %4 = or i64 %3, 2
  ret i64 %4
}

define i32 @fetchChar(i8**) align 8 {
$1:
; # (let (P (val Ptr) C (i32 (val P))) (prog2 (inc 'P) (cond ((>= 127...
; # (val Ptr)
  %1 = load i8*, i8** %0
; # (val P)
  %2 = load i8, i8* %1
; # (i32 (val P))
  %3 = zext i8 %2 to i32
; # (prog2 (inc 'P) (cond ((>= 127 C) C) ((== C (hex "FF")) (i32 TOP)...
; # (inc 'P)
  %4 = getelementptr i8, i8* %1, i32 1
; # (cond ((>= 127 C) C) ((== C (hex "FF")) (i32 TOP)) (T (| (shl (if...
; # (>= 127 C)
  %5 = icmp sge i32 127, %3
  br i1 %5, label %$4, label %$3
$4:
  %6 = phi i8* [%4, %$1] ; # P
  br label %$2
$3:
  %7 = phi i8* [%4, %$1] ; # P
; # (== C (hex "FF"))
  %8 = icmp eq i32 %3, 255
  br i1 %8, label %$6, label %$5
$6:
  %9 = phi i8* [%7, %$3] ; # P
; # (i32 TOP)
  br label %$2
$5:
  %10 = phi i8* [%7, %$3] ; # P
; # (ifn (& C (hex "20")) (& C (hex "1F")) (| (shl (ifn (& C (hex "10...
; # (& C (hex "20"))
  %11 = and i32 %3, 32
  %12 = icmp ne i32 %11, 0
  br i1 %12, label %$8, label %$7
$7:
  %13 = phi i8* [%10, %$5] ; # P
; # (& C (hex "1F"))
  %14 = and i32 %3, 31
  br label %$9
$8:
  %15 = phi i8* [%10, %$5] ; # P
; # (ifn (& C (hex "10")) (& C (hex "0F")) (| (shl (& C (hex "7")) 6)...
; # (& C (hex "10"))
  %16 = and i32 %3, 16
  %17 = icmp ne i32 %16, 0
  br i1 %17, label %$11, label %$10
$10:
  %18 = phi i8* [%15, %$8] ; # P
; # (& C (hex "0F"))
  %19 = and i32 %3, 15
  br label %$12
$11:
  %20 = phi i8* [%15, %$8] ; # P
; # (& C (hex "7"))
  %21 = and i32 %3, 7
; # (shl (& C (hex "7")) 6)
  %22 = shl i32 %21, 6
; # (prog1 (val P) (inc 'P))
; # (val P)
  %23 = load i8, i8* %20
; # (inc 'P)
  %24 = getelementptr i8, i8* %20, i32 1
; # (i32 (prog1 (val P) (inc 'P)))
  %25 = zext i8 %23 to i32
; # (& (i32 (prog1 (val P) (inc 'P))) (hex "3F"))
  %26 = and i32 %25, 63
; # (| (shl (& C (hex "7")) 6) (& (i32 (prog1 (val P) (inc 'P))) (hex...
  %27 = or i32 %22, %26
  br label %$12
$12:
  %28 = phi i8* [%18, %$10], [%24, %$11] ; # P
  %29 = phi i32 [%19, %$10], [%27, %$11] ; # ->
; # (shl (ifn (& C (hex "10")) (& C (hex "0F")) (| (shl (& C (hex "7"...
  %30 = shl i32 %29, 6
; # (prog1 (val P) (inc 'P))
; # (val P)
  %31 = load i8, i8* %28
; # (inc 'P)
  %32 = getelementptr i8, i8* %28, i32 1
; # (i32 (prog1 (val P) (inc 'P)))
  %33 = zext i8 %31 to i32
; # (& (i32 (prog1 (val P) (inc 'P))) (hex "3F"))
  %34 = and i32 %33, 63
; # (| (shl (ifn (& C (hex "10")) (& C (hex "0F")) (| (shl (& C (hex ...
  %35 = or i32 %30, %34
  br label %$9
$9:
  %36 = phi i8* [%13, %$7], [%32, %$12] ; # P
  %37 = phi i32 [%14, %$7], [%35, %$12] ; # ->
; # (shl (ifn (& C (hex "20")) (& C (hex "1F")) (| (shl (ifn (& C (he...
  %38 = shl i32 %37, 6
; # (prog1 (val P) (inc 'P))
; # (val P)
  %39 = load i8, i8* %36
; # (inc 'P)
  %40 = getelementptr i8, i8* %36, i32 1
; # (i32 (prog1 (val P) (inc 'P)))
  %41 = zext i8 %39 to i32
; # (& (i32 (prog1 (val P) (inc 'P))) (hex "3F"))
  %42 = and i32 %41, 63
; # (| (shl (ifn (& C (hex "20")) (& C (hex "1F")) (| (shl (ifn (& C ...
  %43 = or i32 %38, %42
  br label %$2
$2:
  %44 = phi i8* [%6, %$4], [%9, %$6], [%40, %$9] ; # P
  %45 = phi i32 [%3, %$4], [1114112, %$6], [%43, %$9] ; # ->
; # (set Ptr P)
  store i8* %44, i8** %0
  ret i32 %45
}

define i64 @natBuf(i64, i8*) align 8 {
$1:
; # (if (atom Val) (if (sign? Val) (let P (i32* Ptr) (set P (i32 (int...
; # (atom Val)
  %2 = and i64 %0, 15
  %3 = icmp ne i64 %2, 0
  br i1 %3, label %$2, label %$3
$2:
  %4 = phi i64 [%0, %$1] ; # Val
  %5 = phi i8* [%1, %$1] ; # Ptr
; # (if (sign? Val) (let P (i32* Ptr) (set P (i32 (int Val))) 4) (set...
; # (sign? Val)
  %6 = and i64 %4, 8
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$5, label %$6
$5:
  %8 = phi i64 [%4, %$2] ; # Val
  %9 = phi i8* [%5, %$2] ; # Ptr
; # (let P (i32* Ptr) (set P (i32 (int Val))) 4)
; # (i32* Ptr)
  %10 = bitcast i8* %9 to i32*
; # (set P (i32 (int Val)))
; # (int Val)
  %11 = lshr i64 %8, 4
; # (i32 (int Val))
  %12 = trunc i64 %11 to i32
  store i32 %12, i32* %10
  br label %$7
$6:
  %13 = phi i64 [%4, %$2] ; # Val
  %14 = phi i8* [%5, %$2] ; # Ptr
; # (set Ptr (i8 (int Val)))
; # (int Val)
  %15 = lshr i64 %13, 4
; # (i8 (int Val))
  %16 = trunc i64 %15 to i8
  store i8 %16, i8* %14
  br label %$7
$7:
  %17 = phi i64 [%8, %$5], [%13, %$6] ; # Val
  %18 = phi i8* [%9, %$5], [%14, %$6] ; # Ptr
  %19 = phi i64 [4, %$5], [1, %$6] ; # ->
  br label %$4
$3:
  %20 = phi i64 [%0, %$1] ; # Val
  %21 = phi i8* [%1, %$1] ; # Ptr
; # (let X (++ Val) (if (cnt? Val) (let Siz (int Val) (cond ((num? X)...
; # (++ Val)
  %22 = inttoptr i64 %20 to i64*
  %23 = load i64, i64* %22
  %24 = getelementptr i64, i64* %22, i32 1
  %25 = load i64, i64* %24
; # (if (cnt? Val) (let Siz (int Val) (cond ((num? X) (let N (if (cnt...
; # (cnt? Val)
  %26 = and i64 %25, 2
  %27 = icmp ne i64 %26, 0
  br i1 %27, label %$8, label %$9
$8:
  %28 = phi i64 [%25, %$3] ; # Val
  %29 = phi i8* [%21, %$3] ; # Ptr
  %30 = phi i64 [%23, %$3] ; # X
; # (let Siz (int Val) (cond ((num? X) (let N (if (cnt? X) (int @) (v...
; # (int Val)
  %31 = lshr i64 %28, 4
; # (cond ((num? X) (let N (if (cnt? X) (int @) (val (dig @))) (when ...
; # (num? X)
  %32 = and i64 %30, 6
  %33 = icmp ne i64 %32, 0
  br i1 %33, label %$13, label %$12
$13:
  %34 = phi i64 [%28, %$8] ; # Val
  %35 = phi i8* [%29, %$8] ; # Ptr
  %36 = phi i64 [%30, %$8] ; # X
; # (let N (if (cnt? X) (int @) (val (dig @))) (when (sign? X) (setq ...
; # (if (cnt? X) (int @) (val (dig @)))
; # (cnt? X)
  %37 = and i64 %36, 2
  %38 = icmp ne i64 %37, 0
  br i1 %38, label %$14, label %$15
$14:
  %39 = phi i64 [%34, %$13] ; # Val
  %40 = phi i8* [%35, %$13] ; # Ptr
  %41 = phi i64 [%36, %$13] ; # X
; # (int @)
  %42 = lshr i64 %36, 4
  br label %$16
$15:
  %43 = phi i64 [%34, %$13] ; # Val
  %44 = phi i8* [%35, %$13] ; # Ptr
  %45 = phi i64 [%36, %$13] ; # X
; # (dig @)
  %46 = add i64 %36, -4
; # (val (dig @))
  %47 = inttoptr i64 %46 to i64*
  %48 = load i64, i64* %47
  br label %$16
$16:
  %49 = phi i64 [%39, %$14], [%43, %$15] ; # Val
  %50 = phi i8* [%40, %$14], [%44, %$15] ; # Ptr
  %51 = phi i64 [%41, %$14], [%45, %$15] ; # X
  %52 = phi i64 [%42, %$14], [%48, %$15] ; # ->
; # (when (sign? X) (setq N (- N)))
; # (sign? X)
  %53 = and i64 %51, 8
  %54 = icmp ne i64 %53, 0
  br i1 %54, label %$17, label %$18
$17:
  %55 = phi i64 [%49, %$16] ; # Val
  %56 = phi i8* [%50, %$16] ; # Ptr
  %57 = phi i64 [%51, %$16] ; # X
  %58 = phi i64 [%52, %$16] ; # N
; # (- N)
  %59 = sub i64 0, %58
  br label %$18
$18:
  %60 = phi i64 [%49, %$16], [%55, %$17] ; # Val
  %61 = phi i8* [%50, %$16], [%56, %$17] ; # Ptr
  %62 = phi i64 [%51, %$16], [%57, %$17] ; # X
  %63 = phi i64 [%52, %$16], [%59, %$17] ; # N
; # (case Siz (1 (set Ptr (i8 N))) (2 (set (i16* Ptr) (i16 N))) (4 (s...
  switch i64 %31, label %$19 [
    i64 1, label %$21
    i64 2, label %$22
    i64 4, label %$23
  ]
$21:
  %64 = phi i64 [%60, %$18] ; # Val
  %65 = phi i8* [%61, %$18] ; # Ptr
  %66 = phi i64 [%62, %$18] ; # X
  %67 = phi i64 [%63, %$18] ; # N
; # (set Ptr (i8 N))
; # (i8 N)
  %68 = trunc i64 %67 to i8
  store i8 %68, i8* %65
  br label %$20
$22:
  %69 = phi i64 [%60, %$18] ; # Val
  %70 = phi i8* [%61, %$18] ; # Ptr
  %71 = phi i64 [%62, %$18] ; # X
  %72 = phi i64 [%63, %$18] ; # N
; # (set (i16* Ptr) (i16 N))
; # (i16* Ptr)
  %73 = bitcast i8* %70 to i16*
; # (i16 N)
  %74 = trunc i64 %72 to i16
  store i16 %74, i16* %73
  br label %$20
$23:
  %75 = phi i64 [%60, %$18] ; # Val
  %76 = phi i8* [%61, %$18] ; # Ptr
  %77 = phi i64 [%62, %$18] ; # X
  %78 = phi i64 [%63, %$18] ; # N
; # (set (i32* Ptr) (i32 N))
; # (i32* Ptr)
  %79 = bitcast i8* %76 to i32*
; # (i32 N)
  %80 = trunc i64 %78 to i32
  store i32 %80, i32* %79
  br label %$20
$19:
  %81 = phi i64 [%60, %$18] ; # Val
  %82 = phi i8* [%61, %$18] ; # Ptr
  %83 = phi i64 [%62, %$18] ; # X
  %84 = phi i64 [%63, %$18] ; # N
; # (set (i64* Ptr) N)
; # (i64* Ptr)
  %85 = bitcast i8* %82 to i64*
  store i64 %84, i64* %85
  br label %$20
$20:
  %86 = phi i64 [%64, %$21], [%69, %$22], [%75, %$23], [%81, %$19] ; # Val
  %87 = phi i8* [%65, %$21], [%70, %$22], [%76, %$23], [%82, %$19] ; # Ptr
  %88 = phi i64 [%66, %$21], [%71, %$22], [%77, %$23], [%83, %$19] ; # X
  %89 = phi i64 [%67, %$21], [%72, %$22], [%78, %$23], [%84, %$19] ; # N
  br label %$11
$12:
  %90 = phi i64 [%28, %$8] ; # Val
  %91 = phi i8* [%29, %$8] ; # Ptr
  %92 = phi i64 [%30, %$8] ; # X
; # (nil? X)
  %93 = icmp eq i64 %92, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %93, label %$25, label %$24
$25:
  %94 = phi i64 [%90, %$12] ; # Val
  %95 = phi i8* [%91, %$12] ; # Ptr
  %96 = phi i64 [%92, %$12] ; # X
; # (set Ptr (i8 0))
; # (i8 0)
  store i8 0, i8* %95
  br label %$11
$24:
  %97 = phi i64 [%90, %$12] ; # Val
  %98 = phi i8* [%91, %$12] ; # Ptr
  %99 = phi i64 [%92, %$12] ; # X
; # (sym? X)
  %100 = and i64 %99, 8
  %101 = icmp ne i64 %100, 0
  br i1 %101, label %$27, label %$26
$27:
  %102 = phi i64 [%97, %$24] ; # Val
  %103 = phi i8* [%98, %$24] ; # Ptr
  %104 = phi i64 [%99, %$24] ; # X
; # (tail X)
  %105 = add i64 %104, -8
; # (val (tail X))
  %106 = inttoptr i64 %105 to i64*
  %107 = load i64, i64* %106
; # (name (val (tail X)))
  br label %$28
$28:
  %108 = phi i64 [%107, %$27], [%114, %$29] ; # Tail
  %109 = and i64 %108, 6
  %110 = icmp ne i64 %109, 0
  br i1 %110, label %$30, label %$29
$29:
  %111 = phi i64 [%108, %$28] ; # Tail
  %112 = inttoptr i64 %111 to i64*
  %113 = getelementptr i64, i64* %112, i32 1
  %114 = load i64, i64* %113
  br label %$28
$30:
  %115 = phi i64 [%108, %$28] ; # Tail
; # (bufString X Ptr)
  %116 = call i8* @bufString(i64 %115, i8* %103)
  br label %$11
$26:
  %117 = phi i64 [%97, %$24] ; # Val
  %118 = phi i8* [%98, %$24] ; # Ptr
  %119 = phi i64 [%99, %$24] ; # X
  br label %$11
$11:
  %120 = phi i64 [%86, %$20], [%94, %$25], [%102, %$30], [%117, %$26] ; # Val
  %121 = phi i8* [%87, %$20], [%95, %$25], [%103, %$30], [%118, %$26] ; # Ptr
  %122 = phi i64 [%88, %$20], [%96, %$25], [%115, %$30], [%119, %$26] ; # X
  br label %$10
$9:
  %123 = phi i64 [%25, %$3] ; # Val
  %124 = phi i8* [%21, %$3] ; # Ptr
  %125 = phi i64 [%23, %$3] ; # X
; # (let (N 0 Scl (int X)) (if (sign? X) (while (pair Val) (bufFloat ...
; # (int X)
  %126 = lshr i64 %125, 4
; # (if (sign? X) (while (pair Val) (bufFloat (++ Val) Scl Ptr) (inc ...
; # (sign? X)
  %127 = and i64 %125, 8
  %128 = icmp ne i64 %127, 0
  br i1 %128, label %$31, label %$32
$31:
  %129 = phi i64 [%123, %$9] ; # Val
  %130 = phi i8* [%124, %$9] ; # Ptr
  %131 = phi i64 [%125, %$9] ; # X
  %132 = phi i64 [0, %$9] ; # N
; # (while (pair Val) (bufFloat (++ Val) Scl Ptr) (inc 'N 4) (setq Pt...
  br label %$34
$34:
  %133 = phi i64 [%129, %$31], [%146, %$35] ; # Val
  %134 = phi i8* [%130, %$31], [%148, %$35] ; # Ptr
  %135 = phi i64 [%131, %$31], [%141, %$35] ; # X
  %136 = phi i64 [%132, %$31], [%147, %$35] ; # N
; # (pair Val)
  %137 = and i64 %133, 15
  %138 = icmp eq i64 %137, 0
  br i1 %138, label %$35, label %$36
$35:
  %139 = phi i64 [%133, %$34] ; # Val
  %140 = phi i8* [%134, %$34] ; # Ptr
  %141 = phi i64 [%135, %$34] ; # X
  %142 = phi i64 [%136, %$34] ; # N
; # (++ Val)
  %143 = inttoptr i64 %139 to i64*
  %144 = load i64, i64* %143
  %145 = getelementptr i64, i64* %143, i32 1
  %146 = load i64, i64* %145
; # (bufFloat (++ Val) Scl Ptr)
  call void @bufFloat(i64 %144, i64 %126, i8* %140)
; # (inc 'N 4)
  %147 = add i64 %142, 4
; # (ofs Ptr 4)
  %148 = getelementptr i8, i8* %140, i32 4
  br label %$34
$36:
  %149 = phi i64 [%133, %$34] ; # Val
  %150 = phi i8* [%134, %$34] ; # Ptr
  %151 = phi i64 [%135, %$34] ; # X
  %152 = phi i64 [%136, %$34] ; # N
  br label %$33
$32:
  %153 = phi i64 [%123, %$9] ; # Val
  %154 = phi i8* [%124, %$9] ; # Ptr
  %155 = phi i64 [%125, %$9] ; # X
  %156 = phi i64 [0, %$9] ; # N
; # (while (pair Val) (bufDouble (++ Val) Scl Ptr) (inc 'N 8) (setq P...
  br label %$37
$37:
  %157 = phi i64 [%153, %$32], [%170, %$38] ; # Val
  %158 = phi i8* [%154, %$32], [%172, %$38] ; # Ptr
  %159 = phi i64 [%155, %$32], [%165, %$38] ; # X
  %160 = phi i64 [%156, %$32], [%171, %$38] ; # N
; # (pair Val)
  %161 = and i64 %157, 15
  %162 = icmp eq i64 %161, 0
  br i1 %162, label %$38, label %$39
$38:
  %163 = phi i64 [%157, %$37] ; # Val
  %164 = phi i8* [%158, %$37] ; # Ptr
  %165 = phi i64 [%159, %$37] ; # X
  %166 = phi i64 [%160, %$37] ; # N
; # (++ Val)
  %167 = inttoptr i64 %163 to i64*
  %168 = load i64, i64* %167
  %169 = getelementptr i64, i64* %167, i32 1
  %170 = load i64, i64* %169
; # (bufDouble (++ Val) Scl Ptr)
  call void @bufDouble(i64 %168, i64 %126, i8* %164)
; # (inc 'N 8)
  %171 = add i64 %166, 8
; # (ofs Ptr 8)
  %172 = getelementptr i8, i8* %164, i32 8
  br label %$37
$39:
  %173 = phi i64 [%157, %$37] ; # Val
  %174 = phi i8* [%158, %$37] ; # Ptr
  %175 = phi i64 [%159, %$37] ; # X
  %176 = phi i64 [%160, %$37] ; # N
  br label %$33
$33:
  %177 = phi i64 [%149, %$36], [%173, %$39] ; # Val
  %178 = phi i8* [%150, %$36], [%174, %$39] ; # Ptr
  %179 = phi i64 [%151, %$36], [%175, %$39] ; # X
  %180 = phi i64 [%152, %$36], [%176, %$39] ; # N
  br label %$10
$10:
  %181 = phi i64 [%120, %$11], [%177, %$33] ; # Val
  %182 = phi i8* [%121, %$11], [%178, %$33] ; # Ptr
  %183 = phi i64 [%122, %$11], [%179, %$33] ; # X
  %184 = phi i64 [%31, %$11], [%180, %$33] ; # ->
  br label %$4
$4:
  %185 = phi i64 [%17, %$7], [%181, %$10] ; # Val
  %186 = phi i8* [%18, %$7], [%182, %$10] ; # Ptr
  %187 = phi i64 [%19, %$7], [%184, %$10] ; # ->
  ret i64 %187
}

define void @natErr(i64) align 8 {
$1:
; # (err 0 Spec ($ "Bad result spec") null)
  call void @err(i64 0, i64 %0, i8* bitcast ([16 x i8]* @$91 to i8*), i8* null)
  unreachable
}

define i64 @natRetFloat(i32, i64) align 8 {
$1:
; # (let R (boxFloat Val Scl) (unless R (let X (setq R (save (boxNum ...
; # (boxFloat Val Scl)
  %2 = call i64 @boxFloat(i32 %0, i64 %1)
; # (unless R (let X (setq R (save (boxNum (val Fdigit)))) (until (bo...
  %3 = icmp ne i64 %2, 0
  br i1 %3, label %$3, label %$2
$2:
  %4 = phi i64 [%2, %$1] ; # R
; # (let X (setq R (save (boxNum (val Fdigit)))) (until (boxFlt) (set...
; # (val Fdigit)
  %5 = load i64, i64* @Fdigit
; # (boxNum (val Fdigit))
  %6 = call i64 @boxNum(i64 %5)
; # (save (boxNum (val Fdigit)))
  %7 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %8 = load i64, i64* %7
  %9 = alloca i64, i64 2, align 16
  %10 = ptrtoint i64* %9 to i64
  %11 = inttoptr i64 %10 to i64*
  store i64 %6, i64* %11
  %12 = add i64 %10, 8
  %13 = inttoptr i64 %12 to i64*
  store i64 %8, i64* %13
  %14 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %10, i64* %14
; # (until (boxFlt) (setq X (set (big X) (boxNum (val Fdigit)))))
  br label %$4
$4:
  %15 = phi i64 [%6, %$2], [%19, %$5] ; # R
  %16 = phi i64 [%6, %$2], [%23, %$5] ; # X
; # (boxFlt)
  %17 = call i64 @boxFlt()
  %18 = icmp ne i64 %17, 0
  br i1 %18, label %$6, label %$5
$5:
  %19 = phi i64 [%15, %$4] ; # R
  %20 = phi i64 [%16, %$4] ; # X
; # (set (big X) (boxNum (val Fdigit)))
; # (big X)
  %21 = add i64 %20, 4
; # (val Fdigit)
  %22 = load i64, i64* @Fdigit
; # (boxNum (val Fdigit))
  %23 = call i64 @boxNum(i64 %22)
  %24 = inttoptr i64 %21 to i64*
  store i64 %23, i64* %24
  br label %$4
$6:
  %25 = phi i64 [%15, %$4] ; # R
  %26 = phi i64 [%16, %$4] ; # X
; # (set (big X) @)
; # (big X)
  %27 = add i64 %26, 4
  %28 = inttoptr i64 %27 to i64*
  store i64 %17, i64* %28
; # (drop *Safe)
  %29 = inttoptr i64 %10 to i64*
  %30 = getelementptr i64, i64* %29, i32 1
  %31 = load i64, i64* %30
  %32 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %31, i64* %32
  br label %$3
$3:
  %33 = phi i64 [%2, %$1], [%25, %$6] ; # R
; # (if (val Fsign) (neg R) R)
; # (val Fsign)
  %34 = load i1, i1* @Fsign
  br i1 %34, label %$7, label %$8
$7:
  %35 = phi i64 [%33, %$3] ; # R
; # (neg R)
  %36 = icmp eq i64 %35, 2
  br i1 %36, label %$10, label %$11
$10:
  br label %$12
$11:
  %37 = xor i64 %35, 8
  br label %$12
$12:
  %38 = phi i64 [%35, %$10], [%37, %$11] ; # ->
  br label %$9
$8:
  %39 = phi i64 [%33, %$3] ; # R
  br label %$9
$9:
  %40 = phi i64 [%35, %$12], [%39, %$8] ; # R
  %41 = phi i64 [%38, %$12], [%39, %$8] ; # ->
  ret i64 %41
}

define i64 @natRetDouble(i64, i64) align 8 {
$1:
; # (let R (boxDouble Val Scl) (unless R (let X (setq R (save (boxNum...
; # (boxDouble Val Scl)
  %2 = call i64 @boxDouble(i64 %0, i64 %1)
; # (unless R (let X (setq R (save (boxNum (val Fdigit)))) (until (bo...
  %3 = icmp ne i64 %2, 0
  br i1 %3, label %$3, label %$2
$2:
  %4 = phi i64 [%2, %$1] ; # R
; # (let X (setq R (save (boxNum (val Fdigit)))) (until (boxDbl) (set...
; # (val Fdigit)
  %5 = load i64, i64* @Fdigit
; # (boxNum (val Fdigit))
  %6 = call i64 @boxNum(i64 %5)
; # (save (boxNum (val Fdigit)))
  %7 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %8 = load i64, i64* %7
  %9 = alloca i64, i64 2, align 16
  %10 = ptrtoint i64* %9 to i64
  %11 = inttoptr i64 %10 to i64*
  store i64 %6, i64* %11
  %12 = add i64 %10, 8
  %13 = inttoptr i64 %12 to i64*
  store i64 %8, i64* %13
  %14 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %10, i64* %14
; # (until (boxDbl) (setq X (set (big X) (boxNum (val Fdigit)))))
  br label %$4
$4:
  %15 = phi i64 [%6, %$2], [%19, %$5] ; # R
  %16 = phi i64 [%6, %$2], [%23, %$5] ; # X
; # (boxDbl)
  %17 = call i64 @boxDbl()
  %18 = icmp ne i64 %17, 0
  br i1 %18, label %$6, label %$5
$5:
  %19 = phi i64 [%15, %$4] ; # R
  %20 = phi i64 [%16, %$4] ; # X
; # (set (big X) (boxNum (val Fdigit)))
; # (big X)
  %21 = add i64 %20, 4
; # (val Fdigit)
  %22 = load i64, i64* @Fdigit
; # (boxNum (val Fdigit))
  %23 = call i64 @boxNum(i64 %22)
  %24 = inttoptr i64 %21 to i64*
  store i64 %23, i64* %24
  br label %$4
$6:
  %25 = phi i64 [%15, %$4] ; # R
  %26 = phi i64 [%16, %$4] ; # X
; # (set (big X) @)
; # (big X)
  %27 = add i64 %26, 4
  %28 = inttoptr i64 %27 to i64*
  store i64 %17, i64* %28
; # (drop *Safe)
  %29 = inttoptr i64 %10 to i64*
  %30 = getelementptr i64, i64* %29, i32 1
  %31 = load i64, i64* %30
  %32 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %31, i64* %32
  br label %$3
$3:
  %33 = phi i64 [%2, %$1], [%25, %$6] ; # R
; # (if (val Fsign) (neg R) R)
; # (val Fsign)
  %34 = load i1, i1* @Fsign
  br i1 %34, label %$7, label %$8
$7:
  %35 = phi i64 [%33, %$3] ; # R
; # (neg R)
  %36 = icmp eq i64 %35, 2
  br i1 %36, label %$10, label %$11
$10:
  br label %$12
$11:
  %37 = xor i64 %35, 8
  br label %$12
$12:
  %38 = phi i64 [%35, %$10], [%37, %$11] ; # ->
  br label %$9
$8:
  %39 = phi i64 [%33, %$3] ; # R
  br label %$9
$9:
  %40 = phi i64 [%35, %$12], [%39, %$8] ; # R
  %41 = phi i64 [%38, %$12], [%39, %$8] ; # ->
  ret i64 %41
}

define i64 @natRetBuf(i64, i8**) align 8 {
$1:
; # (cond ((t? Spec) (let P (i64* (val Ptr)) (set Ptr (i8* (inc P))) ...
; # (t? Spec)
  %2 = icmp eq i64 %0, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %2, label %$4, label %$3
$4:
  %3 = phi i64 [%0, %$1] ; # Spec
; # (let P (i64* (val Ptr)) (set Ptr (i8* (inc P))) (val P))
; # (val Ptr)
  %4 = load i8*, i8** %1
; # (i64* (val Ptr))
  %5 = bitcast i8* %4 to i64*
; # (set Ptr (i8* (inc P)))
; # (inc P)
  %6 = getelementptr i64, i64* %5, i32 1
; # (i8* (inc P))
  %7 = bitcast i64* %6 to i8*
  store i8* %7, i8** %1
; # (val P)
  %8 = load i64, i64* %5
  br label %$2
$3:
  %9 = phi i64 [%0, %$1] ; # Spec
; # (== Spec $N)
  %10 = icmp eq i64 %9, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 296) to i64)
  br i1 %10, label %$6, label %$5
$6:
  %11 = phi i64 [%9, %$3] ; # Spec
; # (let P (i64* (val Ptr)) (set Ptr (i8* (inc P))) (box (val P)))
; # (val Ptr)
  %12 = load i8*, i8** %1
; # (i64* (val Ptr))
  %13 = bitcast i8* %12 to i64*
; # (set Ptr (i8* (inc P)))
; # (inc P)
  %14 = getelementptr i64, i64* %13, i32 1
; # (i8* (inc P))
  %15 = bitcast i64* %14 to i8*
  store i8* %15, i8** %1
; # (val P)
  %16 = load i64, i64* %13
; # (box (val P))
  %17 = call i64 @box(i64 %16)
  br label %$2
$5:
  %18 = phi i64 [%9, %$3] ; # Spec
; # (== Spec $P)
  %19 = icmp eq i64 %18, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 376) to i64)
  br i1 %19, label %$8, label %$7
$8:
  %20 = phi i64 [%18, %$5] ; # Spec
; # (let P (i64* (val Ptr)) (set Ptr (i8* (inc P))) (box64 (val P)))
; # (val Ptr)
  %21 = load i8*, i8** %1
; # (i64* (val Ptr))
  %22 = bitcast i8* %21 to i64*
; # (set Ptr (i8* (inc P)))
; # (inc P)
  %23 = getelementptr i64, i64* %22, i32 1
; # (i8* (inc P))
  %24 = bitcast i64* %23 to i8*
  store i8* %24, i8** %1
; # (val P)
  %25 = load i64, i64* %22
; # (box64 (val P))
  %26 = and i64 %25, 17293822569102704640
  %27 = icmp ne i64 %26, 0
  br i1 %27, label %$9, label %$10
$9:
  %28 = call i64 @boxNum(i64 %25)
  br label %$11
$10:
  %29 = shl i64 %25, 4
  %30 = or i64 %29, 2
  br label %$11
$11:
  %31 = phi i64 [%28, %$9], [%30, %$10] ; # ->
  br label %$2
$7:
  %32 = phi i64 [%18, %$5] ; # Spec
; # (== Spec $I)
  %33 = icmp eq i64 %32, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 360) to i64)
  br i1 %33, label %$13, label %$12
$13:
  %34 = phi i64 [%32, %$7] ; # Spec
; # (if (ge0 (let P (i32* (val Ptr)) (set Ptr (i8* (inc P))) (val P))...
; # (let P (i32* (val Ptr)) (set Ptr (i8* (inc P))) (val P))
; # (val Ptr)
  %35 = load i8*, i8** %1
; # (i32* (val Ptr))
  %36 = bitcast i8* %35 to i32*
; # (set Ptr (i8* (inc P)))
; # (inc P)
  %37 = getelementptr i32, i32* %36, i32 1
; # (i8* (inc P))
  %38 = bitcast i32* %37 to i8*
  store i8* %38, i8** %1
; # (val P)
  %39 = load i32, i32* %36
; # (ge0 (let P (i32* (val Ptr)) (set Ptr (i8* (inc P))) (val P)))
  %40 = icmp sge i32 %39, 0
  br i1 %40, label %$14, label %$15
$14:
  %41 = phi i64 [%34, %$13] ; # Spec
; # (i64 @)
  %42 = sext i32 %39 to i64
; # (cnt (i64 @))
  %43 = shl i64 %42, 4
  %44 = or i64 %43, 2
  br label %$16
$15:
  %45 = phi i64 [%34, %$13] ; # Spec
; # (- @)
  %46 = sub i32 0, %39
; # (i64 (- @))
  %47 = sext i32 %46 to i64
; # (cnt (i64 (- @)))
  %48 = shl i64 %47, 4
  %49 = or i64 %48, 2
; # (sign (cnt (i64 (- @))))
  %50 = or i64 %49, 8
  br label %$16
$16:
  %51 = phi i64 [%41, %$14], [%45, %$15] ; # Spec
  %52 = phi i64 [%44, %$14], [%50, %$15] ; # ->
  br label %$2
$12:
  %53 = phi i64 [%32, %$7] ; # Spec
; # (== Spec $C)
  %54 = icmp eq i64 %53, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 312) to i64)
  br i1 %54, label %$18, label %$17
$18:
  %55 = phi i64 [%53, %$12] ; # Spec
; # (if (fetchChar Ptr) (mkChar @) $Nil)
; # (fetchChar Ptr)
  %56 = call i32 @fetchChar(i8** %1)
  %57 = icmp ne i32 %56, 0
  br i1 %57, label %$19, label %$20
$19:
  %58 = phi i64 [%55, %$18] ; # Spec
; # (mkChar @)
  %59 = call i64 @mkChar(i32 %56)
  br label %$21
$20:
  %60 = phi i64 [%55, %$18] ; # Spec
  br label %$21
$21:
  %61 = phi i64 [%58, %$19], [%60, %$20] ; # Spec
  %62 = phi i64 [%59, %$19], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$20] ; # ->
  br label %$2
$17:
  %63 = phi i64 [%53, %$12] ; # Spec
; # (== Spec $W)
  %64 = icmp eq i64 %63, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 392) to i64)
  br i1 %64, label %$23, label %$22
$23:
  %65 = phi i64 [%63, %$17] ; # Spec
; # (if (ge0 (let P (i16* (val Ptr)) (set Ptr (i8* (inc P))) (val P))...
; # (let P (i16* (val Ptr)) (set Ptr (i8* (inc P))) (val P))
; # (val Ptr)
  %66 = load i8*, i8** %1
; # (i16* (val Ptr))
  %67 = bitcast i8* %66 to i16*
; # (set Ptr (i8* (inc P)))
; # (inc P)
  %68 = getelementptr i16, i16* %67, i32 1
; # (i8* (inc P))
  %69 = bitcast i16* %68 to i8*
  store i8* %69, i8** %1
; # (val P)
  %70 = load i16, i16* %67
; # (ge0 (let P (i16* (val Ptr)) (set Ptr (i8* (inc P))) (val P)))
  %71 = icmp sge i16 %70, 0
  br i1 %71, label %$24, label %$25
$24:
  %72 = phi i64 [%65, %$23] ; # Spec
; # (i64 @)
  %73 = sext i16 %70 to i64
; # (cnt (i64 @))
  %74 = shl i64 %73, 4
  %75 = or i64 %74, 2
  br label %$26
$25:
  %76 = phi i64 [%65, %$23] ; # Spec
; # (- @)
  %77 = sub i16 0, %70
; # (i64 (- @))
  %78 = sext i16 %77 to i64
; # (cnt (i64 (- @)))
  %79 = shl i64 %78, 4
  %80 = or i64 %79, 2
; # (sign (cnt (i64 (- @))))
  %81 = or i64 %80, 8
  br label %$26
$26:
  %82 = phi i64 [%72, %$24], [%76, %$25] ; # Spec
  %83 = phi i64 [%75, %$24], [%81, %$25] ; # ->
  br label %$2
$22:
  %84 = phi i64 [%63, %$17] ; # Spec
; # (== Spec $B)
  %85 = icmp eq i64 %84, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 344) to i64)
  br i1 %85, label %$28, label %$27
$28:
  %86 = phi i64 [%84, %$22] ; # Spec
; # (let P (val Ptr) (set Ptr (inc P)) (cnt (i64 (val P))))
; # (val Ptr)
  %87 = load i8*, i8** %1
; # (set Ptr (inc P))
; # (inc P)
  %88 = getelementptr i8, i8* %87, i32 1
  store i8* %88, i8** %1
; # (val P)
  %89 = load i8, i8* %87
; # (i64 (val P))
  %90 = zext i8 %89 to i64
; # (cnt (i64 (val P)))
  %91 = shl i64 %90, 4
  %92 = or i64 %91, 2
  br label %$2
$27:
  %93 = phi i64 [%84, %$22] ; # Spec
; # (== Spec $S)
  %94 = icmp eq i64 %93, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 328) to i64)
  br i1 %94, label %$30, label %$29
$30:
  %95 = phi i64 [%93, %$27] ; # Spec
; # (let P (i8** (val Ptr)) (set Ptr (i8* (inc P))) (mkStr (val P)))
; # (val Ptr)
  %96 = load i8*, i8** %1
; # (i8** (val Ptr))
  %97 = bitcast i8* %96 to i8**
; # (set Ptr (i8* (inc P)))
; # (inc P)
  %98 = getelementptr i8*, i8** %97, i32 1
; # (i8* (inc P))
  %99 = bitcast i8** %98 to i8*
  store i8* %99, i8** %1
; # (val P)
  %100 = load i8*, i8** %97
; # (mkStr (val P))
  %101 = call i64 @mkStr(i8* %100)
  br label %$2
$29:
  %102 = phi i64 [%93, %$27] ; # Spec
; # (cnt? Spec)
  %103 = and i64 %102, 2
  %104 = icmp ne i64 %103, 0
  br i1 %104, label %$32, label %$31
$32:
  %105 = phi i64 [%102, %$29] ; # Spec
; # (if (sign? Spec) (natRetFloat (let P (i32* (val Ptr)) (set Ptr (i...
; # (sign? Spec)
  %106 = and i64 %105, 8
  %107 = icmp ne i64 %106, 0
  br i1 %107, label %$33, label %$34
$33:
  %108 = phi i64 [%105, %$32] ; # Spec
; # (let P (i32* (val Ptr)) (set Ptr (i8* (inc P))) (val P))
; # (val Ptr)
  %109 = load i8*, i8** %1
; # (i32* (val Ptr))
  %110 = bitcast i8* %109 to i32*
; # (set Ptr (i8* (inc P)))
; # (inc P)
  %111 = getelementptr i32, i32* %110, i32 1
; # (i8* (inc P))
  %112 = bitcast i32* %111 to i8*
  store i8* %112, i8** %1
; # (val P)
  %113 = load i32, i32* %110
; # (int Spec)
  %114 = lshr i64 %108, 4
; # (natRetFloat (let P (i32* (val Ptr)) (set Ptr (i8* (inc P))) (val...
  %115 = call i64 @natRetFloat(i32 %113, i64 %114)
  br label %$35
$34:
  %116 = phi i64 [%105, %$32] ; # Spec
; # (let P (i64* (val Ptr)) (set Ptr (i8* (inc P))) (val P))
; # (val Ptr)
  %117 = load i8*, i8** %1
; # (i64* (val Ptr))
  %118 = bitcast i8* %117 to i64*
; # (set Ptr (i8* (inc P)))
; # (inc P)
  %119 = getelementptr i64, i64* %118, i32 1
; # (i8* (inc P))
  %120 = bitcast i64* %119 to i8*
  store i8* %120, i8** %1
; # (val P)
  %121 = load i64, i64* %118
; # (int Spec)
  %122 = lshr i64 %116, 4
; # (natRetDouble (let P (i64* (val Ptr)) (set Ptr (i8* (inc P))) (va...
  %123 = call i64 @natRetDouble(i64 %121, i64 %122)
  br label %$35
$35:
  %124 = phi i64 [%108, %$33], [%116, %$34] ; # Spec
  %125 = phi i64 [%115, %$33], [%123, %$34] ; # ->
  br label %$2
$31:
  %126 = phi i64 [%102, %$29] ; # Spec
; # (pair Spec)
  %127 = and i64 %126, 15
  %128 = icmp eq i64 %127, 0
  br i1 %128, label %$37, label %$36
$37:
  %129 = phi i64 [%126, %$31] ; # Spec
; # (let (S (++ Spec) R (natRetBuf S Ptr)) (unless (and (nil? R) (== ...
; # (++ Spec)
  %130 = inttoptr i64 %129 to i64*
  %131 = load i64, i64* %130
  %132 = getelementptr i64, i64* %130, i32 1
  %133 = load i64, i64* %132
; # (natRetBuf S Ptr)
  %134 = call i64 @natRetBuf(i64 %131, i8** %1)
; # (unless (and (nil? R) (== S $C)) (let X (setq R (save (cons R $Ni...
; # (and (nil? R) (== S $C))
; # (nil? R)
  %135 = icmp eq i64 %134, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %135, label %$39, label %$38
$39:
  %136 = phi i64 [%133, %$37] ; # Spec
  %137 = phi i64 [%131, %$37] ; # S
  %138 = phi i64 [%134, %$37] ; # R
; # (== S $C)
  %139 = icmp eq i64 %137, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 312) to i64)
  br label %$38
$38:
  %140 = phi i64 [%133, %$37], [%136, %$39] ; # Spec
  %141 = phi i64 [%131, %$37], [%137, %$39] ; # S
  %142 = phi i64 [%134, %$37], [%138, %$39] ; # R
  %143 = phi i1 [0, %$37], [%139, %$39] ; # ->
  br i1 %143, label %$41, label %$40
$40:
  %144 = phi i64 [%140, %$38] ; # Spec
  %145 = phi i64 [%141, %$38] ; # S
  %146 = phi i64 [%142, %$38] ; # R
; # (let X (setq R (save (cons R $Nil))) (loop (? (cnt? Spec) (let C ...
; # (cons R $Nil)
  %147 = call i64 @cons(i64 %146, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (save (cons R $Nil))
  %148 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %149 = load i64, i64* %148
  %150 = alloca i64, i64 2, align 16
  %151 = ptrtoint i64* %150 to i64
  %152 = inttoptr i64 %151 to i64*
  store i64 %147, i64* %152
  %153 = add i64 %151, 8
  %154 = inttoptr i64 %153 to i64*
  store i64 %149, i64* %154
  %155 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %151, i64* %155
; # (loop (? (cnt? Spec) (let C (int Spec) (while (dec 'C) (let Y (na...
  br label %$42
$42:
  %156 = phi i64 [%144, %$40], [%232, %$55] ; # Spec
  %157 = phi i64 [%145, %$40], [%233, %$55] ; # S
  %158 = phi i64 [%147, %$40], [%234, %$55] ; # R
  %159 = phi i64 [%147, %$40], [%236, %$55] ; # X
; # (? (cnt? Spec) (let C (int Spec) (while (dec 'C) (let Y (natRetBu...
; # (cnt? Spec)
  %160 = and i64 %156, 2
  %161 = icmp ne i64 %160, 0
  br i1 %161, label %$45, label %$43
$45:
  %162 = phi i64 [%156, %$42] ; # Spec
  %163 = phi i64 [%157, %$42] ; # S
  %164 = phi i64 [%158, %$42] ; # R
  %165 = phi i64 [%159, %$42] ; # X
; # (let C (int Spec) (while (dec 'C) (let Y (natRetBuf S Ptr) (? (an...
; # (int Spec)
  %166 = lshr i64 %162, 4
; # (while (dec 'C) (let Y (natRetBuf S Ptr) (? (and (nil? Y) (== S $...
  br label %$46
$46:
  %167 = phi i64 [%162, %$45], [%193, %$51] ; # Spec
  %168 = phi i64 [%163, %$45], [%194, %$51] ; # S
  %169 = phi i64 [%164, %$45], [%195, %$51] ; # R
  %170 = phi i64 [%165, %$45], [%198, %$51] ; # X
  %171 = phi i64 [%166, %$45], [%197, %$51] ; # C
; # (dec 'C)
  %172 = sub i64 %171, 1
  %173 = icmp ne i64 %172, 0
  br i1 %173, label %$47, label %$48
$47:
  %174 = phi i64 [%167, %$46] ; # Spec
  %175 = phi i64 [%168, %$46] ; # S
  %176 = phi i64 [%169, %$46] ; # R
  %177 = phi i64 [%170, %$46] ; # X
  %178 = phi i64 [%172, %$46] ; # C
; # (let Y (natRetBuf S Ptr) (? (and (nil? Y) (== S $C))) (setq X (se...
; # (natRetBuf S Ptr)
  %179 = call i64 @natRetBuf(i64 %175, i8** %1)
; # (? (and (nil? Y) (== S $C)))
; # (and (nil? Y) (== S $C))
; # (nil? Y)
  %180 = icmp eq i64 %179, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %180, label %$50, label %$49
$50:
  %181 = phi i64 [%174, %$47] ; # Spec
  %182 = phi i64 [%175, %$47] ; # S
  %183 = phi i64 [%176, %$47] ; # R
  %184 = phi i64 [%177, %$47] ; # X
  %185 = phi i64 [%178, %$47] ; # C
; # (== S $C)
  %186 = icmp eq i64 %182, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 312) to i64)
  br label %$49
$49:
  %187 = phi i64 [%174, %$47], [%181, %$50] ; # Spec
  %188 = phi i64 [%175, %$47], [%182, %$50] ; # S
  %189 = phi i64 [%176, %$47], [%183, %$50] ; # R
  %190 = phi i64 [%177, %$47], [%184, %$50] ; # X
  %191 = phi i64 [%178, %$47], [%185, %$50] ; # C
  %192 = phi i1 [0, %$47], [%186, %$50] ; # ->
  br i1 %192, label %$48, label %$51
$51:
  %193 = phi i64 [%187, %$49] ; # Spec
  %194 = phi i64 [%188, %$49] ; # S
  %195 = phi i64 [%189, %$49] ; # R
  %196 = phi i64 [%190, %$49] ; # X
  %197 = phi i64 [%191, %$49] ; # C
; # (set 2 X (cons Y $Nil))
; # (cons Y $Nil)
  %198 = call i64 @cons(i64 %179, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %199 = inttoptr i64 %196 to i64*
  %200 = getelementptr i64, i64* %199, i32 1
  store i64 %198, i64* %200
  br label %$46
$48:
  %201 = phi i64 [%167, %$46], [%187, %$49] ; # Spec
  %202 = phi i64 [%168, %$46], [%188, %$49] ; # S
  %203 = phi i64 [%169, %$46], [%189, %$49] ; # R
  %204 = phi i64 [%170, %$46], [%190, %$49] ; # X
  %205 = phi i64 [%172, %$46], [%191, %$49] ; # C
  br label %$44
$43:
  %206 = phi i64 [%156, %$42] ; # Spec
  %207 = phi i64 [%157, %$42] ; # S
  %208 = phi i64 [%158, %$42] ; # R
  %209 = phi i64 [%159, %$42] ; # X
; # (? (atom Spec))
; # (atom Spec)
  %210 = and i64 %206, 15
  %211 = icmp ne i64 %210, 0
  br i1 %211, label %$44, label %$52
$52:
  %212 = phi i64 [%206, %$43] ; # Spec
  %213 = phi i64 [%207, %$43] ; # S
  %214 = phi i64 [%208, %$43] ; # R
  %215 = phi i64 [%209, %$43] ; # X
; # (let Y (natRetBuf (setq S (++ Spec)) Ptr) (? (and (nil? Y) (== S ...
; # (++ Spec)
  %216 = inttoptr i64 %212 to i64*
  %217 = load i64, i64* %216
  %218 = getelementptr i64, i64* %216, i32 1
  %219 = load i64, i64* %218
; # (natRetBuf (setq S (++ Spec)) Ptr)
  %220 = call i64 @natRetBuf(i64 %217, i8** %1)
; # (? (and (nil? Y) (== S $C)))
; # (and (nil? Y) (== S $C))
; # (nil? Y)
  %221 = icmp eq i64 %220, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %221, label %$54, label %$53
$54:
  %222 = phi i64 [%219, %$52] ; # Spec
  %223 = phi i64 [%217, %$52] ; # S
  %224 = phi i64 [%214, %$52] ; # R
  %225 = phi i64 [%215, %$52] ; # X
; # (== S $C)
  %226 = icmp eq i64 %223, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 312) to i64)
  br label %$53
$53:
  %227 = phi i64 [%219, %$52], [%222, %$54] ; # Spec
  %228 = phi i64 [%217, %$52], [%223, %$54] ; # S
  %229 = phi i64 [%214, %$52], [%224, %$54] ; # R
  %230 = phi i64 [%215, %$52], [%225, %$54] ; # X
  %231 = phi i1 [0, %$52], [%226, %$54] ; # ->
  br i1 %231, label %$44, label %$55
$55:
  %232 = phi i64 [%227, %$53] ; # Spec
  %233 = phi i64 [%228, %$53] ; # S
  %234 = phi i64 [%229, %$53] ; # R
  %235 = phi i64 [%230, %$53] ; # X
; # (set 2 X (cons Y $Nil))
; # (cons Y $Nil)
  %236 = call i64 @cons(i64 %220, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %237 = inttoptr i64 %235 to i64*
  %238 = getelementptr i64, i64* %237, i32 1
  store i64 %236, i64* %238
  br label %$42
$44:
  %239 = phi i64 [%201, %$48], [%206, %$43], [%227, %$53] ; # Spec
  %240 = phi i64 [%202, %$48], [%207, %$43], [%228, %$53] ; # S
  %241 = phi i64 [%203, %$48], [%208, %$43], [%229, %$53] ; # R
  %242 = phi i64 [%204, %$48], [%209, %$43], [%230, %$53] ; # X
; # (drop *Safe)
  %243 = inttoptr i64 %151 to i64*
  %244 = getelementptr i64, i64* %243, i32 1
  %245 = load i64, i64* %244
  %246 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %245, i64* %246
  br label %$41
$41:
  %247 = phi i64 [%140, %$38], [%239, %$44] ; # Spec
  %248 = phi i64 [%141, %$38], [%240, %$44] ; # S
  %249 = phi i64 [%142, %$38], [%241, %$44] ; # R
  br label %$2
$36:
  %250 = phi i64 [%126, %$31] ; # Spec
; # (natErr Spec)
  call void @natErr(i64 %250)
  unreachable
$2:
  %251 = phi i64 [%3, %$4], [%11, %$6], [%20, %$11], [%51, %$16], [%61, %$21], [%82, %$26], [%86, %$28], [%95, %$30], [%124, %$35], [%247, %$41] ; # Spec
  %252 = phi i64 [%8, %$4], [%17, %$6], [%31, %$11], [%52, %$16], [%62, %$21], [%83, %$26], [%92, %$28], [%101, %$30], [%125, %$35], [%249, %$41] ; # ->
  ret i64 %252
}

define i64 @ffi(i64, i8*, i64, i64) align 8 {
$1:
; # (let (Spec (car Args) Val (ffiCall (cond ((cnt? Fun) (i8* (int Fu...
; # (car Args)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (cond ((cnt? Fun) (i8* (int Fun))) ((big? Fun) (i8* (val (dig Fun...
; # (cnt? Fun)
  %6 = and i64 %2, 2
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  %8 = phi i64 [%5, %$1] ; # Spec
; # (int Fun)
  %9 = lshr i64 %2, 4
; # (i8* (int Fun))
  %10 = inttoptr i64 %9 to i8*
  br label %$2
$3:
  %11 = phi i64 [%5, %$1] ; # Spec
; # (big? Fun)
  %12 = and i64 %2, 4
  %13 = icmp ne i64 %12, 0
  br i1 %13, label %$6, label %$5
$6:
  %14 = phi i64 [%11, %$3] ; # Spec
; # (dig Fun)
  %15 = add i64 %2, -4
; # (val (dig Fun))
  %16 = inttoptr i64 %15 to i64*
  %17 = load i64, i64* %16
; # (i8* (val (dig Fun)))
  %18 = inttoptr i64 %17 to i8*
  br label %$2
$5:
  %19 = phi i64 [%11, %$3] ; # Spec
; # (pair Fun)
  %20 = and i64 %2, 15
  %21 = icmp eq i64 %20, 0
  br i1 %21, label %$8, label %$7
$8:
  %22 = phi i64 [%19, %$5] ; # Spec
; # (argErr Exe Fun)
  call void @argErr(i64 %0, i64 %2)
  unreachable
$7:
  %23 = phi i64 [%19, %$5] ; # Spec
; # (let Nm (xName Fun) (unless (ffiPrep Lib (bufString Nm (b8 (bufSi...
; # (xName Fun)
  %24 = call i64 @xName(i64 %2)
; # (unless (ffiPrep Lib (bufString Nm (b8 (bufSize Nm))) Args) (err ...
; # (bufSize Nm)
  %25 = call i64 @bufSize(i64 %24)
; # (b8 (bufSize Nm))
  %26 = alloca i8, i64 %25
; # (bufString Nm (b8 (bufSize Nm)))
  %27 = call i8* @bufString(i64 %24, i8* %26)
; # (ffiPrep Lib (bufString Nm (b8 (bufSize Nm))) Args)
  %28 = call i8* @ffiPrep(i8* %1, i8* %27, i64 %3)
  %29 = icmp ne i8* %28, null
  br i1 %29, label %$10, label %$9
$9:
  %30 = phi i64 [%23, %$7] ; # Spec
; # (err Exe 0 ($ "Bad ffi") null)
  call void @err(i64 %0, i64 0, i8* bitcast ([8 x i8]* @$92 to i8*), i8* null)
  unreachable
$10:
  %31 = phi i64 [%23, %$7] ; # Spec
; # (set Fun (box64 (i64 @)))
; # (i64 @)
  %32 = ptrtoint i8* %28 to i64
; # (box64 (i64 @))
  %33 = and i64 %32, 17293822569102704640
  %34 = icmp ne i64 %33, 0
  br i1 %34, label %$11, label %$12
$11:
  %35 = call i64 @boxNum(i64 %32)
  br label %$13
$12:
  %36 = shl i64 %32, 4
  %37 = or i64 %36, 2
  br label %$13
$13:
  %38 = phi i64 [%35, %$11], [%37, %$12] ; # ->
  %39 = inttoptr i64 %2 to i64*
  store i64 %38, i64* %39
  br label %$2
$2:
  %40 = phi i64 [%8, %$4], [%14, %$6], [%31, %$13] ; # Spec
  %41 = phi i8* [%10, %$4], [%18, %$6], [%28, %$13] ; # ->
; # (cdr Args)
  %42 = inttoptr i64 %3 to i64*
  %43 = getelementptr i64, i64* %42, i32 1
  %44 = load i64, i64* %43
; # (ffiCall (cond ((cnt? Fun) (i8* (int Fun))) ((big? Fun) (i8* (val...
  %45 = call i64 @ffiCall(i8* %41, i64 %44)
; # (cond ((nil? Spec) $Nil) ((== Spec $T) Val) ((== Spec $N) (box Va...
; # (nil? Spec)
  %46 = icmp eq i64 %40, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %46, label %$16, label %$15
$16:
  %47 = phi i64 [%40, %$2] ; # Spec
  br label %$14
$15:
  %48 = phi i64 [%40, %$2] ; # Spec
; # (== Spec $T)
  %49 = icmp eq i64 %48, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %49, label %$18, label %$17
$18:
  %50 = phi i64 [%48, %$15] ; # Spec
  br label %$14
$17:
  %51 = phi i64 [%48, %$15] ; # Spec
; # (== Spec $N)
  %52 = icmp eq i64 %51, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 296) to i64)
  br i1 %52, label %$20, label %$19
$20:
  %53 = phi i64 [%51, %$17] ; # Spec
; # (box Val)
  %54 = call i64 @box(i64 %45)
  br label %$14
$19:
  %55 = phi i64 [%51, %$17] ; # Spec
; # (== Spec $P)
  %56 = icmp eq i64 %55, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 376) to i64)
  br i1 %56, label %$22, label %$21
$22:
  %57 = phi i64 [%55, %$19] ; # Spec
; # (box64 Val)
  %58 = and i64 %45, 17293822569102704640
  %59 = icmp ne i64 %58, 0
  br i1 %59, label %$23, label %$24
$23:
  %60 = call i64 @boxNum(i64 %45)
  br label %$25
$24:
  %61 = shl i64 %45, 4
  %62 = or i64 %61, 2
  br label %$25
$25:
  %63 = phi i64 [%60, %$23], [%62, %$24] ; # ->
  br label %$14
$21:
  %64 = phi i64 [%55, %$19] ; # Spec
; # (== Spec $I)
  %65 = icmp eq i64 %64, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 360) to i64)
  br i1 %65, label %$27, label %$26
$27:
  %66 = phi i64 [%64, %$21] ; # Spec
; # (if (ge0 (i32 Val)) (cnt (i64 @)) (sign (cnt (i64 (- @)))))
; # (i32 Val)
  %67 = trunc i64 %45 to i32
; # (ge0 (i32 Val))
  %68 = icmp sge i32 %67, 0
  br i1 %68, label %$28, label %$29
$28:
  %69 = phi i64 [%66, %$27] ; # Spec
; # (i64 @)
  %70 = sext i32 %67 to i64
; # (cnt (i64 @))
  %71 = shl i64 %70, 4
  %72 = or i64 %71, 2
  br label %$30
$29:
  %73 = phi i64 [%66, %$27] ; # Spec
; # (- @)
  %74 = sub i32 0, %67
; # (i64 (- @))
  %75 = sext i32 %74 to i64
; # (cnt (i64 (- @)))
  %76 = shl i64 %75, 4
  %77 = or i64 %76, 2
; # (sign (cnt (i64 (- @))))
  %78 = or i64 %77, 8
  br label %$30
$30:
  %79 = phi i64 [%69, %$28], [%73, %$29] ; # Spec
  %80 = phi i64 [%72, %$28], [%78, %$29] ; # ->
  br label %$14
$26:
  %81 = phi i64 [%64, %$21] ; # Spec
; # (== Spec $C)
  %82 = icmp eq i64 %81, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 312) to i64)
  br i1 %82, label %$32, label %$31
$32:
  %83 = phi i64 [%81, %$26] ; # Spec
; # (if (i32 Val) (mkChar @) $Nil)
; # (i32 Val)
  %84 = trunc i64 %45 to i32
  %85 = icmp ne i32 %84, 0
  br i1 %85, label %$33, label %$34
$33:
  %86 = phi i64 [%83, %$32] ; # Spec
; # (mkChar @)
  %87 = call i64 @mkChar(i32 %84)
  br label %$35
$34:
  %88 = phi i64 [%83, %$32] ; # Spec
  br label %$35
$35:
  %89 = phi i64 [%86, %$33], [%88, %$34] ; # Spec
  %90 = phi i64 [%87, %$33], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$34] ; # ->
  br label %$14
$31:
  %91 = phi i64 [%81, %$26] ; # Spec
; # (== Spec $W)
  %92 = icmp eq i64 %91, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 392) to i64)
  br i1 %92, label %$37, label %$36
$37:
  %93 = phi i64 [%91, %$31] ; # Spec
; # (if (ge0 (i16 Val)) (cnt (i64 @)) (sign (cnt (i64 (- @)))))
; # (i16 Val)
  %94 = trunc i64 %45 to i16
; # (ge0 (i16 Val))
  %95 = icmp sge i16 %94, 0
  br i1 %95, label %$38, label %$39
$38:
  %96 = phi i64 [%93, %$37] ; # Spec
; # (i64 @)
  %97 = sext i16 %94 to i64
; # (cnt (i64 @))
  %98 = shl i64 %97, 4
  %99 = or i64 %98, 2
  br label %$40
$39:
  %100 = phi i64 [%93, %$37] ; # Spec
; # (- @)
  %101 = sub i16 0, %94
; # (i64 (- @))
  %102 = sext i16 %101 to i64
; # (cnt (i64 (- @)))
  %103 = shl i64 %102, 4
  %104 = or i64 %103, 2
; # (sign (cnt (i64 (- @))))
  %105 = or i64 %104, 8
  br label %$40
$40:
  %106 = phi i64 [%96, %$38], [%100, %$39] ; # Spec
  %107 = phi i64 [%99, %$38], [%105, %$39] ; # ->
  br label %$14
$36:
  %108 = phi i64 [%91, %$31] ; # Spec
; # (== Spec $B)
  %109 = icmp eq i64 %108, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 344) to i64)
  br i1 %109, label %$42, label %$41
$42:
  %110 = phi i64 [%108, %$36] ; # Spec
; # (i8 Val)
  %111 = trunc i64 %45 to i8
; # (i64 (i8 Val))
  %112 = zext i8 %111 to i64
; # (cnt (i64 (i8 Val)))
  %113 = shl i64 %112, 4
  %114 = or i64 %113, 2
  br label %$14
$41:
  %115 = phi i64 [%108, %$36] ; # Spec
; # (== Spec $S)
  %116 = icmp eq i64 %115, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 328) to i64)
  br i1 %116, label %$44, label %$43
$44:
  %117 = phi i64 [%115, %$41] ; # Spec
; # (i8* Val)
  %118 = inttoptr i64 %45 to i8*
; # (mkStr (i8* Val))
  %119 = call i64 @mkStr(i8* %118)
  br label %$14
$43:
  %120 = phi i64 [%115, %$41] ; # Spec
; # (cnt? Spec)
  %121 = and i64 %120, 2
  %122 = icmp ne i64 %121, 0
  br i1 %122, label %$46, label %$45
$46:
  %123 = phi i64 [%120, %$43] ; # Spec
; # (if (sign? Spec) (natRetFloat (i32 Val) (int Spec)) (natRetDouble...
; # (sign? Spec)
  %124 = and i64 %123, 8
  %125 = icmp ne i64 %124, 0
  br i1 %125, label %$47, label %$48
$47:
  %126 = phi i64 [%123, %$46] ; # Spec
; # (i32 Val)
  %127 = trunc i64 %45 to i32
; # (int Spec)
  %128 = lshr i64 %126, 4
; # (natRetFloat (i32 Val) (int Spec))
  %129 = call i64 @natRetFloat(i32 %127, i64 %128)
  br label %$49
$48:
  %130 = phi i64 [%123, %$46] ; # Spec
; # (int Spec)
  %131 = lshr i64 %130, 4
; # (natRetDouble Val (int Spec))
  %132 = call i64 @natRetDouble(i64 %45, i64 %131)
  br label %$49
$49:
  %133 = phi i64 [%126, %$47], [%130, %$48] ; # Spec
  %134 = phi i64 [%129, %$47], [%132, %$48] ; # ->
  br label %$14
$45:
  %135 = phi i64 [%120, %$43] ; # Spec
; # (and (pair Spec) Val)
; # (pair Spec)
  %136 = and i64 %135, 15
  %137 = icmp eq i64 %136, 0
  br i1 %137, label %$51, label %$50
$51:
  %138 = phi i64 [%135, %$45] ; # Spec
  %139 = icmp ne i64 %45, 0
  br label %$50
$50:
  %140 = phi i64 [%135, %$45], [%138, %$51] ; # Spec
  %141 = phi i1 [0, %$45], [%139, %$51] ; # ->
  br i1 %141, label %$53, label %$52
$53:
  %142 = phi i64 [%140, %$50] ; # Spec
; # (let (Ptr (i8** (push Val)) S (++ Spec) R (natRetBuf S Ptr)) (unl...
; # (push Val)
  %143 = alloca i64, i64 1
  store i64 %45, i64* %143
; # (i8** (push Val))
  %144 = bitcast i64* %143 to i8**
; # (++ Spec)
  %145 = inttoptr i64 %142 to i64*
  %146 = load i64, i64* %145
  %147 = getelementptr i64, i64* %145, i32 1
  %148 = load i64, i64* %147
; # (natRetBuf S Ptr)
  %149 = call i64 @natRetBuf(i64 %146, i8** %144)
; # (unless (and (nil? R) (== S $C)) (let X (setq R (save (cons R $Ni...
; # (and (nil? R) (== S $C))
; # (nil? R)
  %150 = icmp eq i64 %149, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %150, label %$55, label %$54
$55:
  %151 = phi i64 [%148, %$53] ; # Spec
  %152 = phi i64 [%146, %$53] ; # S
  %153 = phi i64 [%149, %$53] ; # R
; # (== S $C)
  %154 = icmp eq i64 %152, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 312) to i64)
  br label %$54
$54:
  %155 = phi i64 [%148, %$53], [%151, %$55] ; # Spec
  %156 = phi i64 [%146, %$53], [%152, %$55] ; # S
  %157 = phi i64 [%149, %$53], [%153, %$55] ; # R
  %158 = phi i1 [0, %$53], [%154, %$55] ; # ->
  br i1 %158, label %$57, label %$56
$56:
  %159 = phi i64 [%155, %$54] ; # Spec
  %160 = phi i64 [%156, %$54] ; # S
  %161 = phi i64 [%157, %$54] ; # R
; # (let X (setq R (save (cons R $Nil))) (loop (? (cnt? Spec) (let C ...
; # (cons R $Nil)
  %162 = call i64 @cons(i64 %161, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (save (cons R $Nil))
  %163 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %164 = load i64, i64* %163
  %165 = alloca i64, i64 2, align 16
  %166 = ptrtoint i64* %165 to i64
  %167 = inttoptr i64 %166 to i64*
  store i64 %162, i64* %167
  %168 = add i64 %166, 8
  %169 = inttoptr i64 %168 to i64*
  store i64 %164, i64* %169
  %170 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %166, i64* %170
; # (loop (? (cnt? Spec) (let C (int Spec) (while (dec 'C) (let Y (na...
  br label %$58
$58:
  %171 = phi i64 [%159, %$56], [%247, %$71] ; # Spec
  %172 = phi i64 [%160, %$56], [%248, %$71] ; # S
  %173 = phi i64 [%162, %$56], [%249, %$71] ; # R
  %174 = phi i64 [%162, %$56], [%251, %$71] ; # X
; # (? (cnt? Spec) (let C (int Spec) (while (dec 'C) (let Y (natRetBu...
; # (cnt? Spec)
  %175 = and i64 %171, 2
  %176 = icmp ne i64 %175, 0
  br i1 %176, label %$61, label %$59
$61:
  %177 = phi i64 [%171, %$58] ; # Spec
  %178 = phi i64 [%172, %$58] ; # S
  %179 = phi i64 [%173, %$58] ; # R
  %180 = phi i64 [%174, %$58] ; # X
; # (let C (int Spec) (while (dec 'C) (let Y (natRetBuf S Ptr) (? (an...
; # (int Spec)
  %181 = lshr i64 %177, 4
; # (while (dec 'C) (let Y (natRetBuf S Ptr) (? (and (nil? Y) (== S $...
  br label %$62
$62:
  %182 = phi i64 [%177, %$61], [%208, %$67] ; # Spec
  %183 = phi i64 [%178, %$61], [%209, %$67] ; # S
  %184 = phi i64 [%179, %$61], [%210, %$67] ; # R
  %185 = phi i64 [%180, %$61], [%213, %$67] ; # X
  %186 = phi i64 [%181, %$61], [%212, %$67] ; # C
; # (dec 'C)
  %187 = sub i64 %186, 1
  %188 = icmp ne i64 %187, 0
  br i1 %188, label %$63, label %$64
$63:
  %189 = phi i64 [%182, %$62] ; # Spec
  %190 = phi i64 [%183, %$62] ; # S
  %191 = phi i64 [%184, %$62] ; # R
  %192 = phi i64 [%185, %$62] ; # X
  %193 = phi i64 [%187, %$62] ; # C
; # (let Y (natRetBuf S Ptr) (? (and (nil? Y) (== S $C))) (setq X (se...
; # (natRetBuf S Ptr)
  %194 = call i64 @natRetBuf(i64 %190, i8** %144)
; # (? (and (nil? Y) (== S $C)))
; # (and (nil? Y) (== S $C))
; # (nil? Y)
  %195 = icmp eq i64 %194, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %195, label %$66, label %$65
$66:
  %196 = phi i64 [%189, %$63] ; # Spec
  %197 = phi i64 [%190, %$63] ; # S
  %198 = phi i64 [%191, %$63] ; # R
  %199 = phi i64 [%192, %$63] ; # X
  %200 = phi i64 [%193, %$63] ; # C
; # (== S $C)
  %201 = icmp eq i64 %197, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 312) to i64)
  br label %$65
$65:
  %202 = phi i64 [%189, %$63], [%196, %$66] ; # Spec
  %203 = phi i64 [%190, %$63], [%197, %$66] ; # S
  %204 = phi i64 [%191, %$63], [%198, %$66] ; # R
  %205 = phi i64 [%192, %$63], [%199, %$66] ; # X
  %206 = phi i64 [%193, %$63], [%200, %$66] ; # C
  %207 = phi i1 [0, %$63], [%201, %$66] ; # ->
  br i1 %207, label %$64, label %$67
$67:
  %208 = phi i64 [%202, %$65] ; # Spec
  %209 = phi i64 [%203, %$65] ; # S
  %210 = phi i64 [%204, %$65] ; # R
  %211 = phi i64 [%205, %$65] ; # X
  %212 = phi i64 [%206, %$65] ; # C
; # (set 2 X (cons Y $Nil))
; # (cons Y $Nil)
  %213 = call i64 @cons(i64 %194, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %214 = inttoptr i64 %211 to i64*
  %215 = getelementptr i64, i64* %214, i32 1
  store i64 %213, i64* %215
  br label %$62
$64:
  %216 = phi i64 [%182, %$62], [%202, %$65] ; # Spec
  %217 = phi i64 [%183, %$62], [%203, %$65] ; # S
  %218 = phi i64 [%184, %$62], [%204, %$65] ; # R
  %219 = phi i64 [%185, %$62], [%205, %$65] ; # X
  %220 = phi i64 [%187, %$62], [%206, %$65] ; # C
  br label %$60
$59:
  %221 = phi i64 [%171, %$58] ; # Spec
  %222 = phi i64 [%172, %$58] ; # S
  %223 = phi i64 [%173, %$58] ; # R
  %224 = phi i64 [%174, %$58] ; # X
; # (? (atom Spec))
; # (atom Spec)
  %225 = and i64 %221, 15
  %226 = icmp ne i64 %225, 0
  br i1 %226, label %$60, label %$68
$68:
  %227 = phi i64 [%221, %$59] ; # Spec
  %228 = phi i64 [%222, %$59] ; # S
  %229 = phi i64 [%223, %$59] ; # R
  %230 = phi i64 [%224, %$59] ; # X
; # (let Y (natRetBuf (setq S (++ Spec)) Ptr) (? (and (nil? Y) (== S ...
; # (++ Spec)
  %231 = inttoptr i64 %227 to i64*
  %232 = load i64, i64* %231
  %233 = getelementptr i64, i64* %231, i32 1
  %234 = load i64, i64* %233
; # (natRetBuf (setq S (++ Spec)) Ptr)
  %235 = call i64 @natRetBuf(i64 %232, i8** %144)
; # (? (and (nil? Y) (== S $C)))
; # (and (nil? Y) (== S $C))
; # (nil? Y)
  %236 = icmp eq i64 %235, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %236, label %$70, label %$69
$70:
  %237 = phi i64 [%234, %$68] ; # Spec
  %238 = phi i64 [%232, %$68] ; # S
  %239 = phi i64 [%229, %$68] ; # R
  %240 = phi i64 [%230, %$68] ; # X
; # (== S $C)
  %241 = icmp eq i64 %238, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 312) to i64)
  br label %$69
$69:
  %242 = phi i64 [%234, %$68], [%237, %$70] ; # Spec
  %243 = phi i64 [%232, %$68], [%238, %$70] ; # S
  %244 = phi i64 [%229, %$68], [%239, %$70] ; # R
  %245 = phi i64 [%230, %$68], [%240, %$70] ; # X
  %246 = phi i1 [0, %$68], [%241, %$70] ; # ->
  br i1 %246, label %$60, label %$71
$71:
  %247 = phi i64 [%242, %$69] ; # Spec
  %248 = phi i64 [%243, %$69] ; # S
  %249 = phi i64 [%244, %$69] ; # R
  %250 = phi i64 [%245, %$69] ; # X
; # (set 2 X (cons Y $Nil))
; # (cons Y $Nil)
  %251 = call i64 @cons(i64 %235, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %252 = inttoptr i64 %250 to i64*
  %253 = getelementptr i64, i64* %252, i32 1
  store i64 %251, i64* %253
  br label %$58
$60:
  %254 = phi i64 [%216, %$64], [%221, %$59], [%242, %$69] ; # Spec
  %255 = phi i64 [%217, %$64], [%222, %$59], [%243, %$69] ; # S
  %256 = phi i64 [%218, %$64], [%223, %$59], [%244, %$69] ; # R
  %257 = phi i64 [%219, %$64], [%224, %$59], [%245, %$69] ; # X
; # (drop *Safe)
  %258 = inttoptr i64 %166 to i64*
  %259 = getelementptr i64, i64* %258, i32 1
  %260 = load i64, i64* %259
  %261 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %260, i64* %261
  br label %$57
$57:
  %262 = phi i64 [%155, %$54], [%254, %$60] ; # Spec
  %263 = phi i64 [%156, %$54], [%255, %$60] ; # S
  %264 = phi i64 [%157, %$54], [%256, %$60] ; # R
  br label %$14
$52:
  %265 = phi i64 [%140, %$50] ; # Spec
; # (natErr Spec)
  call void @natErr(i64 %265)
  unreachable
$14:
  %266 = phi i64 [%47, %$16], [%50, %$18], [%53, %$20], [%57, %$25], [%79, %$30], [%89, %$35], [%106, %$40], [%110, %$42], [%117, %$44], [%133, %$49], [%262, %$57] ; # Spec
  %267 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$16], [%45, %$18], [%54, %$20], [%63, %$25], [%80, %$30], [%90, %$35], [%107, %$40], [%114, %$42], [%119, %$44], [%134, %$49], [%264, %$57] ; # ->
  ret i64 %267
}

define i64 @_Nat(i64) align 8 {
$1:
; # (let (X (cdr Exe) Fun (save (eval (++ X))) Args (save (cons (eval...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (save (eval (++ X)))
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %17 = load i64, i64* %16
  %18 = alloca i64, i64 2, align 16
  %19 = ptrtoint i64* %18 to i64
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = add i64 %19, 8
  %22 = inttoptr i64 %21 to i64*
  store i64 %17, i64* %22
  %23 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %19, i64* %23
; # (++ X)
  %24 = inttoptr i64 %7 to i64*
  %25 = load i64, i64* %24
  %26 = getelementptr i64, i64* %24, i32 1
  %27 = load i64, i64* %26
; # (eval (++ X))
  %28 = and i64 %25, 6
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %$9, label %$8
$9:
  br label %$7
$8:
  %30 = and i64 %25, 8
  %31 = icmp ne i64 %30, 0
  br i1 %31, label %$11, label %$10
$11:
  %32 = inttoptr i64 %25 to i64*
  %33 = load i64, i64* %32
  br label %$7
$10:
  %34 = call i64 @evList(i64 %25)
  br label %$7
$7:
  %35 = phi i64 [%25, %$9], [%33, %$11], [%34, %$10] ; # ->
; # (cons (eval (++ X)) $Nil)
  %36 = call i64 @cons(i64 %35, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (save (cons (eval (++ X)) $Nil))
  %37 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %38 = load i64, i64* %37
  %39 = alloca i64, i64 2, align 16
  %40 = ptrtoint i64* %39 to i64
  %41 = inttoptr i64 %40 to i64*
  store i64 %36, i64* %41
  %42 = add i64 %40, 8
  %43 = inttoptr i64 %42 to i64*
  store i64 %38, i64* %43
  %44 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %40, i64* %44
; # (while (pair X) (let Z (push (save (eval (++ X))) $Nil) (set 2 L ...
  br label %$12
$12:
  %45 = phi i64 [%27, %$7], [%54, %$15] ; # X
  %46 = phi i64 [%36, %$7], [%72, %$15] ; # L
; # (pair X)
  %47 = and i64 %45, 15
  %48 = icmp eq i64 %47, 0
  br i1 %48, label %$13, label %$14
$13:
  %49 = phi i64 [%45, %$12] ; # X
  %50 = phi i64 [%46, %$12] ; # L
; # (let Z (push (save (eval (++ X))) $Nil) (set 2 L Z) (setq L Z))
; # (++ X)
  %51 = inttoptr i64 %49 to i64*
  %52 = load i64, i64* %51
  %53 = getelementptr i64, i64* %51, i32 1
  %54 = load i64, i64* %53
; # (eval (++ X))
  %55 = and i64 %52, 6
  %56 = icmp ne i64 %55, 0
  br i1 %56, label %$17, label %$16
$17:
  br label %$15
$16:
  %57 = and i64 %52, 8
  %58 = icmp ne i64 %57, 0
  br i1 %58, label %$19, label %$18
$19:
  %59 = inttoptr i64 %52 to i64*
  %60 = load i64, i64* %59
  br label %$15
$18:
  %61 = call i64 @evList(i64 %52)
  br label %$15
$15:
  %62 = phi i64 [%52, %$17], [%60, %$19], [%61, %$18] ; # ->
; # (save (eval (++ X)))
  %63 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %64 = load i64, i64* %63
  %65 = alloca i64, i64 2, align 16
  %66 = ptrtoint i64* %65 to i64
  %67 = inttoptr i64 %66 to i64*
  store i64 %62, i64* %67
  %68 = add i64 %66, 8
  %69 = inttoptr i64 %68 to i64*
  store i64 %64, i64* %69
  %70 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %66, i64* %70
; # (push (save (eval (++ X))) $Nil)
  %71 = alloca i64, i64 2, align 16
  %72 = ptrtoint i64* %71 to i64
  %73 = inttoptr i64 %72 to i64*
  store i64 %62, i64* %73
  %74 = add i64 %72, 8
  %75 = inttoptr i64 %74 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %75
; # (set 2 L Z)
  %76 = inttoptr i64 %50 to i64*
  %77 = getelementptr i64, i64* %76, i32 1
  store i64 %72, i64* %77
  br label %$12
$14:
  %78 = phi i64 [%45, %$12] ; # X
  %79 = phi i64 [%46, %$12] ; # L
; # (ffi Exe null Fun Args)
  %80 = tail call i64 @ffi(i64 %0, i8* null, i64 %15, i64 %36)
; # (drop *Safe)
  %81 = inttoptr i64 %19 to i64*
  %82 = getelementptr i64, i64* %81, i32 1
  %83 = load i64, i64* %82
  %84 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %83, i64* %84
  ret i64 %80
}

define i64 @_Native(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (eval (++ X)) Lib (cond ((cnt? Y) (i8* (int Y...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (cond ((cnt? Y) (i8* (int Y))) ((big? Y) (i8* (val (dig Y)))) ((p...
; # (cnt? Y)
  %16 = and i64 %15, 2
  %17 = icmp ne i64 %16, 0
  br i1 %17, label %$9, label %$8
$9:
  %18 = phi i64 [%7, %$2] ; # X
; # (int Y)
  %19 = lshr i64 %15, 4
; # (i8* (int Y))
  %20 = inttoptr i64 %19 to i8*
  br label %$7
$8:
  %21 = phi i64 [%7, %$2] ; # X
; # (big? Y)
  %22 = and i64 %15, 4
  %23 = icmp ne i64 %22, 0
  br i1 %23, label %$11, label %$10
$11:
  %24 = phi i64 [%21, %$8] ; # X
; # (dig Y)
  %25 = add i64 %15, -4
; # (val (dig Y))
  %26 = inttoptr i64 %25 to i64*
  %27 = load i64, i64* %26
; # (i8* (val (dig Y)))
  %28 = inttoptr i64 %27 to i8*
  br label %$7
$10:
  %29 = phi i64 [%21, %$8] ; # X
; # (pair Y)
  %30 = and i64 %15, 15
  %31 = icmp eq i64 %30, 0
  br i1 %31, label %$13, label %$12
$13:
  %32 = phi i64 [%29, %$10] ; # X
; # (argErr Exe Y)
  call void @argErr(i64 %0, i64 %15)
  unreachable
$12:
  %33 = phi i64 [%29, %$10] ; # X
; # (xName Y)
  %34 = call i64 @xName(i64 %15)
; # (| 2 (>> -4 (char "@")))
; # (== (xName Y) (| 2 (>> -4 (char "@"))))
  %35 = icmp eq i64 %34, 1026
  br i1 %35, label %$15, label %$14
$15:
  %36 = phi i64 [%33, %$12] ; # X
; # (set Y ZERO)
  %37 = inttoptr i64 %15 to i64*
  store i64 2, i64* %37
  br label %$7
$14:
  %38 = phi i64 [%33, %$12] ; # X
; # (unless (dlOpen (pathString @ (b8 (pathSize @)))) (err Exe Y ($ "...
; # (pathSize @)
  %39 = call i64 @pathSize(i64 %34)
; # (b8 (pathSize @))
  %40 = alloca i8, i64 %39
; # (pathString @ (b8 (pathSize @)))
  %41 = call i8* @pathString(i64 %34, i8* %40)
; # (dlOpen (pathString @ (b8 (pathSize @))))
  %42 = call i8* @dlOpen(i8* %41)
  %43 = icmp ne i8* %42, null
  br i1 %43, label %$17, label %$16
$16:
  %44 = phi i64 [%38, %$14] ; # X
; # (dlerror)
  %45 = call i8* @dlerror()
; # (err Exe Y ($ "[DLL] %s") (dlerror))
  call void @err(i64 %0, i64 %15, i8* bitcast ([9 x i8]* @$93 to i8*), i8* %45)
  unreachable
$17:
  %46 = phi i64 [%38, %$14] ; # X
; # (set Y (box64 (i64 @)))
; # (i64 @)
  %47 = ptrtoint i8* %42 to i64
; # (box64 (i64 @))
  %48 = and i64 %47, 17293822569102704640
  %49 = icmp ne i64 %48, 0
  br i1 %49, label %$18, label %$19
$18:
  %50 = call i64 @boxNum(i64 %47)
  br label %$20
$19:
  %51 = shl i64 %47, 4
  %52 = or i64 %51, 2
  br label %$20
$20:
  %53 = phi i64 [%50, %$18], [%52, %$19] ; # ->
  %54 = inttoptr i64 %15 to i64*
  store i64 %53, i64* %54
  br label %$7
$7:
  %55 = phi i64 [%18, %$9], [%24, %$11], [%36, %$15], [%46, %$20] ; # X
  %56 = phi i8* [%20, %$9], [%28, %$11], [null, %$15], [%42, %$20] ; # ->
; # (++ X)
  %57 = inttoptr i64 %55 to i64*
  %58 = load i64, i64* %57
  %59 = getelementptr i64, i64* %57, i32 1
  %60 = load i64, i64* %59
; # (eval (++ X))
  %61 = and i64 %58, 6
  %62 = icmp ne i64 %61, 0
  br i1 %62, label %$23, label %$22
$23:
  br label %$21
$22:
  %63 = and i64 %58, 8
  %64 = icmp ne i64 %63, 0
  br i1 %64, label %$25, label %$24
$25:
  %65 = inttoptr i64 %58 to i64*
  %66 = load i64, i64* %65
  br label %$21
$24:
  %67 = call i64 @evList(i64 %58)
  br label %$21
$21:
  %68 = phi i64 [%58, %$23], [%66, %$25], [%67, %$24] ; # ->
; # (save (eval (++ X)))
  %69 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %70 = load i64, i64* %69
  %71 = alloca i64, i64 2, align 16
  %72 = ptrtoint i64* %71 to i64
  %73 = inttoptr i64 %72 to i64*
  store i64 %68, i64* %73
  %74 = add i64 %72, 8
  %75 = inttoptr i64 %74 to i64*
  store i64 %70, i64* %75
  %76 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %72, i64* %76
; # (++ X)
  %77 = inttoptr i64 %60 to i64*
  %78 = load i64, i64* %77
  %79 = getelementptr i64, i64* %77, i32 1
  %80 = load i64, i64* %79
; # (eval (++ X))
  %81 = and i64 %78, 6
  %82 = icmp ne i64 %81, 0
  br i1 %82, label %$28, label %$27
$28:
  br label %$26
$27:
  %83 = and i64 %78, 8
  %84 = icmp ne i64 %83, 0
  br i1 %84, label %$30, label %$29
$30:
  %85 = inttoptr i64 %78 to i64*
  %86 = load i64, i64* %85
  br label %$26
$29:
  %87 = call i64 @evList(i64 %78)
  br label %$26
$26:
  %88 = phi i64 [%78, %$28], [%86, %$30], [%87, %$29] ; # ->
; # (cons (eval (++ X)) $Nil)
  %89 = call i64 @cons(i64 %88, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (save (cons (eval (++ X)) $Nil))
  %90 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %91 = load i64, i64* %90
  %92 = alloca i64, i64 2, align 16
  %93 = ptrtoint i64* %92 to i64
  %94 = inttoptr i64 %93 to i64*
  store i64 %89, i64* %94
  %95 = add i64 %93, 8
  %96 = inttoptr i64 %95 to i64*
  store i64 %91, i64* %96
  %97 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %93, i64* %97
; # (while (pair X) (let Z (push (save (eval (++ X))) $Nil) (set 2 L ...
  br label %$31
$31:
  %98 = phi i64 [%80, %$26], [%107, %$34] ; # X
  %99 = phi i64 [%89, %$26], [%125, %$34] ; # L
; # (pair X)
  %100 = and i64 %98, 15
  %101 = icmp eq i64 %100, 0
  br i1 %101, label %$32, label %$33
$32:
  %102 = phi i64 [%98, %$31] ; # X
  %103 = phi i64 [%99, %$31] ; # L
; # (let Z (push (save (eval (++ X))) $Nil) (set 2 L Z) (setq L Z))
; # (++ X)
  %104 = inttoptr i64 %102 to i64*
  %105 = load i64, i64* %104
  %106 = getelementptr i64, i64* %104, i32 1
  %107 = load i64, i64* %106
; # (eval (++ X))
  %108 = and i64 %105, 6
  %109 = icmp ne i64 %108, 0
  br i1 %109, label %$36, label %$35
$36:
  br label %$34
$35:
  %110 = and i64 %105, 8
  %111 = icmp ne i64 %110, 0
  br i1 %111, label %$38, label %$37
$38:
  %112 = inttoptr i64 %105 to i64*
  %113 = load i64, i64* %112
  br label %$34
$37:
  %114 = call i64 @evList(i64 %105)
  br label %$34
$34:
  %115 = phi i64 [%105, %$36], [%113, %$38], [%114, %$37] ; # ->
; # (save (eval (++ X)))
  %116 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %117 = load i64, i64* %116
  %118 = alloca i64, i64 2, align 16
  %119 = ptrtoint i64* %118 to i64
  %120 = inttoptr i64 %119 to i64*
  store i64 %115, i64* %120
  %121 = add i64 %119, 8
  %122 = inttoptr i64 %121 to i64*
  store i64 %117, i64* %122
  %123 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %119, i64* %123
; # (push (save (eval (++ X))) $Nil)
  %124 = alloca i64, i64 2, align 16
  %125 = ptrtoint i64* %124 to i64
  %126 = inttoptr i64 %125 to i64*
  store i64 %115, i64* %126
  %127 = add i64 %125, 8
  %128 = inttoptr i64 %127 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %128
; # (set 2 L Z)
  %129 = inttoptr i64 %103 to i64*
  %130 = getelementptr i64, i64* %129, i32 1
  store i64 %125, i64* %130
  br label %$31
$33:
  %131 = phi i64 [%98, %$31] ; # X
  %132 = phi i64 [%99, %$31] ; # L
; # (ffi Exe Lib Fun Args)
  %133 = tail call i64 @ffi(i64 %0, i8* %56, i64 %68, i64 %89)
; # (drop *Safe)
  %134 = inttoptr i64 %72 to i64*
  %135 = getelementptr i64, i64* %134, i32 1
  %136 = load i64, i64* %135
  %137 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %136, i64* %137
  ret i64 %133
}

define i64 @_Struct(i64) align 8 {
$1:
; # (let (X (cdr Exe) N (if (cnt? (needNum Exe (eval (++ X)))) (int @...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (if (cnt? (needNum Exe (eval (++ X)))) (int @) (val (dig @)))
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (needNum Exe (eval (++ X)))
  %16 = and i64 %15, 6
  %17 = icmp ne i64 %16, 0
  br i1 %17, label %$8, label %$7
$7:
  call void @numErr(i64 %0, i64 %15)
  unreachable
$8:
; # (cnt? (needNum Exe (eval (++ X))))
  %18 = and i64 %15, 2
  %19 = icmp ne i64 %18, 0
  br i1 %19, label %$9, label %$10
$9:
  %20 = phi i64 [%7, %$8] ; # X
; # (int @)
  %21 = lshr i64 %15, 4
  br label %$11
$10:
  %22 = phi i64 [%7, %$8] ; # X
; # (dig @)
  %23 = add i64 %15, -4
; # (val (dig @))
  %24 = inttoptr i64 %23 to i64*
  %25 = load i64, i64* %24
  br label %$11
$11:
  %26 = phi i64 [%20, %$9], [%22, %$10] ; # X
  %27 = phi i64 [%21, %$9], [%25, %$10] ; # ->
; # (i8* N)
  %28 = inttoptr i64 %27 to i8*
; # (car X)
  %29 = inttoptr i64 %26 to i64*
  %30 = load i64, i64* %29
; # (eval (car X))
  %31 = and i64 %30, 6
  %32 = icmp ne i64 %31, 0
  br i1 %32, label %$14, label %$13
$14:
  br label %$12
$13:
  %33 = and i64 %30, 8
  %34 = icmp ne i64 %33, 0
  br i1 %34, label %$16, label %$15
$16:
  %35 = inttoptr i64 %30 to i64*
  %36 = load i64, i64* %35
  br label %$12
$15:
  %37 = call i64 @evList(i64 %30)
  br label %$12
$12:
  %38 = phi i64 [%30, %$14], [%36, %$16], [%37, %$15] ; # ->
; # (save (eval (car X)))
  %39 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %40 = load i64, i64* %39
  %41 = alloca i64, i64 2, align 16
  %42 = ptrtoint i64* %41 to i64
  %43 = inttoptr i64 %42 to i64*
  store i64 %38, i64* %43
  %44 = add i64 %42, 8
  %45 = inttoptr i64 %44 to i64*
  store i64 %40, i64* %45
  %46 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %42, i64* %46
; # (while (pair (shift X)) (setq P (ofs P (natBuf (eval (car X)) P))...
  br label %$17
$17:
  %47 = phi i64 [%26, %$12], [%54, %$20] ; # X
  %48 = phi i8* [%28, %$12], [%67, %$20] ; # P
; # (shift X)
  %49 = inttoptr i64 %47 to i64*
  %50 = getelementptr i64, i64* %49, i32 1
  %51 = load i64, i64* %50
; # (pair (shift X))
  %52 = and i64 %51, 15
  %53 = icmp eq i64 %52, 0
  br i1 %53, label %$18, label %$19
$18:
  %54 = phi i64 [%51, %$17] ; # X
  %55 = phi i8* [%48, %$17] ; # P
; # (car X)
  %56 = inttoptr i64 %54 to i64*
  %57 = load i64, i64* %56
; # (eval (car X))
  %58 = and i64 %57, 6
  %59 = icmp ne i64 %58, 0
  br i1 %59, label %$22, label %$21
$22:
  br label %$20
$21:
  %60 = and i64 %57, 8
  %61 = icmp ne i64 %60, 0
  br i1 %61, label %$24, label %$23
$24:
  %62 = inttoptr i64 %57 to i64*
  %63 = load i64, i64* %62
  br label %$20
$23:
  %64 = call i64 @evList(i64 %57)
  br label %$20
$20:
  %65 = phi i64 [%57, %$22], [%63, %$24], [%64, %$23] ; # ->
; # (natBuf (eval (car X)) P)
  %66 = call i64 @natBuf(i64 %65, i8* %55)
; # (ofs P (natBuf (eval (car X)) P))
  %67 = getelementptr i8, i8* %55, i64 %66
  br label %$17
$19:
  %68 = phi i64 [%51, %$17] ; # X
  %69 = phi i8* [%48, %$17] ; # P
; # (cond ((nil? Y) @) ((== Y $S) (mkStr (i8* N))) (T (natRetBuf Y (i...
; # (nil? Y)
  %70 = icmp eq i64 %38, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %70, label %$27, label %$26
$27:
  %71 = phi i64 [%68, %$19] ; # X
  %72 = phi i8* [%69, %$19] ; # P
  br label %$25
$26:
  %73 = phi i64 [%68, %$19] ; # X
  %74 = phi i8* [%69, %$19] ; # P
; # (== Y $S)
  %75 = icmp eq i64 %38, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 328) to i64)
  br i1 %75, label %$29, label %$28
$29:
  %76 = phi i64 [%73, %$26] ; # X
  %77 = phi i8* [%74, %$26] ; # P
; # (i8* N)
  %78 = inttoptr i64 %27 to i8*
; # (mkStr (i8* N))
  %79 = call i64 @mkStr(i8* %78)
  br label %$25
$28:
  %80 = phi i64 [%73, %$26] ; # X
  %81 = phi i8* [%74, %$26] ; # P
; # (push N)
  %82 = alloca i64, i64 1
  store i64 %27, i64* %82
; # (i8** (push N))
  %83 = bitcast i64* %82 to i8**
; # (natRetBuf Y (i8** (push N)))
  %84 = call i64 @natRetBuf(i64 %38, i8** %83)
  br label %$25
$25:
  %85 = phi i64 [%71, %$27], [%76, %$29], [%80, %$28] ; # X
  %86 = phi i8* [%72, %$27], [%77, %$29], [%81, %$28] ; # P
  %87 = phi i64 [%38, %$27], [%79, %$29], [%84, %$28] ; # ->
; # (drop *Safe)
  %88 = inttoptr i64 %42 to i64*
  %89 = getelementptr i64, i64* %88, i32 1
  %90 = load i64, i64* %89
  %91 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %90, i64* %91
  ret i64 %87
}

define i64 @cbl(i64, i64, i64, i64, i64, i64) align 8 {
$1:
; # (let Exe (push NIL NIL ZERO Fun) (set Exe (ofs Exe 3)) (let P (se...
; # (push NIL NIL ZERO Fun)
  %6 = alloca i64, i64 4, align 16
  %7 = ptrtoint i64* %6 to i64
  %8 = add i64 %7, 16
  %9 = inttoptr i64 %8 to i64*
  store i64 2, i64* %9
  %10 = add i64 %7, 24
  %11 = inttoptr i64 %10 to i64*
  store i64 %0, i64* %11
; # (set Exe (ofs Exe 3))
; # (ofs Exe 3)
  %12 = add i64 %7, 24
  %13 = inttoptr i64 %7 to i64*
  store i64 %12, i64* %13
; # (let P (set 2 Exe (push NIL NIL ZERO (box A))) (set P (ofs P 3)) ...
; # (set 2 Exe (push NIL NIL ZERO (box A)))
; # (box A)
  %14 = call i64 @box(i64 %1)
; # (push NIL NIL ZERO (box A))
  %15 = alloca i64, i64 4, align 16
  %16 = ptrtoint i64* %15 to i64
  %17 = add i64 %16, 16
  %18 = inttoptr i64 %17 to i64*
  store i64 2, i64* %18
  %19 = add i64 %16, 24
  %20 = inttoptr i64 %19 to i64*
  store i64 %14, i64* %20
  %21 = inttoptr i64 %7 to i64*
  %22 = getelementptr i64, i64* %21, i32 1
  store i64 %16, i64* %22
; # (set P (ofs P 3))
; # (ofs P 3)
  %23 = add i64 %16, 24
  %24 = inttoptr i64 %16 to i64*
  store i64 %23, i64* %24
; # (set 2 P (push NIL NIL ZERO (box B)))
; # (box B)
  %25 = call i64 @box(i64 %2)
; # (push NIL NIL ZERO (box B))
  %26 = alloca i64, i64 4, align 16
  %27 = ptrtoint i64* %26 to i64
  %28 = add i64 %27, 16
  %29 = inttoptr i64 %28 to i64*
  store i64 2, i64* %29
  %30 = add i64 %27, 24
  %31 = inttoptr i64 %30 to i64*
  store i64 %25, i64* %31
  %32 = inttoptr i64 %16 to i64*
  %33 = getelementptr i64, i64* %32, i32 1
  store i64 %27, i64* %33
; # (set P (ofs P 3))
; # (ofs P 3)
  %34 = add i64 %27, 24
  %35 = inttoptr i64 %27 to i64*
  store i64 %34, i64* %35
; # (set 2 P (push NIL NIL ZERO (box C)))
; # (box C)
  %36 = call i64 @box(i64 %3)
; # (push NIL NIL ZERO (box C))
  %37 = alloca i64, i64 4, align 16
  %38 = ptrtoint i64* %37 to i64
  %39 = add i64 %38, 16
  %40 = inttoptr i64 %39 to i64*
  store i64 2, i64* %40
  %41 = add i64 %38, 24
  %42 = inttoptr i64 %41 to i64*
  store i64 %36, i64* %42
  %43 = inttoptr i64 %27 to i64*
  %44 = getelementptr i64, i64* %43, i32 1
  store i64 %38, i64* %44
; # (set P (ofs P 3))
; # (ofs P 3)
  %45 = add i64 %38, 24
  %46 = inttoptr i64 %38 to i64*
  store i64 %45, i64* %46
; # (set 2 P (push NIL NIL ZERO (box D)))
; # (box D)
  %47 = call i64 @box(i64 %4)
; # (push NIL NIL ZERO (box D))
  %48 = alloca i64, i64 4, align 16
  %49 = ptrtoint i64* %48 to i64
  %50 = add i64 %49, 16
  %51 = inttoptr i64 %50 to i64*
  store i64 2, i64* %51
  %52 = add i64 %49, 24
  %53 = inttoptr i64 %52 to i64*
  store i64 %47, i64* %53
  %54 = inttoptr i64 %38 to i64*
  %55 = getelementptr i64, i64* %54, i32 1
  store i64 %49, i64* %55
; # (set P (ofs P 3))
; # (ofs P 3)
  %56 = add i64 %49, 24
  %57 = inttoptr i64 %49 to i64*
  store i64 %56, i64* %57
; # (set 2 P (push NIL $Nil ZERO (box E)))
; # (box E)
  %58 = call i64 @box(i64 %5)
; # (push NIL $Nil ZERO (box E))
  %59 = alloca i64, i64 4, align 16
  %60 = ptrtoint i64* %59 to i64
  %61 = add i64 %60, 8
  %62 = inttoptr i64 %61 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %62
  %63 = add i64 %60, 16
  %64 = inttoptr i64 %63 to i64*
  store i64 2, i64* %64
  %65 = add i64 %60, 24
  %66 = inttoptr i64 %65 to i64*
  store i64 %58, i64* %66
  %67 = inttoptr i64 %49 to i64*
  %68 = getelementptr i64, i64* %67, i32 1
  store i64 %60, i64* %68
; # (set P (ofs P 3))
; # (ofs P 3)
  %69 = add i64 %60, 24
  %70 = inttoptr i64 %60 to i64*
  store i64 %69, i64* %70
; # (evList Exe)
  %71 = call i64 @evList(i64 %7)
; # (xCnt 0 (evList Exe))
  %72 = call i64 @xCnt(i64 0, i64 %71)
  ret i64 %72
}

define i64 @_Cb1(i64, i64, i64, i64, i64) align 8 {
$1:
; # (val 2 $Lisp)
  %5 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 40) to i64) to i64*
  %6 = getelementptr i64, i64* %5, i32 1
  %7 = load i64, i64* %6
; # (cbl (val 2 $Lisp) A B C D E)
  %8 = call i64 @cbl(i64 %7, i64 %0, i64 %1, i64 %2, i64 %3, i64 %4)
  ret i64 %8
}

define i64 @_Cb2(i64, i64, i64, i64, i64) align 8 {
$1:
; # (val 4 $Lisp)
  %5 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 40) to i64) to i64*
  %6 = getelementptr i64, i64* %5, i32 3
  %7 = load i64, i64* %6
; # (cbl (val 4 $Lisp) A B C D E)
  %8 = call i64 @cbl(i64 %7, i64 %0, i64 %1, i64 %2, i64 %3, i64 %4)
  ret i64 %8
}

define i64 @_Cb3(i64, i64, i64, i64, i64) align 8 {
$1:
; # (val 6 $Lisp)
  %5 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 40) to i64) to i64*
  %6 = getelementptr i64, i64* %5, i32 5
  %7 = load i64, i64* %6
; # (cbl (val 6 $Lisp) A B C D E)
  %8 = call i64 @cbl(i64 %7, i64 %0, i64 %1, i64 %2, i64 %3, i64 %4)
  ret i64 %8
}

define i64 @_Cb4(i64, i64, i64, i64, i64) align 8 {
$1:
; # (val 8 $Lisp)
  %5 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 40) to i64) to i64*
  %6 = getelementptr i64, i64* %5, i32 7
  %7 = load i64, i64* %6
; # (cbl (val 8 $Lisp) A B C D E)
  %8 = call i64 @cbl(i64 %7, i64 %0, i64 %1, i64 %2, i64 %3, i64 %4)
  ret i64 %8
}

define i64 @_Cb5(i64, i64, i64, i64, i64) align 8 {
$1:
; # (val 10 $Lisp)
  %5 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 40) to i64) to i64*
  %6 = getelementptr i64, i64* %5, i32 9
  %7 = load i64, i64* %6
; # (cbl (val 10 $Lisp) A B C D E)
  %8 = call i64 @cbl(i64 %7, i64 %0, i64 %1, i64 %2, i64 %3, i64 %4)
  ret i64 %8
}

define i64 @_Cb6(i64, i64, i64, i64, i64) align 8 {
$1:
; # (val 12 $Lisp)
  %5 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 40) to i64) to i64*
  %6 = getelementptr i64, i64* %5, i32 11
  %7 = load i64, i64* %6
; # (cbl (val 12 $Lisp) A B C D E)
  %8 = call i64 @cbl(i64 %7, i64 %0, i64 %1, i64 %2, i64 %3, i64 %4)
  ret i64 %8
}

define i64 @_Cb7(i64, i64, i64, i64, i64) align 8 {
$1:
; # (val 14 $Lisp)
  %5 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 40) to i64) to i64*
  %6 = getelementptr i64, i64* %5, i32 13
  %7 = load i64, i64* %6
; # (cbl (val 14 $Lisp) A B C D E)
  %8 = call i64 @cbl(i64 %7, i64 %0, i64 %1, i64 %2, i64 %3, i64 %4)
  ret i64 %8
}

define i64 @_Cb8(i64, i64, i64, i64, i64) align 8 {
$1:
; # (val 16 $Lisp)
  %5 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 40) to i64) to i64*
  %6 = getelementptr i64, i64* %5, i32 15
  %7 = load i64, i64* %6
; # (cbl (val 16 $Lisp) A B C D E)
  %8 = call i64 @cbl(i64 %7, i64 %0, i64 %1, i64 %2, i64 %3, i64 %4)
  ret i64 %8
}

define i64 @_Cb9(i64, i64, i64, i64, i64) align 8 {
$1:
; # (val 18 $Lisp)
  %5 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 40) to i64) to i64*
  %6 = getelementptr i64, i64* %5, i32 17
  %7 = load i64, i64* %6
; # (cbl (val 18 $Lisp) A B C D E)
  %8 = call i64 @cbl(i64 %7, i64 %0, i64 %1, i64 %2, i64 %3, i64 %4)
  ret i64 %8
}

define i64 @_Cb10(i64, i64, i64, i64, i64) align 8 {
$1:
; # (val 20 $Lisp)
  %5 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 40) to i64) to i64*
  %6 = getelementptr i64, i64* %5, i32 19
  %7 = load i64, i64* %6
; # (cbl (val 20 $Lisp) A B C D E)
  %8 = call i64 @cbl(i64 %7, i64 %0, i64 %1, i64 %2, i64 %3, i64 %4)
  ret i64 %8
}

define i64 @_Cb11(i64, i64, i64, i64, i64) align 8 {
$1:
; # (val 22 $Lisp)
  %5 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 40) to i64) to i64*
  %6 = getelementptr i64, i64* %5, i32 21
  %7 = load i64, i64* %6
; # (cbl (val 22 $Lisp) A B C D E)
  %8 = call i64 @cbl(i64 %7, i64 %0, i64 %1, i64 %2, i64 %3, i64 %4)
  ret i64 %8
}

define i64 @_Cb12(i64, i64, i64, i64, i64) align 8 {
$1:
; # (val 24 $Lisp)
  %5 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 40) to i64) to i64*
  %6 = getelementptr i64, i64* %5, i32 23
  %7 = load i64, i64* %6
; # (cbl (val 24 $Lisp) A B C D E)
  %8 = call i64 @cbl(i64 %7, i64 %0, i64 %1, i64 %2, i64 %3, i64 %4)
  ret i64 %8
}

define i64 @_Cb13(i64, i64, i64, i64, i64) align 8 {
$1:
; # (val 26 $Lisp)
  %5 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 40) to i64) to i64*
  %6 = getelementptr i64, i64* %5, i32 25
  %7 = load i64, i64* %6
; # (cbl (val 26 $Lisp) A B C D E)
  %8 = call i64 @cbl(i64 %7, i64 %0, i64 %1, i64 %2, i64 %3, i64 %4)
  ret i64 %8
}

define i64 @_Cb14(i64, i64, i64, i64, i64) align 8 {
$1:
; # (val 28 $Lisp)
  %5 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 40) to i64) to i64*
  %6 = getelementptr i64, i64* %5, i32 27
  %7 = load i64, i64* %6
; # (cbl (val 28 $Lisp) A B C D E)
  %8 = call i64 @cbl(i64 %7, i64 %0, i64 %1, i64 %2, i64 %3, i64 %4)
  ret i64 %8
}

define i64 @_Cb15(i64, i64, i64, i64, i64) align 8 {
$1:
; # (val 30 $Lisp)
  %5 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 40) to i64) to i64*
  %6 = getelementptr i64, i64* %5, i32 29
  %7 = load i64, i64* %6
; # (cbl (val 30 $Lisp) A B C D E)
  %8 = call i64 @cbl(i64 %7, i64 %0, i64 %1, i64 %2, i64 %3, i64 %4)
  ret i64 %8
}

define i64 @_Cb16(i64, i64, i64, i64, i64) align 8 {
$1:
; # (val 32 $Lisp)
  %5 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 40) to i64) to i64*
  %6 = getelementptr i64, i64* %5, i32 31
  %7 = load i64, i64* %6
; # (cbl (val 32 $Lisp) A B C D E)
  %8 = call i64 @cbl(i64 %7, i64 %0, i64 %1, i64 %2, i64 %3, i64 %4)
  ret i64 %8
}

define i64 @_Cb17(i64, i64, i64, i64, i64) align 8 {
$1:
; # (val 34 $Lisp)
  %5 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 40) to i64) to i64*
  %6 = getelementptr i64, i64* %5, i32 33
  %7 = load i64, i64* %6
; # (cbl (val 34 $Lisp) A B C D E)
  %8 = call i64 @cbl(i64 %7, i64 %0, i64 %1, i64 %2, i64 %3, i64 %4)
  ret i64 %8
}

define i64 @_Cb18(i64, i64, i64, i64, i64) align 8 {
$1:
; # (val 36 $Lisp)
  %5 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 40) to i64) to i64*
  %6 = getelementptr i64, i64* %5, i32 35
  %7 = load i64, i64* %6
; # (cbl (val 36 $Lisp) A B C D E)
  %8 = call i64 @cbl(i64 %7, i64 %0, i64 %1, i64 %2, i64 %3, i64 %4)
  ret i64 %8
}

define i64 @_Cb19(i64, i64, i64, i64, i64) align 8 {
$1:
; # (val 38 $Lisp)
  %5 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 40) to i64) to i64*
  %6 = getelementptr i64, i64* %5, i32 37
  %7 = load i64, i64* %6
; # (cbl (val 38 $Lisp) A B C D E)
  %8 = call i64 @cbl(i64 %7, i64 %0, i64 %1, i64 %2, i64 %3, i64 %4)
  ret i64 %8
}

define i64 @_Cb20(i64, i64, i64, i64, i64) align 8 {
$1:
; # (val 40 $Lisp)
  %5 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 40) to i64) to i64*
  %6 = getelementptr i64, i64* %5, i32 39
  %7 = load i64, i64* %6
; # (cbl (val 40 $Lisp) A B C D E)
  %8 = call i64 @cbl(i64 %7, i64 %0, i64 %1, i64 %2, i64 %3, i64 %4)
  ret i64 %8
}

define i64 @_Cb21(i64, i64, i64, i64, i64) align 8 {
$1:
; # (val 42 $Lisp)
  %5 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 40) to i64) to i64*
  %6 = getelementptr i64, i64* %5, i32 41
  %7 = load i64, i64* %6
; # (cbl (val 42 $Lisp) A B C D E)
  %8 = call i64 @cbl(i64 %7, i64 %0, i64 %1, i64 %2, i64 %3, i64 %4)
  ret i64 %8
}

define i64 @_Cb22(i64, i64, i64, i64, i64) align 8 {
$1:
; # (val 44 $Lisp)
  %5 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 40) to i64) to i64*
  %6 = getelementptr i64, i64* %5, i32 43
  %7 = load i64, i64* %6
; # (cbl (val 44 $Lisp) A B C D E)
  %8 = call i64 @cbl(i64 %7, i64 %0, i64 %1, i64 %2, i64 %3, i64 %4)
  ret i64 %8
}

define i64 @_Cb23(i64, i64, i64, i64, i64) align 8 {
$1:
; # (val 46 $Lisp)
  %5 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 40) to i64) to i64*
  %6 = getelementptr i64, i64* %5, i32 45
  %7 = load i64, i64* %6
; # (cbl (val 46 $Lisp) A B C D E)
  %8 = call i64 @cbl(i64 %7, i64 %0, i64 %1, i64 %2, i64 %3, i64 %4)
  ret i64 %8
}

define i64 @_Cb24(i64, i64, i64, i64, i64) align 8 {
$1:
; # (val 48 $Lisp)
  %5 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 40) to i64) to i64*
  %6 = getelementptr i64, i64* %5, i32 47
  %7 = load i64, i64* %6
; # (cbl (val 48 $Lisp) A B C D E)
  %8 = call i64 @cbl(i64 %7, i64 %0, i64 %1, i64 %2, i64 %3, i64 %4)
  ret i64 %8
}

define i64 @_Lisp(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (evSym X)) (let (P $Lisp Q (i8** (cbFuns))) (...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (evSym X)
  %4 = call i64 @evSym(i64 %3)
; # (let (P $Lisp Q (i8** (cbFuns))) (loop (? (== Y (val P))) (setq P...
; # (i8* $Cb)
  %5 = bitcast i64(i64,i64,i64,i64,i64)** bitcast (i8* getelementptr (i8, i8* bitcast ([24 x i64]* @cbFuns to i8*), i32 0) to i64(i64,i64,i64,i64,i64)**) to i8*
; # (i8** (cbFuns))
  %6 = bitcast i8* %5 to i8**
; # (loop (? (== Y (val P))) (setq P (ofs P 2) Q (ofs Q 1)) (? (> P $...
  br label %$2
$2:
  %7 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 40) to i64), %$1], [%39, %$5] ; # P
  %8 = phi i8** [%6, %$1], [%40, %$5] ; # Q
; # (? (== Y (val P)))
; # (val P)
  %9 = inttoptr i64 %7 to i64*
  %10 = load i64, i64* %9
; # (== Y (val P))
  %11 = icmp eq i64 %4, %10
  br i1 %11, label %$4, label %$3
$3:
  %12 = phi i64 [%7, %$2] ; # P
  %13 = phi i8** [%8, %$2] ; # Q
; # (ofs P 2)
  %14 = add i64 %12, 16
; # (ofs Q 1)
  %15 = getelementptr i8*, i8** %13, i32 1
; # (? (> P $LispEnd) (setq P $Lisp Q (i8** (cbFuns))) (until (nil? (...
; # (> P $LispEnd)
  %16 = icmp ugt i64 %14, ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 416) to i64)
  br i1 %16, label %$6, label %$5
$6:
  %17 = phi i64 [%14, %$3] ; # P
  %18 = phi i8** [%15, %$3] ; # Q
; # (i8* $Cb)
  %19 = bitcast i64(i64,i64,i64,i64,i64)** bitcast (i8* getelementptr (i8, i8* bitcast ([24 x i64]* @cbFuns to i8*), i32 0) to i64(i64,i64,i64,i64,i64)**) to i8*
; # (i8** (cbFuns))
  %20 = bitcast i8* %19 to i8**
; # (until (nil? (val 2 P)) (setq P (ofs P 2) Q (ofs Q 1)) (when (> P...
  br label %$7
$7:
  %21 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 40) to i64), %$6], [%34, %$11] ; # P
  %22 = phi i8** [%20, %$6], [%35, %$11] ; # Q
; # (val 2 P)
  %23 = inttoptr i64 %21 to i64*
  %24 = getelementptr i64, i64* %23, i32 1
  %25 = load i64, i64* %24
; # (nil? (val 2 P))
  %26 = icmp eq i64 %25, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %26, label %$9, label %$8
$8:
  %27 = phi i64 [%21, %$7] ; # P
  %28 = phi i8** [%22, %$7] ; # Q
; # (ofs P 2)
  %29 = add i64 %27, 16
; # (ofs Q 1)
  %30 = getelementptr i8*, i8** %28, i32 1
; # (when (> P $LispEnd) (err Exe 0 ($ "Too many callbacks") null))
; # (> P $LispEnd)
  %31 = icmp ugt i64 %29, ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 416) to i64)
  br i1 %31, label %$10, label %$11
$10:
  %32 = phi i64 [%29, %$8] ; # P
  %33 = phi i8** [%30, %$8] ; # Q
; # (err Exe 0 ($ "Too many callbacks") null)
  call void @err(i64 %0, i64 0, i8* bitcast ([19 x i8]* @$94 to i8*), i8* null)
  unreachable
$11:
  %34 = phi i64 [%29, %$8] ; # P
  %35 = phi i8** [%30, %$8] ; # Q
  br label %$7
$9:
  %36 = phi i64 [%21, %$7] ; # P
  %37 = phi i8** [%22, %$7] ; # Q
; # (set P Y)
  %38 = inttoptr i64 %36 to i64*
  store i64 %4, i64* %38
  br label %$4
$5:
  %39 = phi i64 [%14, %$3] ; # P
  %40 = phi i8** [%15, %$3] ; # Q
  br label %$2
$4:
  %41 = phi i64 [%7, %$2], [%36, %$9] ; # P
  %42 = phi i8** [%8, %$2], [%37, %$9] ; # Q
  %43 = phi i64 [0, %$2], [%4, %$9] ; # ->
; # (set 2 P (eval (cadr X)))
; # (cadr X)
  %44 = inttoptr i64 %3 to i64*
  %45 = getelementptr i64, i64* %44, i32 1
  %46 = load i64, i64* %45
  %47 = inttoptr i64 %46 to i64*
  %48 = load i64, i64* %47
; # (eval (cadr X))
  %49 = and i64 %48, 6
  %50 = icmp ne i64 %49, 0
  br i1 %50, label %$14, label %$13
$14:
  br label %$12
$13:
  %51 = and i64 %48, 8
  %52 = icmp ne i64 %51, 0
  br i1 %52, label %$16, label %$15
$16:
  %53 = inttoptr i64 %48 to i64*
  %54 = load i64, i64* %53
  br label %$12
$15:
  %55 = call i64 @evList(i64 %48)
  br label %$12
$12:
  %56 = phi i64 [%48, %$14], [%54, %$16], [%55, %$15] ; # ->
  %57 = inttoptr i64 %41 to i64*
  %58 = getelementptr i64, i64* %57, i32 1
  store i64 %56, i64* %58
; # (val Q)
  %59 = load i8*, i8** %42
; # (i64 (val Q))
  %60 = ptrtoint i8* %59 to i64
; # (box64 (i64 (val Q)))
  %61 = and i64 %60, 17293822569102704640
  %62 = icmp ne i64 %61, 0
  br i1 %62, label %$17, label %$18
$17:
  %63 = call i64 @boxNum(i64 %60)
  br label %$19
$18:
  %64 = shl i64 %60, 4
  %65 = or i64 %64, 2
  br label %$19
$19:
  %66 = phi i64 [%63, %$17], [%65, %$18] ; # ->
  ret i64 %66
}

define i64 @_Args(i64) align 8 {
$1:
; # (if (pair (val $Next)) $T $Nil)
; # (val $Next)
  %1 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 128) to i64) to i64*
  %2 = load i64, i64* %1
; # (pair (val $Next))
  %3 = and i64 %2, 15
  %4 = icmp eq i64 %3, 0
  br i1 %4, label %$2, label %$3
$2:
  br label %$4
$3:
  br label %$4
$4:
  %5 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$2], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$3] ; # ->
  ret i64 %5
}

define i64 @_Next(i64) align 8 {
$1:
; # (let X (val $Next) (set $Next (car X)) (cdr X))
; # (val $Next)
  %1 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 128) to i64) to i64*
  %2 = load i64, i64* %1
; # (set $Next (car X))
; # (car X)
  %3 = inttoptr i64 %2 to i64*
  %4 = load i64, i64* %3
  %5 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 128) to i64) to i64*
  store i64 %4, i64* %5
; # (cdr X)
  %6 = inttoptr i64 %2 to i64*
  %7 = getelementptr i64, i64* %6, i32 1
  %8 = load i64, i64* %7
  ret i64 %8
}

define i64 @_Arg(i64) align 8 {
$1:
; # (if (le0 (evCnt Exe (cdr Exe))) $Nil (let (N @ X (val $Next)) (wh...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (evCnt Exe (cdr Exe))
  %4 = call i64 @evCnt(i64 %0, i64 %3)
; # (le0 (evCnt Exe (cdr Exe)))
  %5 = icmp sle i64 %4, 0
  br i1 %5, label %$2, label %$3
$2:
  br label %$4
$3:
; # (let (N @ X (val $Next)) (while (gt0 (dec 'N)) (setq X (car X))) ...
; # (val $Next)
  %6 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 128) to i64) to i64*
  %7 = load i64, i64* %6
; # (while (gt0 (dec 'N)) (setq X (car X)))
  br label %$5
$5:
  %8 = phi i64 [%4, %$3], [%12, %$6] ; # N
  %9 = phi i64 [%7, %$3], [%15, %$6] ; # X
; # (dec 'N)
  %10 = sub i64 %8, 1
; # (gt0 (dec 'N))
  %11 = icmp sgt i64 %10, 0
  br i1 %11, label %$6, label %$7
$6:
  %12 = phi i64 [%10, %$5] ; # N
  %13 = phi i64 [%9, %$5] ; # X
; # (car X)
  %14 = inttoptr i64 %13 to i64*
  %15 = load i64, i64* %14
  br label %$5
$7:
  %16 = phi i64 [%10, %$5] ; # N
  %17 = phi i64 [%9, %$5] ; # X
; # (cdr X)
  %18 = inttoptr i64 %17 to i64*
  %19 = getelementptr i64, i64* %18, i32 1
  %20 = load i64, i64* %19
  br label %$4
$4:
  %21 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%20, %$7] ; # ->
  ret i64 %21
}

define i64 @_Rest(i64) align 8 {
$1:
; # (let X (val $Next) (if (atom X) X (let (Y (cons (cdr X) $Nil) R (...
; # (val $Next)
  %1 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 128) to i64) to i64*
  %2 = load i64, i64* %1
; # (if (atom X) X (let (Y (cons (cdr X) $Nil) R (save Y)) (while (pa...
; # (atom X)
  %3 = and i64 %2, 15
  %4 = icmp ne i64 %3, 0
  br i1 %4, label %$2, label %$3
$2:
  %5 = phi i64 [%2, %$1] ; # X
  br label %$4
$3:
  %6 = phi i64 [%2, %$1] ; # X
; # (let (Y (cons (cdr X) $Nil) R (save Y)) (while (pair (setq X (car...
; # (cdr X)
  %7 = inttoptr i64 %6 to i64*
  %8 = getelementptr i64, i64* %7, i32 1
  %9 = load i64, i64* %8
; # (cons (cdr X) $Nil)
  %10 = call i64 @cons(i64 %9, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (save Y)
  %11 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %12 = load i64, i64* %11
  %13 = alloca i64, i64 2, align 16
  %14 = ptrtoint i64* %13 to i64
  %15 = inttoptr i64 %14 to i64*
  store i64 %10, i64* %15
  %16 = add i64 %14, 8
  %17 = inttoptr i64 %16 to i64*
  store i64 %12, i64* %17
  %18 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %14, i64* %18
; # (while (pair (setq X (car X))) (setq Y (set 2 Y (cons (cdr X) $Ni...
  br label %$5
$5:
  %19 = phi i64 [%6, %$3], [%25, %$6] ; # X
  %20 = phi i64 [%10, %$3], [%30, %$6] ; # Y
; # (car X)
  %21 = inttoptr i64 %19 to i64*
  %22 = load i64, i64* %21
; # (pair (setq X (car X)))
  %23 = and i64 %22, 15
  %24 = icmp eq i64 %23, 0
  br i1 %24, label %$6, label %$7
$6:
  %25 = phi i64 [%22, %$5] ; # X
  %26 = phi i64 [%20, %$5] ; # Y
; # (set 2 Y (cons (cdr X) $Nil))
; # (cdr X)
  %27 = inttoptr i64 %25 to i64*
  %28 = getelementptr i64, i64* %27, i32 1
  %29 = load i64, i64* %28
; # (cons (cdr X) $Nil)
  %30 = call i64 @cons(i64 %29, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %31 = inttoptr i64 %26 to i64*
  %32 = getelementptr i64, i64* %31, i32 1
  store i64 %30, i64* %32
  br label %$5
$7:
  %33 = phi i64 [%22, %$5] ; # X
  %34 = phi i64 [%20, %$5] ; # Y
; # (drop *Safe)
  %35 = inttoptr i64 %14 to i64*
  %36 = getelementptr i64, i64* %35, i32 1
  %37 = load i64, i64* %36
  %38 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %37, i64* %38
  br label %$4
$4:
  %39 = phi i64 [%5, %$2], [%33, %$7] ; # X
  %40 = phi i64 [%5, %$2], [%10, %$7] ; # ->
  ret i64 %40
}

define i64 @_Adr(i64) align 8 {
$1:
; # (cond ((cnt? (eval (cadr Exe))) (int @)) ((big? @) (val (dig @)))...
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$5, label %$4
$5:
  br label %$3
$4:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$7, label %$6
$7:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$3
$6:
  %12 = call i64 @evList(i64 %5)
  br label %$3
$3:
  %13 = phi i64 [%5, %$5], [%11, %$7], [%12, %$6] ; # ->
; # (cnt? (eval (cadr Exe)))
  %14 = and i64 %13, 2
  %15 = icmp ne i64 %14, 0
  br i1 %15, label %$9, label %$8
$9:
; # (int @)
  %16 = lshr i64 %13, 4
  br label %$2
$8:
; # (big? @)
  %17 = and i64 %13, 4
  %18 = icmp ne i64 %17, 0
  br i1 %18, label %$11, label %$10
$11:
; # (dig @)
  %19 = add i64 %13, -4
; # (val (dig @))
  %20 = inttoptr i64 %19 to i64*
  %21 = load i64, i64* %20
  br label %$2
$10:
; # (box64 @)
  %22 = and i64 %13, 17293822569102704640
  %23 = icmp ne i64 %22, 0
  br i1 %23, label %$12, label %$13
$12:
  %24 = call i64 @boxNum(i64 %13)
  br label %$14
$13:
  %25 = shl i64 %13, 4
  %26 = or i64 %25, 2
  br label %$14
$14:
  %27 = phi i64 [%24, %$12], [%26, %$13] ; # ->
  br label %$2
$2:
  %28 = phi i64 [%16, %$9], [%21, %$11], [%27, %$14] ; # ->
  ret i64 %28
}

define i64 @_Byte(i64) align 8 {
$1:
; # (let (X (cdr Exe) P (i8* (if (cnt? (needNum Exe (eval (++ X)))) (...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (if (cnt? (needNum Exe (eval (++ X)))) (int @) (val (dig @)))
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (needNum Exe (eval (++ X)))
  %16 = and i64 %15, 6
  %17 = icmp ne i64 %16, 0
  br i1 %17, label %$8, label %$7
$7:
  call void @numErr(i64 %0, i64 %15)
  unreachable
$8:
; # (cnt? (needNum Exe (eval (++ X))))
  %18 = and i64 %15, 2
  %19 = icmp ne i64 %18, 0
  br i1 %19, label %$9, label %$10
$9:
; # (int @)
  %20 = lshr i64 %15, 4
  br label %$11
$10:
; # (dig @)
  %21 = add i64 %15, -4
; # (val (dig @))
  %22 = inttoptr i64 %21 to i64*
  %23 = load i64, i64* %22
  br label %$11
$11:
  %24 = phi i64 [%20, %$9], [%23, %$10] ; # ->
; # (i8* (if (cnt? (needNum Exe (eval (++ X)))) (int @) (val (dig @))...
  %25 = inttoptr i64 %24 to i8*
; # (if (atom X) (cnt (i64 (val P))) (let (Y (needCnt Exe (eval (car ...
; # (atom X)
  %26 = and i64 %7, 15
  %27 = icmp ne i64 %26, 0
  br i1 %27, label %$12, label %$13
$12:
; # (val P)
  %28 = load i8, i8* %25
; # (i64 (val P))
  %29 = zext i8 %28 to i64
; # (cnt (i64 (val P)))
  %30 = shl i64 %29, 4
  %31 = or i64 %30, 2
  br label %$14
$13:
; # (let (Y (needCnt Exe (eval (car X))) N (int @)) (set P (i8 (if (s...
; # (car X)
  %32 = inttoptr i64 %7 to i64*
  %33 = load i64, i64* %32
; # (eval (car X))
  %34 = and i64 %33, 6
  %35 = icmp ne i64 %34, 0
  br i1 %35, label %$17, label %$16
$17:
  br label %$15
$16:
  %36 = and i64 %33, 8
  %37 = icmp ne i64 %36, 0
  br i1 %37, label %$19, label %$18
$19:
  %38 = inttoptr i64 %33 to i64*
  %39 = load i64, i64* %38
  br label %$15
$18:
  %40 = call i64 @evList(i64 %33)
  br label %$15
$15:
  %41 = phi i64 [%33, %$17], [%39, %$19], [%40, %$18] ; # ->
; # (needCnt Exe (eval (car X)))
  %42 = and i64 %41, 2
  %43 = icmp ne i64 %42, 0
  br i1 %43, label %$21, label %$20
$20:
  call void @cntErr(i64 %0, i64 %41)
  unreachable
$21:
; # (int @)
  %44 = lshr i64 %41, 4
; # (set P (i8 (if (sign? Y) (- N) N)))
; # (if (sign? Y) (- N) N)
; # (sign? Y)
  %45 = and i64 %41, 8
  %46 = icmp ne i64 %45, 0
  br i1 %46, label %$22, label %$23
$22:
; # (- N)
  %47 = sub i64 0, %44
  br label %$24
$23:
  br label %$24
$24:
  %48 = phi i64 [%47, %$22], [%44, %$23] ; # ->
; # (i8 (if (sign? Y) (- N) N))
  %49 = trunc i64 %48 to i8
  store i8 %49, i8* %25
  br label %$14
$14:
  %50 = phi i64 [%31, %$12], [%41, %$24] ; # ->
  ret i64 %50
}

define i64 @_Env(i64) align 8 {
$1:
; # (let (X (cdr Exe) R (save $Nil)) (if (atom X) (let Bnd (val $Bind...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (save $Nil)
  %4 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %5 = load i64, i64* %4
  %6 = alloca i64, i64 2, align 16
  %7 = ptrtoint i64* %6 to i64
  %8 = inttoptr i64 %7 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %8
  %9 = add i64 %7, 8
  %10 = inttoptr i64 %9 to i64*
  store i64 %5, i64* %10
  %11 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %7, i64* %11
; # (if (atom X) (let Bnd (val $Bind) (while Bnd (let (S (val 2 Bnd) ...
; # (atom X)
  %12 = and i64 %3, 15
  %13 = icmp ne i64 %12, 0
  br i1 %13, label %$2, label %$3
$2:
  %14 = phi i64 [%3, %$1] ; # X
  %15 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$1] ; # R
; # (let Bnd (val $Bind) (while Bnd (let (S (val 2 Bnd) Y R) (loop (?...
; # (val $Bind)
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  %17 = load i64, i64* %16
; # (while Bnd (let (S (val 2 Bnd) Y R) (loop (? (atom Y) (setq R (sa...
  br label %$5
$5:
  %18 = phi i64 [%14, %$2], [%59, %$10] ; # X
  %19 = phi i64 [%15, %$2], [%60, %$10] ; # R
  %20 = phi i64 [%17, %$2], [%66, %$10] ; # Bnd
  %21 = icmp ne i64 %20, 0
  br i1 %21, label %$6, label %$7
$6:
  %22 = phi i64 [%18, %$5] ; # X
  %23 = phi i64 [%19, %$5] ; # R
  %24 = phi i64 [%20, %$5] ; # Bnd
; # (let (S (val 2 Bnd) Y R) (loop (? (atom Y) (setq R (safe (cons (c...
; # (val 2 Bnd)
  %25 = inttoptr i64 %24 to i64*
  %26 = getelementptr i64, i64* %25, i32 1
  %27 = load i64, i64* %26
; # (loop (? (atom Y) (setq R (safe (cons (cons S (val S)) R)))) (? (...
  br label %$8
$8:
  %28 = phi i64 [%22, %$6], [%52, %$12] ; # X
  %29 = phi i64 [%23, %$6], [%53, %$12] ; # R
  %30 = phi i64 [%24, %$6], [%54, %$12] ; # Bnd
  %31 = phi i64 [%23, %$6], [%58, %$12] ; # Y
; # (? (atom Y) (setq R (safe (cons (cons S (val S)) R))))
; # (atom Y)
  %32 = and i64 %31, 15
  %33 = icmp ne i64 %32, 0
  br i1 %33, label %$11, label %$9
$11:
  %34 = phi i64 [%28, %$8] ; # X
  %35 = phi i64 [%29, %$8] ; # R
  %36 = phi i64 [%30, %$8] ; # Bnd
  %37 = phi i64 [%31, %$8] ; # Y
; # (val S)
  %38 = inttoptr i64 %27 to i64*
  %39 = load i64, i64* %38
; # (cons S (val S))
  %40 = call i64 @cons(i64 %27, i64 %39)
; # (cons (cons S (val S)) R)
  %41 = call i64 @cons(i64 %40, i64 %35)
; # (safe (cons (cons S (val S)) R))
  %42 = inttoptr i64 %7 to i64*
  store i64 %41, i64* %42
  br label %$10
$9:
  %43 = phi i64 [%28, %$8] ; # X
  %44 = phi i64 [%29, %$8] ; # R
  %45 = phi i64 [%30, %$8] ; # Bnd
  %46 = phi i64 [%31, %$8] ; # Y
; # (? (== S (caar Y)))
; # (caar Y)
  %47 = inttoptr i64 %46 to i64*
  %48 = load i64, i64* %47
  %49 = inttoptr i64 %48 to i64*
  %50 = load i64, i64* %49
; # (== S (caar Y))
  %51 = icmp eq i64 %27, %50
  br i1 %51, label %$10, label %$12
$12:
  %52 = phi i64 [%43, %$9] ; # X
  %53 = phi i64 [%44, %$9] ; # R
  %54 = phi i64 [%45, %$9] ; # Bnd
  %55 = phi i64 [%46, %$9] ; # Y
; # (shift Y)
  %56 = inttoptr i64 %55 to i64*
  %57 = getelementptr i64, i64* %56, i32 1
  %58 = load i64, i64* %57
  br label %$8
$10:
  %59 = phi i64 [%34, %$11], [%43, %$9] ; # X
  %60 = phi i64 [%41, %$11], [%44, %$9] ; # R
  %61 = phi i64 [%36, %$11], [%45, %$9] ; # Bnd
  %62 = phi i64 [%37, %$11], [%46, %$9] ; # Y
  %63 = phi i64 [%41, %$11], [0, %$9] ; # ->
; # (val 3 Bnd)
  %64 = inttoptr i64 %61 to i64*
  %65 = getelementptr i64, i64* %64, i32 2
  %66 = load i64, i64* %65
  br label %$5
$7:
  %67 = phi i64 [%18, %$5] ; # X
  %68 = phi i64 [%19, %$5] ; # R
  %69 = phi i64 [%20, %$5] ; # Bnd
  br label %$4
$3:
  %70 = phi i64 [%3, %$1] ; # X
  %71 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$1] ; # R
; # (let Y (link (push $Nil NIL)) (loop (let Z (set Y (eval (++ X))) ...
; # (push $Nil NIL)
  %72 = alloca i64, i64 2, align 16
  %73 = ptrtoint i64* %72 to i64
  %74 = inttoptr i64 %73 to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i64* %74
; # (link (push $Nil NIL))
  %75 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %76 = load i64, i64* %75
  %77 = inttoptr i64 %73 to i64*
  %78 = getelementptr i64, i64* %77, i32 1
  store i64 %76, i64* %78
  %79 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %73, i64* %79
; # (loop (let Z (set Y (eval (++ X))) (nond ((atom Z) (loop (let V (...
  br label %$13
$13:
  %80 = phi i64 [%70, %$3], [%170, %$35] ; # X
  %81 = phi i64 [%71, %$3], [%171, %$35] ; # R
; # (let Z (set Y (eval (++ X))) (nond ((atom Z) (loop (let V (++ Z) ...
; # (set Y (eval (++ X)))
; # (++ X)
  %82 = inttoptr i64 %80 to i64*
  %83 = load i64, i64* %82
  %84 = getelementptr i64, i64* %82, i32 1
  %85 = load i64, i64* %84
; # (eval (++ X))
  %86 = and i64 %83, 6
  %87 = icmp ne i64 %86, 0
  br i1 %87, label %$16, label %$15
$16:
  br label %$14
$15:
  %88 = and i64 %83, 8
  %89 = icmp ne i64 %88, 0
  br i1 %89, label %$18, label %$17
$18:
  %90 = inttoptr i64 %83 to i64*
  %91 = load i64, i64* %90
  br label %$14
$17:
  %92 = call i64 @evList(i64 %83)
  br label %$14
$14:
  %93 = phi i64 [%83, %$16], [%91, %$18], [%92, %$17] ; # ->
  %94 = inttoptr i64 %73 to i64*
  store i64 %93, i64* %94
; # (nond ((atom Z) (loop (let V (++ Z) (setq R (safe (cons (if (pair...
; # (atom Z)
  %95 = and i64 %93, 15
  %96 = icmp ne i64 %95, 0
  br i1 %96, label %$20, label %$21
$21:
  %97 = phi i64 [%85, %$14] ; # X
  %98 = phi i64 [%81, %$14] ; # R
  %99 = phi i64 [%93, %$14] ; # Z
; # (loop (let V (++ Z) (setq R (safe (cons (if (pair V) (cons (car V...
  br label %$22
$22:
  %100 = phi i64 [%97, %$21], [%132, %$26] ; # X
  %101 = phi i64 [%98, %$21], [%133, %$26] ; # R
  %102 = phi i64 [%99, %$21], [%134, %$26] ; # Z
; # (let V (++ Z) (setq R (safe (cons (if (pair V) (cons (car V) (cdr...
; # (++ Z)
  %103 = inttoptr i64 %102 to i64*
  %104 = load i64, i64* %103
  %105 = getelementptr i64, i64* %103, i32 1
  %106 = load i64, i64* %105
; # (if (pair V) (cons (car V) (cdr V)) (cons V (val V)))
; # (pair V)
  %107 = and i64 %104, 15
  %108 = icmp eq i64 %107, 0
  br i1 %108, label %$23, label %$24
$23:
  %109 = phi i64 [%100, %$22] ; # X
  %110 = phi i64 [%101, %$22] ; # R
  %111 = phi i64 [%106, %$22] ; # Z
; # (car V)
  %112 = inttoptr i64 %104 to i64*
  %113 = load i64, i64* %112
; # (cdr V)
  %114 = inttoptr i64 %104 to i64*
  %115 = getelementptr i64, i64* %114, i32 1
  %116 = load i64, i64* %115
; # (cons (car V) (cdr V))
  %117 = call i64 @cons(i64 %113, i64 %116)
  br label %$25
$24:
  %118 = phi i64 [%100, %$22] ; # X
  %119 = phi i64 [%101, %$22] ; # R
  %120 = phi i64 [%106, %$22] ; # Z
; # (val V)
  %121 = inttoptr i64 %104 to i64*
  %122 = load i64, i64* %121
; # (cons V (val V))
  %123 = call i64 @cons(i64 %104, i64 %122)
  br label %$25
$25:
  %124 = phi i64 [%109, %$23], [%118, %$24] ; # X
  %125 = phi i64 [%110, %$23], [%119, %$24] ; # R
  %126 = phi i64 [%111, %$23], [%120, %$24] ; # Z
  %127 = phi i64 [%117, %$23], [%123, %$24] ; # ->
; # (cons (if (pair V) (cons (car V) (cdr V)) (cons V (val V))) R)
  %128 = call i64 @cons(i64 %127, i64 %125)
; # (safe (cons (if (pair V) (cons (car V) (cdr V)) (cons V (val V)))...
  %129 = inttoptr i64 %7 to i64*
  store i64 %128, i64* %129
; # (? (atom Z))
; # (atom Z)
  %130 = and i64 %126, 15
  %131 = icmp ne i64 %130, 0
  br i1 %131, label %$27, label %$26
$26:
  %132 = phi i64 [%124, %$25] ; # X
  %133 = phi i64 [%128, %$25] ; # R
  %134 = phi i64 [%126, %$25] ; # Z
  br label %$22
$27:
  %135 = phi i64 [%124, %$25] ; # X
  %136 = phi i64 [%128, %$25] ; # R
  %137 = phi i64 [%126, %$25] ; # Z
  %138 = phi i64 [0, %$25] ; # ->
  br label %$19
$20:
  %139 = phi i64 [%85, %$14] ; # X
  %140 = phi i64 [%81, %$14] ; # R
  %141 = phi i64 [%93, %$14] ; # Z
; # (nil? Z)
  %142 = icmp eq i64 %141, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %142, label %$28, label %$29
$29:
  %143 = phi i64 [%139, %$20] ; # X
  %144 = phi i64 [%140, %$20] ; # R
  %145 = phi i64 [%141, %$20] ; # Z
; # (++ X)
  %146 = inttoptr i64 %143 to i64*
  %147 = load i64, i64* %146
  %148 = getelementptr i64, i64* %146, i32 1
  %149 = load i64, i64* %148
; # (eval (++ X))
  %150 = and i64 %147, 6
  %151 = icmp ne i64 %150, 0
  br i1 %151, label %$32, label %$31
$32:
  br label %$30
$31:
  %152 = and i64 %147, 8
  %153 = icmp ne i64 %152, 0
  br i1 %153, label %$34, label %$33
$34:
  %154 = inttoptr i64 %147 to i64*
  %155 = load i64, i64* %154
  br label %$30
$33:
  %156 = call i64 @evList(i64 %147)
  br label %$30
$30:
  %157 = phi i64 [%147, %$32], [%155, %$34], [%156, %$33] ; # ->
; # (cons Z (eval (++ X)))
  %158 = call i64 @cons(i64 %145, i64 %157)
; # (cons (cons Z (eval (++ X))) R)
  %159 = call i64 @cons(i64 %158, i64 %144)
; # (safe (cons (cons Z (eval (++ X))) R))
  %160 = inttoptr i64 %7 to i64*
  store i64 %159, i64* %160
  br label %$19
$28:
  %161 = phi i64 [%139, %$20] ; # X
  %162 = phi i64 [%140, %$20] ; # R
  %163 = phi i64 [%141, %$20] ; # Z
  br label %$19
$19:
  %164 = phi i64 [%135, %$27], [%149, %$30], [%161, %$28] ; # X
  %165 = phi i64 [%136, %$27], [%159, %$30], [%162, %$28] ; # R
  %166 = phi i64 [%137, %$27], [%145, %$30], [%163, %$28] ; # Z
  %167 = phi i64 [%138, %$27], [%159, %$30], [0, %$28] ; # ->
; # (? (atom X))
; # (atom X)
  %168 = and i64 %164, 15
  %169 = icmp ne i64 %168, 0
  br i1 %169, label %$36, label %$35
$35:
  %170 = phi i64 [%164, %$19] ; # X
  %171 = phi i64 [%165, %$19] ; # R
  br label %$13
$36:
  %172 = phi i64 [%164, %$19] ; # X
  %173 = phi i64 [%165, %$19] ; # R
  %174 = phi i64 [0, %$19] ; # ->
  br label %$4
$4:
  %175 = phi i64 [%67, %$7], [%172, %$36] ; # X
  %176 = phi i64 [%68, %$7], [%173, %$36] ; # R
; # (drop *Safe)
  %177 = inttoptr i64 %7 to i64*
  %178 = getelementptr i64, i64* %177, i32 1
  %179 = load i64, i64* %178
  %180 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %179, i64* %180
  ret i64 %176
}

define i64 @_Trail(i64) align 8 {
$1:
; # (let (F (not (nil? (eval (cadr Exe)))) Bnd (val $Bind) R $Nil) (w...
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (nil? (eval (cadr Exe)))
  %14 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
; # (not (nil? (eval (cadr Exe))))
  %15 = icmp eq i1 %14, 0
; # (val $Bind)
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  %17 = load i64, i64* %16
; # (while Bnd (let S (val 2 Bnd) (cond ((== S $At) (when (val 4 Bnd)...
  br label %$7
$7:
  %18 = phi i64 [%17, %$2], [%55, %$10] ; # Bnd
  %19 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%52, %$10] ; # R
  %20 = icmp ne i64 %18, 0
  br i1 %20, label %$8, label %$9
$8:
  %21 = phi i64 [%18, %$7] ; # Bnd
  %22 = phi i64 [%19, %$7] ; # R
; # (let S (val 2 Bnd) (cond ((== S $At) (when (val 4 Bnd) (setq R (c...
; # (val 2 Bnd)
  %23 = inttoptr i64 %21 to i64*
  %24 = getelementptr i64, i64* %23, i32 1
  %25 = load i64, i64* %24
; # (cond ((== S $At) (when (val 4 Bnd) (setq R (cons @ R)))) (F (set...
; # (== S $At)
  %26 = icmp eq i64 %25, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64)
  br i1 %26, label %$12, label %$11
$12:
  %27 = phi i64 [%21, %$8] ; # Bnd
  %28 = phi i64 [%22, %$8] ; # R
; # (when (val 4 Bnd) (setq R (cons @ R)))
; # (val 4 Bnd)
  %29 = inttoptr i64 %27 to i64*
  %30 = getelementptr i64, i64* %29, i32 3
  %31 = load i64, i64* %30
  %32 = icmp ne i64 %31, 0
  br i1 %32, label %$13, label %$14
$13:
  %33 = phi i64 [%27, %$12] ; # Bnd
  %34 = phi i64 [%28, %$12] ; # R
; # (cons @ R)
  %35 = call i64 @cons(i64 %31, i64 %34)
  br label %$14
$14:
  %36 = phi i64 [%27, %$12], [%33, %$13] ; # Bnd
  %37 = phi i64 [%28, %$12], [%35, %$13] ; # R
  br label %$10
$11:
  %38 = phi i64 [%21, %$8] ; # Bnd
  %39 = phi i64 [%22, %$8] ; # R
  br i1 %15, label %$16, label %$15
$16:
  %40 = phi i64 [%38, %$11] ; # Bnd
  %41 = phi i64 [%39, %$11] ; # R
; # (val S)
  %42 = inttoptr i64 %25 to i64*
  %43 = load i64, i64* %42
; # (cons (val S) R)
  %44 = call i64 @cons(i64 %43, i64 %41)
; # (cons S (cons (val S) R))
  %45 = call i64 @cons(i64 %25, i64 %44)
; # (set S (val Bnd))
; # (val Bnd)
  %46 = inttoptr i64 %40 to i64*
  %47 = load i64, i64* %46
  %48 = inttoptr i64 %25 to i64*
  store i64 %47, i64* %48
  br label %$10
$15:
  %49 = phi i64 [%38, %$11] ; # Bnd
  %50 = phi i64 [%39, %$11] ; # R
  br label %$10
$10:
  %51 = phi i64 [%36, %$14], [%40, %$16], [%49, %$15] ; # Bnd
  %52 = phi i64 [%37, %$14], [%45, %$16], [%50, %$15] ; # R
; # (val 3 Bnd)
  %53 = inttoptr i64 %51 to i64*
  %54 = getelementptr i64, i64* %53, i32 2
  %55 = load i64, i64* %54
  br label %$7
$9:
  %56 = phi i64 [%18, %$7] ; # Bnd
  %57 = phi i64 [%19, %$7] ; # R
; # (let X R (until (atom X) (when (atom (++ X)) (set @ (++ X)))))
; # (until (atom X) (when (atom (++ X)) (set @ (++ X))))
  br label %$17
$17:
  %58 = phi i64 [%56, %$9], [%80, %$21] ; # Bnd
  %59 = phi i64 [%57, %$9], [%81, %$21] ; # R
  %60 = phi i64 [%57, %$9], [%82, %$21] ; # X
; # (atom X)
  %61 = and i64 %60, 15
  %62 = icmp ne i64 %61, 0
  br i1 %62, label %$19, label %$18
$18:
  %63 = phi i64 [%58, %$17] ; # Bnd
  %64 = phi i64 [%59, %$17] ; # R
  %65 = phi i64 [%60, %$17] ; # X
; # (when (atom (++ X)) (set @ (++ X)))
; # (++ X)
  %66 = inttoptr i64 %65 to i64*
  %67 = load i64, i64* %66
  %68 = getelementptr i64, i64* %66, i32 1
  %69 = load i64, i64* %68
; # (atom (++ X))
  %70 = and i64 %67, 15
  %71 = icmp ne i64 %70, 0
  br i1 %71, label %$20, label %$21
$20:
  %72 = phi i64 [%63, %$18] ; # Bnd
  %73 = phi i64 [%64, %$18] ; # R
  %74 = phi i64 [%69, %$18] ; # X
; # (set @ (++ X))
; # (++ X)
  %75 = inttoptr i64 %74 to i64*
  %76 = load i64, i64* %75
  %77 = getelementptr i64, i64* %75, i32 1
  %78 = load i64, i64* %77
  %79 = inttoptr i64 %67 to i64*
  store i64 %76, i64* %79
  br label %$21
$21:
  %80 = phi i64 [%63, %$18], [%72, %$20] ; # Bnd
  %81 = phi i64 [%64, %$18], [%73, %$20] ; # R
  %82 = phi i64 [%69, %$18], [%78, %$20] ; # X
  br label %$17
$19:
  %83 = phi i64 [%58, %$17] ; # Bnd
  %84 = phi i64 [%59, %$17] ; # R
  %85 = phi i64 [%60, %$17] ; # X
  ret i64 %84
}

define i64 @_Up(i64) align 8 {
$1:
; # (let (X (cdr Exe) Y (car X) N 1 Bnd (val $Bind)) (when (num? Y) (...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (car X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (val $Bind)
  %6 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 8) to i64) to i64*
  %7 = load i64, i64* %6
; # (when (num? Y) (setq N (int Y) Y (car (shift X))))
; # (num? Y)
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$2, label %$3
$2:
  %10 = phi i64 [%3, %$1] ; # X
  %11 = phi i64 [%5, %$1] ; # Y
  %12 = phi i64 [1, %$1] ; # N
  %13 = phi i64 [%7, %$1] ; # Bnd
; # (int Y)
  %14 = lshr i64 %11, 4
; # (shift X)
  %15 = inttoptr i64 %10 to i64*
  %16 = getelementptr i64, i64* %15, i32 1
  %17 = load i64, i64* %16
; # (car (shift X))
  %18 = inttoptr i64 %17 to i64*
  %19 = load i64, i64* %18
  br label %$3
$3:
  %20 = phi i64 [%3, %$1], [%17, %$2] ; # X
  %21 = phi i64 [%5, %$1], [%19, %$2] ; # Y
  %22 = phi i64 [1, %$1], [%14, %$2] ; # N
  %23 = phi i64 [%7, %$1], [%13, %$2] ; # Bnd
; # (if (nil? Y) (if N (loop (? (=0 Bnd) $Nil) (? (and (== $At (val 2...
; # (nil? Y)
  %24 = icmp eq i64 %21, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %24, label %$4, label %$5
$4:
  %25 = phi i64 [%20, %$3] ; # X
  %26 = phi i64 [%21, %$3] ; # Y
  %27 = phi i64 [%22, %$3] ; # N
  %28 = phi i64 [%23, %$3] ; # Bnd
; # (if N (loop (? (=0 Bnd) $Nil) (? (and (== $At (val 2 Bnd)) (=0 (d...
  %29 = icmp ne i64 %27, 0
  br i1 %29, label %$7, label %$8
$7:
  %30 = phi i64 [%25, %$4] ; # X
  %31 = phi i64 [%26, %$4] ; # Y
  %32 = phi i64 [%27, %$4] ; # N
  %33 = phi i64 [%28, %$4] ; # Bnd
; # (loop (? (=0 Bnd) $Nil) (? (and (== $At (val 2 Bnd)) (=0 (dec 'N)...
  br label %$10
$10:
  %34 = phi i64 [%30, %$7], [%83, %$16] ; # X
  %35 = phi i64 [%31, %$7], [%84, %$16] ; # Y
  %36 = phi i64 [%32, %$7], [%85, %$16] ; # N
  %37 = phi i64 [%33, %$7], [%89, %$16] ; # Bnd
; # (? (=0 Bnd) $Nil)
; # (=0 Bnd)
  %38 = icmp eq i64 %37, 0
  br i1 %38, label %$13, label %$11
$13:
  %39 = phi i64 [%34, %$10] ; # X
  %40 = phi i64 [%35, %$10] ; # Y
  %41 = phi i64 [%36, %$10] ; # N
  %42 = phi i64 [%37, %$10] ; # Bnd
  br label %$12
$11:
  %43 = phi i64 [%34, %$10] ; # X
  %44 = phi i64 [%35, %$10] ; # Y
  %45 = phi i64 [%36, %$10] ; # N
  %46 = phi i64 [%37, %$10] ; # Bnd
; # (? (and (== $At (val 2 Bnd)) (=0 (dec 'N))) (if (val 4 Bnd) @ $Ni...
; # (and (== $At (val 2 Bnd)) (=0 (dec 'N)))
; # (val 2 Bnd)
  %47 = inttoptr i64 %46 to i64*
  %48 = getelementptr i64, i64* %47, i32 1
  %49 = load i64, i64* %48
; # (== $At (val 2 Bnd))
  %50 = icmp eq i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 440) to i64), %49
  br i1 %50, label %$15, label %$14
$15:
  %51 = phi i64 [%43, %$11] ; # X
  %52 = phi i64 [%44, %$11] ; # Y
  %53 = phi i64 [%45, %$11] ; # N
  %54 = phi i64 [%46, %$11] ; # Bnd
; # (dec 'N)
  %55 = sub i64 %53, 1
; # (=0 (dec 'N))
  %56 = icmp eq i64 %55, 0
  br label %$14
$14:
  %57 = phi i64 [%43, %$11], [%51, %$15] ; # X
  %58 = phi i64 [%44, %$11], [%52, %$15] ; # Y
  %59 = phi i64 [%45, %$11], [%55, %$15] ; # N
  %60 = phi i64 [%46, %$11], [%54, %$15] ; # Bnd
  %61 = phi i1 [0, %$11], [%56, %$15] ; # ->
  br i1 %61, label %$17, label %$16
$17:
  %62 = phi i64 [%57, %$14] ; # X
  %63 = phi i64 [%58, %$14] ; # Y
  %64 = phi i64 [%59, %$14] ; # N
  %65 = phi i64 [%60, %$14] ; # Bnd
; # (if (val 4 Bnd) @ $Nil)
; # (val 4 Bnd)
  %66 = inttoptr i64 %65 to i64*
  %67 = getelementptr i64, i64* %66, i32 3
  %68 = load i64, i64* %67
  %69 = icmp ne i64 %68, 0
  br i1 %69, label %$18, label %$19
$18:
  %70 = phi i64 [%62, %$17] ; # X
  %71 = phi i64 [%63, %$17] ; # Y
  %72 = phi i64 [%64, %$17] ; # N
  %73 = phi i64 [%65, %$17] ; # Bnd
  br label %$20
$19:
  %74 = phi i64 [%62, %$17] ; # X
  %75 = phi i64 [%63, %$17] ; # Y
  %76 = phi i64 [%64, %$17] ; # N
  %77 = phi i64 [%65, %$17] ; # Bnd
  br label %$20
$20:
  %78 = phi i64 [%70, %$18], [%74, %$19] ; # X
  %79 = phi i64 [%71, %$18], [%75, %$19] ; # Y
  %80 = phi i64 [%72, %$18], [%76, %$19] ; # N
  %81 = phi i64 [%73, %$18], [%77, %$19] ; # Bnd
  %82 = phi i64 [%68, %$18], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$19] ; # ->
  br label %$12
$16:
  %83 = phi i64 [%57, %$14] ; # X
  %84 = phi i64 [%58, %$14] ; # Y
  %85 = phi i64 [%59, %$14] ; # N
  %86 = phi i64 [%60, %$14] ; # Bnd
; # (val 3 Bnd)
  %87 = inttoptr i64 %86 to i64*
  %88 = getelementptr i64, i64* %87, i32 2
  %89 = load i64, i64* %88
  br label %$10
$12:
  %90 = phi i64 [%39, %$13], [%78, %$20] ; # X
  %91 = phi i64 [%40, %$13], [%79, %$20] ; # Y
  %92 = phi i64 [%41, %$13], [%80, %$20] ; # N
  %93 = phi i64 [%42, %$13], [%81, %$20] ; # Bnd
  %94 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$13], [%82, %$20] ; # ->
  br label %$9
$8:
  %95 = phi i64 [%25, %$4] ; # X
  %96 = phi i64 [%26, %$4] ; # Y
  %97 = phi i64 [%27, %$4] ; # N
  %98 = phi i64 [%28, %$4] ; # Bnd
  br label %$9
$9:
  %99 = phi i64 [%90, %$12], [%95, %$8] ; # X
  %100 = phi i64 [%91, %$12], [%96, %$8] ; # Y
  %101 = phi i64 [%92, %$12], [%97, %$8] ; # N
  %102 = phi i64 [%93, %$12], [%98, %$8] ; # Bnd
  %103 = phi i64 [%94, %$12], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # ->
  br label %$6
$5:
  %104 = phi i64 [%20, %$3] ; # X
  %105 = phi i64 [%21, %$3] ; # Y
  %106 = phi i64 [%22, %$3] ; # N
  %107 = phi i64 [%23, %$3] ; # Bnd
; # (let Z Y (when N (loop (? (=0 Bnd)) (? (and (== Y (val 2 Bnd)) (p...
; # (when N (loop (? (=0 Bnd)) (? (and (== Y (val 2 Bnd)) (prog (setq...
  %108 = icmp ne i64 %106, 0
  br i1 %108, label %$21, label %$22
$21:
  %109 = phi i64 [%104, %$5] ; # X
  %110 = phi i64 [%105, %$5] ; # Y
  %111 = phi i64 [%106, %$5] ; # N
  %112 = phi i64 [%107, %$5] ; # Bnd
  %113 = phi i64 [%105, %$5] ; # Z
; # (loop (? (=0 Bnd)) (? (and (== Y (val 2 Bnd)) (prog (setq Z Bnd) ...
  br label %$23
$23:
  %114 = phi i64 [%109, %$21], [%142, %$28] ; # X
  %115 = phi i64 [%110, %$21], [%143, %$28] ; # Y
  %116 = phi i64 [%111, %$21], [%144, %$28] ; # N
  %117 = phi i64 [%112, %$21], [%149, %$28] ; # Bnd
  %118 = phi i64 [%113, %$21], [%146, %$28] ; # Z
; # (? (=0 Bnd))
; # (=0 Bnd)
  %119 = icmp eq i64 %117, 0
  br i1 %119, label %$25, label %$24
$24:
  %120 = phi i64 [%114, %$23] ; # X
  %121 = phi i64 [%115, %$23] ; # Y
  %122 = phi i64 [%116, %$23] ; # N
  %123 = phi i64 [%117, %$23] ; # Bnd
  %124 = phi i64 [%118, %$23] ; # Z
; # (? (and (== Y (val 2 Bnd)) (prog (setq Z Bnd) (=0 (dec 'N)))))
; # (and (== Y (val 2 Bnd)) (prog (setq Z Bnd) (=0 (dec 'N))))
; # (val 2 Bnd)
  %125 = inttoptr i64 %123 to i64*
  %126 = getelementptr i64, i64* %125, i32 1
  %127 = load i64, i64* %126
; # (== Y (val 2 Bnd))
  %128 = icmp eq i64 %121, %127
  br i1 %128, label %$27, label %$26
$27:
  %129 = phi i64 [%120, %$24] ; # X
  %130 = phi i64 [%121, %$24] ; # Y
  %131 = phi i64 [%122, %$24] ; # N
  %132 = phi i64 [%123, %$24] ; # Bnd
  %133 = phi i64 [%124, %$24] ; # Z
; # (dec 'N)
  %134 = sub i64 %131, 1
; # (=0 (dec 'N))
  %135 = icmp eq i64 %134, 0
  br label %$26
$26:
  %136 = phi i64 [%120, %$24], [%129, %$27] ; # X
  %137 = phi i64 [%121, %$24], [%130, %$27] ; # Y
  %138 = phi i64 [%122, %$24], [%134, %$27] ; # N
  %139 = phi i64 [%123, %$24], [%132, %$27] ; # Bnd
  %140 = phi i64 [%124, %$24], [%132, %$27] ; # Z
  %141 = phi i1 [0, %$24], [%135, %$27] ; # ->
  br i1 %141, label %$25, label %$28
$28:
  %142 = phi i64 [%136, %$26] ; # X
  %143 = phi i64 [%137, %$26] ; # Y
  %144 = phi i64 [%138, %$26] ; # N
  %145 = phi i64 [%139, %$26] ; # Bnd
  %146 = phi i64 [%140, %$26] ; # Z
; # (val 3 Bnd)
  %147 = inttoptr i64 %145 to i64*
  %148 = getelementptr i64, i64* %147, i32 2
  %149 = load i64, i64* %148
  br label %$23
$25:
  %150 = phi i64 [%114, %$23], [%136, %$26] ; # X
  %151 = phi i64 [%115, %$23], [%137, %$26] ; # Y
  %152 = phi i64 [%116, %$23], [%138, %$26] ; # N
  %153 = phi i64 [%117, %$23], [%139, %$26] ; # Bnd
  %154 = phi i64 [%118, %$23], [%140, %$26] ; # Z
  %155 = phi i64 [0, %$23], [0, %$26] ; # ->
  br label %$22
$22:
  %156 = phi i64 [%104, %$5], [%150, %$25] ; # X
  %157 = phi i64 [%105, %$5], [%151, %$25] ; # Y
  %158 = phi i64 [%106, %$5], [%152, %$25] ; # N
  %159 = phi i64 [%107, %$5], [%153, %$25] ; # Bnd
  %160 = phi i64 [%105, %$5], [%154, %$25] ; # Z
; # (if (atom (shift X)) (val Z) (set Z (eval (car X))))
; # (shift X)
  %161 = inttoptr i64 %156 to i64*
  %162 = getelementptr i64, i64* %161, i32 1
  %163 = load i64, i64* %162
; # (atom (shift X))
  %164 = and i64 %163, 15
  %165 = icmp ne i64 %164, 0
  br i1 %165, label %$29, label %$30
$29:
  %166 = phi i64 [%163, %$22] ; # X
  %167 = phi i64 [%157, %$22] ; # Y
  %168 = phi i64 [%158, %$22] ; # N
  %169 = phi i64 [%159, %$22] ; # Bnd
  %170 = phi i64 [%160, %$22] ; # Z
; # (val Z)
  %171 = inttoptr i64 %170 to i64*
  %172 = load i64, i64* %171
  br label %$31
$30:
  %173 = phi i64 [%163, %$22] ; # X
  %174 = phi i64 [%157, %$22] ; # Y
  %175 = phi i64 [%158, %$22] ; # N
  %176 = phi i64 [%159, %$22] ; # Bnd
  %177 = phi i64 [%160, %$22] ; # Z
; # (set Z (eval (car X)))
; # (car X)
  %178 = inttoptr i64 %173 to i64*
  %179 = load i64, i64* %178
; # (eval (car X))
  %180 = and i64 %179, 6
  %181 = icmp ne i64 %180, 0
  br i1 %181, label %$34, label %$33
$34:
  br label %$32
$33:
  %182 = and i64 %179, 8
  %183 = icmp ne i64 %182, 0
  br i1 %183, label %$36, label %$35
$36:
  %184 = inttoptr i64 %179 to i64*
  %185 = load i64, i64* %184
  br label %$32
$35:
  %186 = call i64 @evList(i64 %179)
  br label %$32
$32:
  %187 = phi i64 [%179, %$34], [%185, %$36], [%186, %$35] ; # ->
  %188 = inttoptr i64 %177 to i64*
  store i64 %187, i64* %188
  br label %$31
$31:
  %189 = phi i64 [%166, %$29], [%173, %$32] ; # X
  %190 = phi i64 [%167, %$29], [%174, %$32] ; # Y
  %191 = phi i64 [%168, %$29], [%175, %$32] ; # N
  %192 = phi i64 [%169, %$29], [%176, %$32] ; # Bnd
  %193 = phi i64 [%170, %$29], [%177, %$32] ; # Z
  %194 = phi i64 [%172, %$29], [%187, %$32] ; # ->
  br label %$6
$6:
  %195 = phi i64 [%99, %$9], [%189, %$31] ; # X
  %196 = phi i64 [%100, %$9], [%190, %$31] ; # Y
  %197 = phi i64 [%101, %$9], [%191, %$31] ; # N
  %198 = phi i64 [%102, %$9], [%192, %$31] ; # Bnd
  %199 = phi i64 [%103, %$9], [%194, %$31] ; # ->
  ret i64 %199
}

define i64 @_History(i64) align 8 {
$1:
; # (let X (cdr Exe) (if (atom X) (let P (history_list) (if (and P (v...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (if (atom X) (let P (history_list) (if (and P (val P)) (let (Y (c...
; # (atom X)
  %4 = and i64 %3, 15
  %5 = icmp ne i64 %4, 0
  br i1 %5, label %$2, label %$3
$2:
; # (let P (history_list) (if (and P (val P)) (let (Y (cons (mkStr (v...
; # (history_list)
  %6 = call i8*** @history_list()
; # (if (and P (val P)) (let (Y (cons (mkStr (val (val P))) $Nil) R (...
; # (and P (val P))
  %7 = icmp ne i8*** %6, null
  br i1 %7, label %$6, label %$5
$6:
; # (val P)
  %8 = load i8**, i8*** %6
  %9 = icmp ne i8** %8, null
  br label %$5
$5:
  %10 = phi i1 [0, %$2], [%9, %$6] ; # ->
  br i1 %10, label %$7, label %$8
$7:
; # (let (Y (cons (mkStr (val (val P))) $Nil) R (save Y) I 0) (while ...
; # (val P)
  %11 = load i8**, i8*** %6
; # (val (val P))
  %12 = load i8*, i8** %11
; # (mkStr (val (val P)))
  %13 = call i64 @mkStr(i8* %12)
; # (cons (mkStr (val (val P))) $Nil)
  %14 = call i64 @cons(i64 %13, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (save Y)
  %15 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %16 = load i64, i64* %15
  %17 = alloca i64, i64 2, align 16
  %18 = ptrtoint i64* %17 to i64
  %19 = inttoptr i64 %18 to i64*
  store i64 %14, i64* %19
  %20 = add i64 %18, 8
  %21 = inttoptr i64 %20 to i64*
  store i64 %16, i64* %21
  %22 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %18, i64* %22
; # (while (val (ofs P (inc 'I))) (setq Y (set 2 Y (cons (mkStr (val ...
  br label %$10
$10:
  %23 = phi i64 [%14, %$7], [%33, %$11] ; # Y
  %24 = phi i64 [0, %$7], [%30, %$11] ; # I
; # (inc 'I)
  %25 = add i64 %24, 1
; # (ofs P (inc 'I))
  %26 = getelementptr i8**, i8*** %6, i64 %25
; # (val (ofs P (inc 'I)))
  %27 = load i8**, i8*** %26
  %28 = icmp ne i8** %27, null
  br i1 %28, label %$11, label %$12
$11:
  %29 = phi i64 [%23, %$10] ; # Y
  %30 = phi i64 [%25, %$10] ; # I
; # (set 2 Y (cons (mkStr (val @)) $Nil))
; # (val @)
  %31 = load i8*, i8** %27
; # (mkStr (val @))
  %32 = call i64 @mkStr(i8* %31)
; # (cons (mkStr (val @)) $Nil)
  %33 = call i64 @cons(i64 %32, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %34 = inttoptr i64 %29 to i64*
  %35 = getelementptr i64, i64* %34, i32 1
  store i64 %33, i64* %35
  br label %$10
$12:
  %36 = phi i64 [%23, %$10] ; # Y
  %37 = phi i64 [%25, %$10] ; # I
; # (drop *Safe)
  %38 = inttoptr i64 %18 to i64*
  %39 = getelementptr i64, i64* %38, i32 1
  %40 = load i64, i64* %39
  %41 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %40, i64* %41
  br label %$9
$8:
  br label %$9
$9:
  %42 = phi i64 [%14, %$12], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # ->
  br label %$4
$3:
; # (let (Y (needLst Exe (eval (car X))) Z Y) (clear_history) (while ...
; # (car X)
  %43 = inttoptr i64 %3 to i64*
  %44 = load i64, i64* %43
; # (eval (car X))
  %45 = and i64 %44, 6
  %46 = icmp ne i64 %45, 0
  br i1 %46, label %$15, label %$14
$15:
  br label %$13
$14:
  %47 = and i64 %44, 8
  %48 = icmp ne i64 %47, 0
  br i1 %48, label %$17, label %$16
$17:
  %49 = inttoptr i64 %44 to i64*
  %50 = load i64, i64* %49
  br label %$13
$16:
  %51 = call i64 @evList(i64 %44)
  br label %$13
$13:
  %52 = phi i64 [%44, %$15], [%50, %$17], [%51, %$16] ; # ->
; # (needLst Exe (eval (car X)))
  %53 = and i64 %52, 15
  %54 = icmp eq i64 %53, 0
  br i1 %54, label %$18, label %$19
$19:
  %55 = icmp eq i64 %52, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br label %$18
$18:
  %56 = phi i1 [1, %$13], [%55, %$19] ; # ->
  br i1 %56, label %$21, label %$20
$20:
  call void @lstErr(i64 %0, i64 %52)
  unreachable
$21:
; # (clear_history)
  call void @clear_history()
; # (while (pair Z) (let (Nm (xName (xSym (++ Z))) Stk (stack)) (add_...
  br label %$22
$22:
  %57 = phi i64 [%52, %$21], [%64, %$23] ; # Z
; # (pair Z)
  %58 = and i64 %57, 15
  %59 = icmp eq i64 %58, 0
  br i1 %59, label %$23, label %$24
$23:
  %60 = phi i64 [%57, %$22] ; # Z
; # (let (Nm (xName (xSym (++ Z))) Stk (stack)) (add_history (bufStri...
; # (++ Z)
  %61 = inttoptr i64 %60 to i64*
  %62 = load i64, i64* %61
  %63 = getelementptr i64, i64* %61, i32 1
  %64 = load i64, i64* %63
; # (xSym (++ Z))
  %65 = call i64 @xSym(i64 %62)
; # (xName (xSym (++ Z)))
  %66 = call i64 @xName(i64 %65)
; # (stack)
  %67 = call i8* @llvm.stacksave()
; # (bufSize Nm)
  %68 = call i64 @bufSize(i64 %66)
; # (b8 (bufSize Nm))
  %69 = alloca i8, i64 %68
; # (bufString Nm (b8 (bufSize Nm)))
  %70 = call i8* @bufString(i64 %66, i8* %69)
; # (add_history (bufString Nm (b8 (bufSize Nm))))
  call void @add_history(i8* %70)
; # (stack Stk)
  call void @llvm.stackrestore(i8* %67)
  br label %$22
$24:
  %71 = phi i64 [%57, %$22] ; # Z
  br label %$4
$4:
  %72 = phi i64 [%42, %$9], [%52, %$24] ; # ->
  ret i64 %72
}

define i64 @_Version(i64) align 8 {
$1:
; # (when (nil? (eval (cadr Exe))) (outWord (int (val $Y))) (call $Pu...
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (nil? (eval (cadr Exe)))
  %14 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %14, label %$7, label %$8
$7:
; # (val $Y)
  %15 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([3 x i64]* @$Version to i8*), i32 0) to i64) to i64*
  %16 = load i64, i64* %15
; # (int (val $Y))
  %17 = lshr i64 %16, 4
; # (outWord (int (val $Y)))
  call void @outWord(i64 %17)
; # (call $Put (char "."))
  %18 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %18(i8 46)
; # (val $M)
  %19 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([3 x i64]* @$Version to i8*), i32 8) to i64) to i64*
  %20 = load i64, i64* %19
; # (int (val $M))
  %21 = lshr i64 %20, 4
; # (outWord (int (val $M)))
  call void @outWord(i64 %21)
; # (call $Put (char "."))
  %22 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %22(i8 46)
; # (val $D)
  %23 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([3 x i64]* @$Version to i8*), i32 16) to i64) to i64*
  %24 = load i64, i64* %23
; # (int (val $D))
  %25 = lshr i64 %24, 4
; # (outWord (int (val $D)))
  call void @outWord(i64 %25)
; # (newline)
  call void @newline()
  br label %$8
$8:
; # (val $Y)
  %26 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([3 x i64]* @$Version to i8*), i32 0) to i64) to i64*
  %27 = load i64, i64* %26
; # (val $M)
  %28 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([3 x i64]* @$Version to i8*), i32 8) to i64) to i64*
  %29 = load i64, i64* %28
; # (val $D)
  %30 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([3 x i64]* @$Version to i8*), i32 16) to i64) to i64*
  %31 = load i64, i64* %30
; # (cons (val $D) $Nil)
  %32 = call i64 @cons(i64 %31, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (cons (val $M) (cons (val $D) $Nil))
  %33 = call i64 @cons(i64 %29, i64 %32)
; # (cons (val $Y) (cons (val $M) (cons (val $D) $Nil)))
  %34 = call i64 @cons(i64 %27, i64 %33)
  ret i64 %34
}

define i32 @main(i32, i8**) align 8 {
$1:
; # (set $AV0 (val Av) $AV (setq Av (ofs Av 1)) $StkLimit (ulimStk))
; # (val Av)
  %2 = load i8*, i8** %1
  store i8* %2, i8** @$AV0
; # (ofs Av 1)
  %3 = getelementptr i8*, i8** %1, i32 1
  store i8** %3, i8*** @$AV
; # (ulimStk)
  %4 = call i8* @ulimStk()
  store i8* %4, i8** @$StkLimit
; # (let P (ofs Av (- Ac 2)) (unless (strcmp (val P) ($ "+")) (set $D...
; # (- Ac 2)
  %5 = sub i32 %0, 2
; # (ofs Av (- Ac 2))
  %6 = getelementptr i8*, i8** %3, i32 %5
; # (unless (strcmp (val P) ($ "+")) (set $Dbg $T P null))
; # (val P)
  %7 = load i8*, i8** %6
; # (strcmp (val P) ($ "+"))
  %8 = call i32 @strcmp(i8* %7, i8* bitcast ([2 x i8]* @$95 to i8*))
  %9 = icmp ne i32 %8, 0
  br i1 %9, label %$3, label %$2
$2:
  %10 = phi i8** [%3, %$1] ; # Av
; # (set $Dbg $T P null)
  %11 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 824) to i64) to i64*
  store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), i64* %11
  store i8* null, i8** %6
  br label %$3
$3:
  %12 = phi i8** [%3, %$1], [%10, %$2] ; # Av
; # (let P (val Av) (when (and P (<> (val P) (char "-"))) (let Q (str...
; # (val Av)
  %13 = load i8*, i8** %12
; # (when (and P (<> (val P) (char "-"))) (let Q (strrchr P (char "/"...
; # (and P (<> (val P) (char "-")))
  %14 = icmp ne i8* %13, null
  br i1 %14, label %$5, label %$4
$5:
  %15 = phi i8** [%12, %$3] ; # Av
; # (val P)
  %16 = load i8, i8* %13
; # (<> (val P) (char "-"))
  %17 = icmp ne i8 %16, 45
  br label %$4
$4:
  %18 = phi i8** [%12, %$3], [%15, %$5] ; # Av
  %19 = phi i1 [0, %$3], [%17, %$5] ; # ->
  br i1 %19, label %$6, label %$7
$6:
  %20 = phi i8** [%18, %$4] ; # Av
; # (let Q (strrchr P (char "/")) (unless (or (=0 Q) (and (== Q (+ P ...
; # (strrchr P (char "/"))
  %21 = call i8* @strrchr(i8* %13, i32 47)
; # (unless (or (=0 Q) (and (== Q (+ P 1)) (== (val P) (char ".")))) ...
; # (or (=0 Q) (and (== Q (+ P 1)) (== (val P) (char "."))))
; # (=0 Q)
  %22 = icmp eq i8* %21, null
  br i1 %22, label %$8, label %$9
$9:
  %23 = phi i8** [%20, %$6] ; # Av
; # (and (== Q (+ P 1)) (== (val P) (char ".")))
; # (+ P 1)
  %24 = getelementptr i8, i8* %13, i32 1
; # (== Q (+ P 1))
  %25 = icmp eq i8* %21, %24
  br i1 %25, label %$11, label %$10
$11:
  %26 = phi i8** [%23, %$9] ; # Av
; # (val P)
  %27 = load i8, i8* %13
; # (== (val P) (char "."))
  %28 = icmp eq i8 %27, 46
  br label %$10
$10:
  %29 = phi i8** [%23, %$9], [%26, %$11] ; # Av
  %30 = phi i1 [0, %$9], [%28, %$11] ; # ->
  br label %$8
$8:
  %31 = phi i8** [%20, %$6], [%29, %$10] ; # Av
  %32 = phi i1 [1, %$6], [%30, %$10] ; # ->
  br i1 %32, label %$13, label %$12
$12:
  %33 = phi i8** [%31, %$8] ; # Av
; # (let (N (+ (- Q P) 1) H (malloc (+ N 1))) (set $PilHome H $PilLen...
; # (- Q P)
  %34 = ptrtoint i8* %21 to i64
  %35 = ptrtoint i8* %13 to i64
  %36 = sub i64 %34, %35
; # (+ (- Q P) 1)
  %37 = add i64 %36, 1
; # (+ N 1)
  %38 = add i64 %37, 1
; # (malloc (+ N 1))
  %39 = call i8* @malloc(i64 %38)
; # (set $PilHome H $PilLen N)
  store i8* %39, i8** @$PilHome
  store i64 %37, i64* @$PilLen
; # (memcpy H P N)
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* %39, i8* %13, i64 %37, i1 0)
; # (set (ofs H N) 0)
; # (ofs H N)
  %40 = getelementptr i8, i8* %39, i64 %37
  store i8 0, i8* %40
  br label %$13
$13:
  %41 = phi i8** [%31, %$8], [%33, %$12] ; # Av
  br label %$7
$7:
  %42 = phi i8** [%18, %$4], [%41, %$13] ; # Av
; # (when (getenv ($ "HOME")) (set $UsrHome @ $UsrLen (strlen @)))
; # (getenv ($ "HOME"))
  %43 = call i8* @getenv(i8* bitcast ([5 x i8]* @$96 to i8*))
  %44 = icmp ne i8* %43, null
  br i1 %44, label %$14, label %$15
$14:
  %45 = phi i8** [%42, %$7] ; # Av
; # (set $UsrHome @ $UsrLen (strlen @))
  store i8* %43, i8** @$UsrHome
; # (strlen @)
  %46 = call i64 @strlen(i8* %43)
  store i64 %46, i64* @$UsrLen
  br label %$15
$15:
  %47 = phi i8** [%42, %$7], [%45, %$14] ; # Av
; # (heapAlloc)
  call void @heapAlloc()
; # (let P $Nil (loop (let Nm (val (tail P)) (when (num? Nm) (intern ...
; # (loop (let Nm (val (tail P)) (when (num? Nm) (intern P 0 @ (cdr $...
  br label %$16
$16:
  %48 = phi i8** [%47, %$15], [%71, %$18] ; # Av
  %49 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$15], [%73, %$18] ; # P
; # (let Nm (val (tail P)) (when (num? Nm) (intern P 0 @ (cdr $Pico) ...
; # (tail P)
  %50 = add i64 %49, -8
; # (val (tail P))
  %51 = inttoptr i64 %50 to i64*
  %52 = load i64, i64* %51
; # (when (num? Nm) (intern P 0 @ (cdr $Pico) $Nil NO) (? (== P $Last...
; # (num? Nm)
  %53 = and i64 %52, 6
  %54 = icmp ne i64 %53, 0
  br i1 %54, label %$17, label %$18
$17:
  %55 = phi i8** [%48, %$16] ; # Av
  %56 = phi i64 [%49, %$16] ; # P
; # (cdr $Pico)
  %57 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 64) to i64) to i64*
  %58 = getelementptr i64, i64* %57, i32 1
  %59 = load i64, i64* %58
; # (intern P 0 @ (cdr $Pico) $Nil NO)
  %60 = call i64 @intern(i64 %56, i64 0, i64 %52, i64 %59, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), i1 0)
; # (? (== P $LastSym))
; # (== P $LastSym)
  %61 = icmp eq i64 %56, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 7096) to i64)
  br i1 %61, label %$20, label %$19
$19:
  %62 = phi i8** [%55, %$17] ; # Av
  %63 = phi i64 [%56, %$17] ; # P
; # (when (big? Nm) (setq P (ofs P 2)))
; # (big? Nm)
  %64 = and i64 %52, 4
  %65 = icmp ne i64 %64, 0
  br i1 %65, label %$21, label %$22
$21:
  %66 = phi i8** [%62, %$19] ; # Av
  %67 = phi i64 [%63, %$19] ; # P
; # (ofs P 2)
  %68 = add i64 %67, 16
  br label %$22
$22:
  %69 = phi i8** [%62, %$19], [%66, %$21] ; # Av
  %70 = phi i64 [%63, %$19], [%68, %$21] ; # P
  br label %$18
$18:
  %71 = phi i8** [%48, %$16], [%69, %$22] ; # Av
  %72 = phi i64 [%49, %$16], [%70, %$22] ; # P
; # (ofs P 2)
  %73 = add i64 %72, 16
  br label %$16
$20:
  %74 = phi i8** [%55, %$17] ; # Av
  %75 = phi i64 [%56, %$17] ; # P
  %76 = phi i64 [0, %$17] ; # ->
; # (set $OS (mkStr TgOS) $CPU (mkStr TgCPU) $Pid (cnt (i64 (getpid))...
; # (mkStr TgOS)
  %77 = call i64 @mkStr(i8* @TgOS)
  %78 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 168) to i64) to i64*
  store i64 %77, i64* %78
; # (mkStr TgCPU)
  %79 = call i64 @mkStr(i8* @TgCPU)
  %80 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 184) to i64) to i64*
  store i64 %79, i64* %80
; # (getpid)
  %81 = call i32 @getpid()
; # (i64 (getpid))
  %82 = sext i32 %81 to i64
; # (cnt (i64 (getpid)))
  %83 = shl i64 %82, 4
  %84 = or i64 %83, 2
  %85 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 200) to i64) to i64*
  store i64 %84, i64* %85
; # (tail $Db1)
  %86 = add i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 408) to i64), -8
  %87 = inttoptr i64 %86 to i64*
  store i64 26, i64* %87
; # (cons $Db1 $Nil)
  %88 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 408) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  store i64 %88, i64* @$Extern
; # (b8+ (ioFrame T))
  %89 = alloca i8, i64 28, align 8
; # (initOutFile 2)
  %90 = call i8* @initOutFile(i32 2)
; # (pushOutFile (b8+ (ioFrame T)) (initOutFile 2) 0)
  call void @pushOutFile(i8* %89, i8* %90, i32 0)
; # (set $Stdout (b8+ (ioFrame T)))
; # (b8+ (ioFrame T))
  %91 = alloca i8, i64 28, align 8
  store i8* %91, i8** @$Stdout
; # (initOutFile 1)
  %92 = call i8* @initOutFile(i32 1)
; # (pushOutFile (set $Stdout (b8+ (ioFrame T))) (initOutFile 1) 0)
  call void @pushOutFile(i8* %91, i8* %92, i32 0)
; # (set $Stdin (b8+ (ioFrame T)))
; # (b8+ (ioFrame T))
  %93 = alloca i8, i64 28, align 8
  store i8* %93, i8** @$Stdin
; # (initInFile 0 null)
  %94 = call i8* @initInFile(i32 0, i8* null)
; # (pushInFile (set $Stdin (b8+ (ioFrame T))) (initInFile 0 null) 0)...
  call void @pushInFile(i8* %93, i8* %94, i32 0)
; # (set Tio (=0 (tcgetattr 0 OrgTermio)))
; # (tcgetattr 0 OrgTermio)
  %95 = call i32 @tcgetattr(i32 0, i8* @OrgTermio)
; # (=0 (tcgetattr 0 OrgTermio))
  %96 = icmp eq i32 %95, 0
  store i1 %96, i1* @Tio
; # (sigUnblock 0)
  call void @sigUnblock(i32 0)
; # (val SIGHUP Sig)
  %97 = getelementptr i32, i32* @Sig, i32 0
  %98 = load i32, i32* %97
; # (fun sig)
; # (i8* (def (pico~pack "@" (pico~car cross~Args)) (func (; cross~Ar...
  %99 = bitcast void(i32)* @sig to i8*
; # (iSignal (val SIGHUP Sig) (fun sig))
  call void @iSignal(i32 %98, i8* %99)
; # (val SIGUSR1 Sig)
  %100 = getelementptr i32, i32* @Sig, i32 2
  %101 = load i32, i32* %100
; # (fun sig)
; # (i8* (def (pico~pack "@" (pico~car cross~Args)) (func (; cross~Ar...
  %102 = bitcast void(i32)* @sig to i8*
; # (iSignal (val SIGUSR1 Sig) (fun sig))
  call void @iSignal(i32 %101, i8* %102)
; # (val SIGUSR2 Sig)
  %103 = getelementptr i32, i32* @Sig, i32 3
  %104 = load i32, i32* %103
; # (fun sig)
; # (i8* (def (pico~pack "@" (pico~car cross~Args)) (func (; cross~Ar...
  %105 = bitcast void(i32)* @sig to i8*
; # (iSignal (val SIGUSR2 Sig) (fun sig))
  call void @iSignal(i32 %104, i8* %105)
; # (val SIGALRM Sig)
  %106 = getelementptr i32, i32* @Sig, i32 5
  %107 = load i32, i32* %106
; # (fun sig)
; # (i8* (def (pico~pack "@" (pico~car cross~Args)) (func (; cross~Ar...
  %108 = bitcast void(i32)* @sig to i8*
; # (iSignal (val SIGALRM Sig) (fun sig))
  call void @iSignal(i32 %107, i8* %108)
; # (val SIGTERM Sig)
  %109 = getelementptr i32, i32* @Sig, i32 6
  %110 = load i32, i32* %109
; # (fun sig)
; # (i8* (def (pico~pack "@" (pico~car cross~Args)) (func (; cross~Ar...
  %111 = bitcast void(i32)* @sig to i8*
; # (iSignal (val SIGTERM Sig) (fun sig))
  call void @iSignal(i32 %110, i8* %111)
; # (val SIGWINCH Sig)
  %112 = getelementptr i32, i32* @Sig, i32 13
  %113 = load i32, i32* %112
; # (fun sig)
; # (i8* (def (pico~pack "@" (pico~car cross~Args)) (func (; cross~Ar...
  %114 = bitcast void(i32)* @sig to i8*
; # (iSignal (val SIGWINCH Sig) (fun sig))
  call void @iSignal(i32 %113, i8* %114)
; # (val SIGIO Sig)
  %115 = getelementptr i32, i32* @Sig, i32 14
  %116 = load i32, i32* %115
; # (fun sig)
; # (i8* (def (pico~pack "@" (pico~car cross~Args)) (func (; cross~Ar...
  %117 = bitcast void(i32)* @sig to i8*
; # (iSignal (val SIGIO Sig) (fun sig))
  call void @iSignal(i32 %116, i8* %117)
; # (when (== (signal (val SIGTSTP Sig) (val SigIgn)) (val SigDfl)) (...
; # (val SIGTSTP Sig)
  %118 = getelementptr i32, i32* @Sig, i32 10
  %119 = load i32, i32* %118
; # (val SigIgn)
  %120 = load i8*, i8** @SigIgn
; # (signal (val SIGTSTP Sig) (val SigIgn))
  %121 = call i8* @signal(i32 %119, i8* %120)
; # (val SigDfl)
  %122 = load i8*, i8** @SigDfl
; # (== (signal (val SIGTSTP Sig) (val SigIgn)) (val SigDfl))
  %123 = icmp eq i8* %121, %122
  br i1 %123, label %$23, label %$24
$23:
  %124 = phi i8** [%74, %$20] ; # Av
; # (val SIGTSTP Sig)
  %125 = getelementptr i32, i32* @Sig, i32 10
  %126 = load i32, i32* %125
; # (fun sig)
; # (i8* (def (pico~pack "@" (pico~car cross~Args)) (func (; cross~Ar...
  %127 = bitcast void(i32)* @sig to i8*
; # (iSignal (val SIGTSTP Sig) (fun sig))
  call void @iSignal(i32 %126, i8* %127)
  br label %$24
$24:
  %128 = phi i8** [%74, %$20], [%124, %$23] ; # Av
; # (val SIGINT Sig)
  %129 = getelementptr i32, i32* @Sig, i32 1
  %130 = load i32, i32* %129
; # (fun sigTerm)
; # (i8* (def (pico~pack "@" (pico~car cross~Args)) (func (; cross~Ar...
  %131 = bitcast void(i32)* @sigTerm to i8*
; # (iSignal (val SIGINT Sig) (fun sigTerm))
  call void @iSignal(i32 %130, i8* %131)
; # (val SIGCHLD Sig)
  %132 = getelementptr i32, i32* @Sig, i32 7
  %133 = load i32, i32* %132
; # (fun sigChld)
; # (i8* (def (pico~pack "@" (pico~car cross~Args)) (func (; cross~Ar...
  %134 = bitcast void(i32)* @sigChld to i8*
; # (signal (val SIGCHLD Sig) (fun sigChld))
  %135 = call i8* @signal(i32 %133, i8* %134)
; # (val SIGPIPE Sig)
  %136 = getelementptr i32, i32* @Sig, i32 4
  %137 = load i32, i32* %136
; # (val SigIgn)
  %138 = load i8*, i8** @SigIgn
; # (signal (val SIGPIPE Sig) (val SigIgn))
  %139 = call i8* @signal(i32 %137, i8* %138)
; # (val SIGTTIN Sig)
  %140 = getelementptr i32, i32* @Sig, i32 11
  %141 = load i32, i32* %140
; # (val SigIgn)
  %142 = load i8*, i8** @SigIgn
; # (signal (val SIGTTIN Sig) (val SigIgn))
  %143 = call i8* @signal(i32 %141, i8* %142)
; # (val SIGTTOU Sig)
  %144 = getelementptr i32, i32* @Sig, i32 12
  %145 = load i32, i32* %144
; # (val SigIgn)
  %146 = load i8*, i8** @SigIgn
; # (signal (val SIGTTOU Sig) (val SigIgn))
  %147 = call i8* @signal(i32 %145, i8* %146)
; # (initReadline)
  call void @initReadline()
; # (set $USec (getUsec YES))
; # (getUsec YES)
  %148 = call i64 @getUsec(i1 1)
  store i64 %148, i64* @$USec
; # (unless (setjmp QuitRst) (loadAll 0))
; # (setjmp QuitRst)
  %149 = call i32 @setjmp(i8* @QuitRst)
  %150 = icmp ne i32 %149, 0
  br i1 %150, label %$26, label %$25
$25:
  %151 = phi i8** [%128, %$24] ; # Av
; # (loadAll 0)
  %152 = call i64 @loadAll(i64 0)
  br label %$26
$26:
  %153 = phi i8** [%128, %$24], [%151, %$25] ; # Av
; # (unless (val $Repl) (set $Repl YES) (iSignal (val SIGINT Sig) (fu...
; # (val $Repl)
  %154 = load i1, i1* @$Repl
  br i1 %154, label %$28, label %$27
$27:
  %155 = phi i8** [%153, %$26] ; # Av
; # (set $Repl YES)
  store i1 1, i1* @$Repl
; # (val SIGINT Sig)
  %156 = getelementptr i32, i32* @Sig, i32 1
  %157 = load i32, i32* %156
; # (fun sig)
; # (i8* (def (pico~pack "@" (pico~car cross~Args)) (func (; cross~Ar...
  %158 = bitcast void(i32)* @sig to i8*
; # (iSignal (val SIGINT Sig) (fun sig))
  call void @iSignal(i32 %157, i8* %158)
  br label %$28
$28:
  %159 = phi i8** [%153, %$26], [%155, %$27] ; # Av
; # (save -ZERO)
  %160 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %161 = load i64, i64* %160
  %162 = alloca i64, i64 2, align 16
  %163 = ptrtoint i64* %162 to i64
  %164 = inttoptr i64 %163 to i64*
  store i64 10, i64* %164
  %165 = add i64 %163, 8
  %166 = inttoptr i64 %165 to i64*
  store i64 %161, i64* %166
  %167 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %163, i64* %167
; # (loop (let X (safe (stdRead ($ ": "))) (cond ((lt0 (val $Chr)) (b...
  br label %$29
$29:
  %168 = phi i8** [%159, %$28], [%191, %$30] ; # Av
; # (let X (safe (stdRead ($ ": "))) (cond ((lt0 (val $Chr)) (bye 0))...
; # (stdRead ($ ": "))
  %169 = call i64 @stdRead(i8* bitcast ([3 x i8]* @$97 to i8*))
; # (safe (stdRead ($ ": ")))
  %170 = inttoptr i64 %163 to i64*
  store i64 %169, i64* %170
; # (cond ((lt0 (val $Chr)) (bye 0)) ((=0 (val $Chr)) (unless (nil? X...
; # (val $Chr)
  %171 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
; # (lt0 (val $Chr))
  %172 = icmp slt i32 %171, 0
  br i1 %172, label %$32, label %$31
$32:
  %173 = phi i8** [%168, %$29] ; # Av
; # (bye 0)
  call void @bye(i32 0)
  unreachable
$31:
  %174 = phi i8** [%168, %$29] ; # Av
; # (val $Chr)
  %175 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
; # (=0 (val $Chr))
  %176 = icmp eq i32 %175, 0
  br i1 %176, label %$34, label %$33
$34:
  %177 = phi i8** [%174, %$31] ; # Av
; # (unless (nil? X) (stdEval X))
; # (nil? X)
  %178 = icmp eq i64 %169, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %178, label %$36, label %$35
$35:
  %179 = phi i8** [%177, %$34] ; # Av
; # (stdEval X)
  %180 = call i64 @stdEval(i64 %169)
  br label %$36
$36:
  %181 = phi i8** [%177, %$34], [%179, %$35] ; # Av
  br label %$30
$33:
  %182 = phi i8** [%174, %$31] ; # Av
; # (eval X)
  %183 = and i64 %169, 6
  %184 = icmp ne i64 %183, 0
  br i1 %184, label %$39, label %$38
$39:
  br label %$37
$38:
  %185 = and i64 %169, 8
  %186 = icmp ne i64 %185, 0
  br i1 %186, label %$41, label %$40
$41:
  %187 = inttoptr i64 %169 to i64*
  %188 = load i64, i64* %187
  br label %$37
$40:
  %189 = call i64 @evList(i64 %169)
  br label %$37
$37:
  %190 = phi i64 [%169, %$39], [%188, %$41], [%189, %$40] ; # ->
  br label %$30
$30:
  %191 = phi i8** [%181, %$36], [%182, %$37] ; # Av
  br label %$29
}

@$97 = private constant [3 x i8] c": \00"
@$96 = private constant [5 x i8] c"HOME\00"
@$95 = private constant [2 x i8] c"+\00"
@$94 = private constant [19 x i8] c"Too many callbacks\00"
@$93 = private constant [9 x i8] c"[DLL] %s\00"
@$92 = private constant [8 x i8] c"Bad ffi\00"
@$91 = private constant [16 x i8] c"Bad result spec\00"
@$90 = private constant [19 x i8] c"Can't open PTY: %s\00"
@$89 = private constant [3 x i8] c"%s\00"
@$88 = private constant [11 x i8] c"Not making\00"
@$87 = private constant [3 x i8] c"+ \00"
@$86 = private constant [9 x i8] c"wait pid\00"
@$85 = private constant [4 x i8] c" = \00"
@$84 = private constant [3 x i8] c" :\00"
@$83 = private constant [9 x i8] c"No Break\00"
@$82 = private constant [3 x i8] c"! \00"
@$81 = private constant [14 x i8] c"No coroutines\00"
@$80 = private constant [18 x i8] c"Stack overwritten\00"
@$79 = private constant [13 x i8] c"Tag expected\00"
@$78 = private constant [20 x i8] c"Reentrant coroutine\00"
@$77 = private constant [20 x i8] c"Coroutine not found\00"
@$76 = private constant [14 x i8] c"Tag not found\00"
@$75 = private constant [10 x i8] c"Bad extra\00"
@$74 = private constant [10 x i8] c"Bad super\00"
@$73 = private constant [12 x i8] c"Bad message\00"
@$72 = private constant [12 x i8] c" redefined\0A\00"
@$71 = private constant [3 x i8] c"# \00"
@$70 = private constant [10 x i8] c"Bad count\00"
@$69 = private constant [10 x i8] c"Bad chain\00"
@$68 = private constant [19 x i8] c"Circular free list\00"
@$67 = private constant [28 x i8] c"Transaction fsync error: %s\00"
@$66 = private constant [7 x i8] c"Bad ID\00"
@$65 = private constant [2 x i8] c"r\00"
@$64 = private constant [3 x i8] c"a+\00"
@$63 = private constant [2 x i8] c"a\00"
@$62 = private constant [23 x i8] c"Log truncate error: %s\00"
@$61 = private constant [42 x i8] c"Last transaction not completed: Rollback\0A\00"
@$60 = private constant [35 x i8] c"Discarding incomplete transaction\0A\00"
@$59 = private constant [12 x i8] c"DB Oversize\00"
@$58 = private constant [14 x i8] c"Log write: %s\00"
@$57 = private constant [18 x i8] c"Journal write: %s\00"
@$56 = private constant [19 x i8] c"DB fsync error: %s\00"
@$55 = private constant [12 x i8] c"Bad Journal\00"
@$54 = private constant [13 x i8] c"DB write: %s\00"
@$53 = private constant [12 x i8] c"DB read: %s\00"
@$52 = private constant [12 x i8] c"Bad DB file\00"
@$51 = private constant [3 x i8] c"> \00"
@$50 = private constant [4 x i8] c"-> \00"
@$49 = private constant [4 x i8] c"   \00"
@$48 = private constant [4 x i8] c". (\00"
@$47 = private constant [4 x i8] c" . \00"
@$46 = private constant [6 x i8] c"priv~\00"
@$45 = private constant [27 x i8] c"Super parentheses mismatch\00"
@$44 = private constant [16 x i8] c"Bad dotted pair\00"
@$43 = private constant [15 x i8] c"sync write: %s\00"
@$42 = private constant [14 x i8] c"No current fd\00"
@$41 = private constant [14 x i8] c"Tell PIPE_BUF\00"
@$40 = private constant [16 x i8] c"child write: %s\00"
@$39 = private constant [16 x i8] c"bytes write: %s\00"
@$38 = private constant [9 x i8] c"SETFD %s\00"
@$37 = private constant [17 x i8] c"Select error: %s\00"
@$36 = private constant [7 x i8] c"Bad FD\00"
@$35 = private constant [15 x i8] c"Bad input '%s'\00"
@$34 = private constant [12 x i8] c"EOF Overrun\00"
@$33 = private constant [14 x i8] c"Size overflow\00"
@$32 = private constant [15 x i8] c"Pipe error: %s\00"
@$31 = private constant [16 x i8] c"Close error: %s\00"
@$30 = private constant [15 x i8] c"Open error: %s\00"
@$29 = private constant [10 x i8] c"Undefined\00"
@$28 = private constant [2 x i8] c".\00"
@$27 = private constant [6 x i8] c"Div/0\00"
@$26 = private constant [4 x i8] c".so\00"
@$25 = private constant [5 x i8] c"lib/\00"
@$24 = private constant [21 x i8] c"Bad symbol namespace\00"
@$23 = private constant [11 x i8] c"Can't fork\00"
@$22 = private constant [14 x i8] c"File lock: %s\00"
@$21 = private constant [10 x i8] c"Protected\00"
@$20 = private constant [15 x i8] c"Item not found\00"
@$19 = private constant [18 x i8] c"Variable expected\00"
@$18 = private constant [14 x i8] c"List expected\00"
@$17 = private constant [19 x i8] c"Cons pair expected\00"
@$16 = private constant [14 x i8] c"Atom expected\00"
@$15 = private constant [25 x i8] c"External symbol expected\00"
@$14 = private constant [14 x i8] c"Char expected\00"
@$13 = private constant [16 x i8] c"Symbol expected\00"
@$12 = private constant [16 x i8] c"Number expected\00"
@$11 = private constant [22 x i8] c"Small number expected\00"
@$10 = private constant [13 x i8] c"Bad argument\00"
@$9 = private constant [15 x i8] c"Stack overflow\00"
@$8 = private constant [9 x i8] c"No stack\00"
@$7 = private constant [3 x i8] c"? \00"
@$6 = private constant [5 x i8] c" -- \00"
@$5 = private constant [4 x i8] c"!? \00"
@$4 = private constant [10 x i8] c"No memory\00"
@$3 = private constant [16 x i8] c"%s: Can't exec\0A\00"
@$2 = private constant [13 x i8] c"Give up: %s\0A\00"
@$1 = private constant [2 x i8] c"\0A\00"
pil21/src/ext.l0000644000000000000000000001662414643270176010462 0ustar  # 09jul24 Software Lab. Alexander Burger

(symbols '(llvm))

(begin "ext" T
   "vers.l" "defs.l" "glob.l" "dec.l" )

(local) (SNXBASE SNXSIZE Snx FD)

# External declarations
(local) (xCnt evCnt evSym xName symChar charSym initInFile initOutFile)

(de T i64 xCnt (any any))
(de T i64 evCnt (any any))
(de T evSym (any))
(de T xName (any))
(de T i32 symChar (i64*))
(de T void charSym (i32 i64*))
(de T i8* initInFile (i32 i8*))
(de T i8* initOutFile (i32))

# Soundex Algorithm
(array $SnxTab i8
   (char "0") (char "1") (char "2") (char "3") (char "4") (char "5") (char "6") (char "7")  # 48
   (char "8") (char "9")        0          0          0          0          0          0
          0          0   (char "F") (char "S") (char "T")        0   (char "F") (char "S")  # 64
          0          0   (char "S") (char "S") (char "L") (char "N") (char "N")        0
   (char "F") (char "S") (char "R") (char "S") (char "T")        0   (char "F") (char "F")
   (char "S")        0   (char "S")        0          0          0          0          0
          0          0   (char "F") (char "S") (char "T")        0   (char "F") (char "S")  # 96
          0          0   (char "S") (char "S") (char "L") (char "N") (char "N")        0
   (char "F") (char "S") (char "R") (char "S") (char "T")        0   (char "F") (char "F")
   (char "S")        0   (char "S")        0          0          0          0          0
          0          0          0          0          0          0          0          0  # 128
          0          0          0          0          0          0          0          0
          0          0          0          0          0          0          0          0
          0          0          0          0          0          0          0          0
          0          0          0          0          0          0          0          0  # 160
          0          0          0          0          0          0          0          0
          0          0          0          0          0          0          0          0
          0          0          0          0          0          0          0          0
          0          0          0          0          0          0          0   (char "S")  # 192
          0          0          0          0          0          0          0          0
   (char "T") (char "N")   0    0          0          0          0   (char "S")
          0          0          0          0          0          0          0   (char "S")
          0          0          0          0          0          0          0   (char "S")  # 224
          0          0          0          0          0          0          0          0
          0   (char "N") )

(setq
   SNXBASE 48
   SNXSIZE (+ (* 24 8) 2) )

# (ext:Snx 'any ['cnt]) -> sym
(de Snx (Exe)
   (let X (cdr Exe)
      (if (nil? (evSym X))
         @
         (let
            (P (push 0 (xName @) NIL)  # [cnt name link]
               C (symChar P) )
            (while (> SNXBASE C)
               (unless (setq C (symChar P))
                  (ret $Nil) ) )
            (let
               (Q (link (ofs P 1) T)
                  R (push 4 NIL ZERO NIL)  # [cnt last name link]
                  N (if (pair (shift X)) (evCnt Exe X) 24) )
               (link (ofs R 2))
               (when
                  (or
                     (and (>= C (char "a")) (>= (char "z") C))
                     (== C 128)
                     (and (>= C 224) (>= 255 C)) )
                  (setq C (& C -33)) )  # Convert to lower case
               (charSym C R)
               (let Last C
                  (loop
                     (? (=0 (setq C (symChar P))))
                     (when (> C 32)  # Non-white
                        (cond
                           ((or
                                 (lt0 (dec 'C SNXBASE))  # Too small
                                 (>= C SNXSIZE)  # Too big
                                 (=0 (setq C (i32 (val (ofs $SnxTab C))))) )  # No entry
                              (setq Last 0) )
                           ((<> C Last)
                              (? (=0 (dec 'N)))
                              (charSym (setq Last C) R) ) ) ) )
                  (consStr (val 3 R)) ) ) ) ) ) )

# File Descriptor
# (ext:FD 'cnt) -> fd
(de FD (Exe)
   (prog1
      (eval (cadr Exe))
      (when (ge0 (i32 (xCnt Exe @)))
         (initInFile @ null)
         (initOutFile @) ) ) )

# Base64 Encoding
(local) ($Chr64 $Stat64 $Next64)

(str $Chr64 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/")
(var $Stat64 i32 0)  # State
(var $Next64 i32 0)  # Next value

# (ext:Base64) -> num|NIL
# (ext:Base64 'num1|NIL ['num2|NIL ['num3|NIL]]) -> flg
(de Base64 (Exe)
   (let X (cdr Exe)
      (cond
         ((atom X)  # No arguments
            (let C (val $Chr)
               (while (and (ge0 C) (>= (char " ") C))
                  (setq C (call $Get)) )
               (if (strchr $Chr64 C)
                  (let N (i32 (- @ $Chr64))  # Legal character
                     (setq C (call $Get))
                     (case (val $Stat64)  # Initial state
                        (0
                           (unless (strchr $Chr64 C)
                              (set $Stat64 0)
                              (ret $Nil) )
                           (set $Next64 (i32 (- @ $Chr64)))
                           (call $Get)
                           (set $Stat64 (inc (val $Stat64)))
                           (cnt
                              (i64
                                 (| (shl N 2) (shr (val $Next64) 4)) ) ) )
                        (1
                           (prog1
                              (cnt
                                 (i64
                                    (|
                                       (shl (& (val $Next64) 15) 4)
                                       (shr N 2) ) ) )
                              (set
                                 $Next64 N
                                 $Stat64 (inc (val $Stat64)) ) ) )
                        (T
                           (set $Stat64 0)
                           (cnt
                              (i64
                                 (| (shl (& (val $Next64) 3) 6) N) ) ) ) ) )
                  (when (== C (char "="))  # Filler
                     (call $Get)
                     (when (== (val $Stat64) 1)
                        (call $Get) ) )
                  (set $Stat64 0)
                  $Nil ) ) )
         ((nil? (eval (car X))) @)
         (T
            (let N (xCnt Exe @)
               (call $Put (val (ofs $Chr64 (shr N 2))))
               (when (nil? (eval (car (shift X))))
                  (call $Put
                     (val (ofs $Chr64 (shl (& N 3) 4))) )
                  (call $Put (char "="))
                  (call $Put (char "="))
                  (ret $Nil) )
               (let M (xCnt Exe @)
                  (call $Put
                     (val
                        (ofs $Chr64
                           (| (shl (& N 3) 4) (shr M 4)) ) ) )
                  (when (nil? (eval (cadr X)))
                     (call $Put
                        (val (ofs $Chr64 (shl (& M 15) 2))) )
                     (call $Put (char "="))
                     (ret $Nil) )
                  (setq N (xCnt Exe @))
                  (call $Put
                     (val
                        (ofs $Chr64
                           (| (shl (& M 15) 2) (shr N 6)) ) ) )
                  (call $Put (val (ofs $Chr64 (& N 63))))
                  $T ) ) ) ) ) )

(end)
pil21/src/ext.ll0000644000000000000000000010613014771742746010637 0ustar  source_filename = "ext.l"

declare {i64, i1} @llvm.uadd.with.overflow.i64(i64, i64)
declare {i64, i1} @llvm.usub.with.overflow.i64(i64, i64)
declare i64 @llvm.fshl.i64(i64, i64, i64)
declare i64 @llvm.fshr.i64(i64, i64, i64)
declare void @llvm.memcpy.p0i8.p0i8.i64(i8*, i8*, i64, i1)
declare void @llvm.memset.p0i8.i64(i8*, i8, i64, i1)
declare i8* @llvm.stacksave()
declare void @llvm.stackrestore(i8*)

@$AV0 = external global i8*
@$AV = external global i8**
@$PilHome = external global i8*
@$PilLen = external global i64
@$UsrHome = external global i8*
@$UsrLen = external global i64
@$Heaps = external global i64
@$Avail = external global i64
@$Extern = external global i64
@$ExtCnt = external global i64
@$ExtSkip = external global i64
@$Coroutines = external global i8*
@$Current = external global i8*
@$CrtLast = external global i8*
@$CrtFree = external global i8*
@$StkLimit = external global i8*
@$StkSizeT = external global i64
@$StkSize = external global i64
@$Stdin = external global i8*
@$Stdout = external global i8*
@$LinePtr = external global i8*
@$LineBuf = external global i8*
@$LinePrmt = external global i8*
@$ReplPrmt = external global i8*
@$ContPrmt = external global i8*
@$Ret = external global i64
@$TtyPid = external global i32
@$InFDs = external global i32
@$InFiles = external global i8**
@$OutFiles = external global i8**
@$IoCnt = external global i32
@$IoIx = external global i64
@$IoChar = external global i64
@$PutBin = external global void(i8)*
@$GetBin = external global i32()*
@$OutFDs = external global i32
@$Nfds = external global i32
@$Poll = external global i64*
@$SeedL = external global i64
@$SeedH = external global i64
@$USec = external global i64
@$Rt = external global i64
@$Child = external global i8*
@$Children = external global i32
@$Slot = external global i32
@$Spkr = external global i32
@$Mic = external global i32
@$SpMiPipe = external global [2 x i32]
@$Talking = external global i32
@$Hear = external global i32
@$Tell = external global i32
@$TellBuf = external global i8*
@$Ptr = external global i8*
@$End = external global i8*
@$BufX = external global i8*
@$PtrX = external global i8*
@$EndX = external global i8*
@$ExtN = external global i32
@$Extn = external global i32
@$StrP = external global i64*
@$GcCount = external global i64
@$DbFiles = external global i8*
@$DbFile = external global i8*
@$DBs = external global i32
@$MaxBlkSize = external global i32
@$DbBlock = external global i8*
@$BlkIndex = external global i64
@$BlkLink = external global i64
@$BlkPtr = external global i8*
@$BlkEnd = external global i8*
@$DbJnl = external global i8*
@$DbLog = external global i8*
@$Signal = external global [16 x i32]
@SymTab = external global [888 x i64]
@gcData = external global [53 x i64]
@cbFuns = external global [24 x i64]
@env = external global [25 x i64]
@$Cell = external global [2 x i64]
@$Version = external global [3 x i64]
@$TBuf = external global [2 x i8]
@$Month = external global [13 x i8]
@$Repl = external global i1
@$PRepl = external global i1
@$Tc = external global i1
@$Jam = external global i1
@$InBye = external global i1
@$Sync = external global i1
@$Empty = constant [1 x i8] c"\00"
@$Delim = constant [16 x i8] c" \09\0A\0D\22'(),[]`{}~\00"
declare i8* @malloc(i64)
declare i8* @realloc(i8*, i64)
declare void @free(i8*)
declare i32 @fork()
declare i8* @getenv(i8*)
declare i32 @setenv(i8*, i8*, i32)
declare i8* @getcwd(i8*, i64)
declare i32 @chdir(i8*)
declare i32 @getpid()
declare i32 @getpgrp()
declare i32 @setsid()
declare i32 @alarm(i32)
declare i32 @setpgid(i32, i32)
declare i32 @execvp(i8*, i8**)
declare i32 @isatty(i32)
declare i32 @openpty(i32*, i32*, i8*, i8*, i8*)
declare i32 @login_tty(i32)
declare i32 @tcgetattr(i32, i8*)
declare i32 @tcgetpgrp(i32)
declare i32 @tcsetpgrp(i32, i32)
declare i64 @read(i32, i8*, i64)
declare i64 @write(i32, i8*, i64)
declare i64 @pread(i32, i8*, i64, i64)
declare i64 @pwrite(i32, i8*, i64, i64)
declare i32 @fread(i8*, i64, i64, i8*)
declare i32 @fwrite(i8*, i64, i64, i8*)
declare i32 @putc_unlocked(i32, i8*)
declare i32 @getc_unlocked(i8*)
declare i8* @fopen(i8*, i8*)
declare i32 @fflush(i8*)
declare i32 @feof(i8*)
declare i32 @fclose(i8*)
declare i32 @fileno(i8*)
declare i32 @fsync(i32)
declare i32 @pipe(i32*)
declare i32 @memcmp(i8*, i8*, i64)
declare i64 @strlen(i8*)
declare i8* @strcpy(i8*, i8*)
declare i8* @strdup(i8*)
declare i32 @strcmp(i8*, i8*)
declare i8* @strchr(i8*, i32)
declare i8* @strrchr(i8*, i32)
declare i8* @dlsym(i8*, i8*)
declare i8* @dlerror()
declare i32 @dup(i32)
declare i32 @dup2(i32, i32)
declare i32 @close(i32)
declare i8* @signal(i32, i8*)
declare i32 @waitpid(i32, i32*, i32)
declare i32 @poll(i64*, i32, i64)
declare i32 @setjmp(i8*)
declare void @longjmp(i8*, i32)
declare i32 @kill(i32, i32)
declare void @exit(i32)
declare void @add_history(i8*)
declare i8*** @history_list()
declare void @clear_history()
@TgOS = external global i8
@TgCPU = external global i8
@PipeBufSize = external global i32
@Fsign = external global i1
@Fdigit = external global i64
declare i8* @stderrMsg(i8*, i8*)
declare void @gPrintf(i8*, i32, i8*, i8*)
declare i8* @strErrno()
declare i32 @openRd(i8*)
declare i32 @openWr(i8*)
declare i32 @openRdWr(i8*)
declare i32 @openRdWrExcl(i8*)
declare i32 @openRdWrCreate(i8*)
declare i32 @openRdWrAppend(i8*)
declare i32 @openWrAppend(i8*)
declare i1 @fseekOfs(i8*, i32)
declare i1 @fseek0(i8*)
declare i1 @seek0(i32)
declare i1 @truncate0(i32)
declare i32 @socketPair(i32*)
declare i32 @fcntlCloExec(i32)
declare void @fcntlSetFl(i32, i32)
declare i32 @nonBlocking(i32)
declare void @fcntlSetOwn(i32, i32)
declare i8* @getDir(i8*)
declare void @initReadline()
declare i8* @gReadline(i8*)
declare void @rlHide()
declare void @rlShow()
declare void @rlSigBeg()
declare void @rlSigEnd()
declare i8* @currentLine()
@Sig = external global i32
@SigDfl = external global i8*
@SigIgn = external global i8*
declare i32 @gSignal(i32)
declare void @iSignal(i32, i8*)
declare void @sigUnblock(i32)
declare void @sigChld(i32)
declare i32 @waitWuntraced(i32, i32*)
declare i32 @wifStopped(i32*)
declare i32 @nErrno()
declare i32 @gErrno()
@Tio = external global i1
@OrgTermio = external global i8
@Termio = external global i8*
declare void @stopTerm()
declare void @setRaw()
declare void @setCooked()
declare i1 @reopenTty(i8*)
declare i64 @getUsec(i1)
declare i64 @getMsec()
declare i64 @getDate()
declare i64 @getGmDate()
declare i64 @getTime()
declare i64 @getGmTime()
declare i8* @ulimStk()
declare i64 @fileInfo(i1, i1, i8*, i64*)
declare void @pollIn(i32, i64*)
declare void @pollOut(i32, i64*)
declare void @pollIgn(i64*)
declare i32 @gPoll(i64*, i32, i64)
declare i1 @readyIn(i64*)
declare i1 @readyOut(i64*)
declare i32 @rdLock(i32, i64, i64, i1)
declare i32 @wrLock(i32, i64, i64, i1)
declare i32 @unLock(i32, i64, i64)
declare i32 @getLock(i32, i64, i64)
@JmpBufSize = external global i64
@QuitRst = external global i8
declare i8* @dlOpen(i8*)
declare i8* @ffiPrep(i8*, i8*, i64)
declare i64 @ffiCall(i8*, i64)
declare i64 @boxFloat(i32, i64)
declare i64 @boxFlt()
declare i64 @boxDouble(i64, i64)
declare i64 @boxDbl()
declare void @bufFloat(i64, i64, i8*)
declare void @bufDouble(i64, i64, i8*)
declare i1 @chance(i64)
declare i1 @isLowc(i32)
declare i1 @isUppc(i32)
declare i1 @isLetterOrDigit(i32)
declare i32 @toUpperCase(i32)
declare i32 @toLowerCase(i32)
declare i64 @dbg(i64, i64)
declare i1 @equal(i64, i64)
declare i64 @compare(i64, i64)
declare i64 @evList(i64)
declare i64 @cons(i64, i64)
declare i64 @cons2(i64, i64, i64)
declare i64 @cons3(i64, i64, i64, i64)
declare i64 @consStr(i64)
declare i64 @bufSize(i64)
declare i8* @bufString(i64, i8*)
declare i64 @mkStr(i8*)
declare i8 @firstByte(i64)
declare void @pack(i64, i64*)
declare i1 @subStr(i64, i64)
declare i1 @flush(i8*)
declare void @flushAll()
declare void @newline()
declare void @space()
declare void @outWord(i64)
declare void @outString(i8*)
declare void @print(i64)
declare i64 @repl(i64, i8*, i64)
declare void @dbFetch(i64, i64)
declare void @dbTouch(i64, i64)
declare void @dbZap(i64)
declare void @putSrc(i64, i64)
declare i64 @brkLoad(i64)
declare i64 @xCnt(i64, i64)
declare i64 @evCnt(i64, i64)
declare i64 @evSym(i64)
declare i64 @xName(i64)
declare i32 @symChar(i64*)
declare void @charSym(i32, i64*)
declare i8* @initInFile(i32, i8*)
declare i8* @initOutFile(i32)
@$SnxTab = global [194 x i8] [
  i8 48,
  i8 49,
  i8 50,
  i8 51,
  i8 52,
  i8 53,
  i8 54,
  i8 55,
  i8 56,
  i8 57,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 70,
  i8 83,
  i8 84,
  i8 0,
  i8 70,
  i8 83,
  i8 0,
  i8 0,
  i8 83,
  i8 83,
  i8 76,
  i8 78,
  i8 78,
  i8 0,
  i8 70,
  i8 83,
  i8 82,
  i8 83,
  i8 84,
  i8 0,
  i8 70,
  i8 70,
  i8 83,
  i8 0,
  i8 83,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 70,
  i8 83,
  i8 84,
  i8 0,
  i8 70,
  i8 83,
  i8 0,
  i8 0,
  i8 83,
  i8 83,
  i8 76,
  i8 78,
  i8 78,
  i8 0,
  i8 70,
  i8 83,
  i8 82,
  i8 83,
  i8 84,
  i8 0,
  i8 70,
  i8 70,
  i8 83,
  i8 0,
  i8 83,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 83,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 84,
  i8 78,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 83,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 83,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 83,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 0,
  i8 78
]

define i64 @Snx(i64) align 8 {
$1:
; # (let X (cdr Exe) (if (nil? (evSym X)) @ (let (P (push 0 (xName @)...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (if (nil? (evSym X)) @ (let (P (push 0 (xName @) NIL) C (symChar ...
; # (evSym X)
  %4 = call i64 @evSym(i64 %3)
; # (nil? (evSym X))
  %5 = icmp eq i64 %4, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %5, label %$2, label %$3
$2:
  %6 = phi i64 [%3, %$1] ; # X
  br label %$4
$3:
  %7 = phi i64 [%3, %$1] ; # X
; # (let (P (push 0 (xName @) NIL) C (symChar P)) (while (> SNXBASE C...
; # (xName @)
  %8 = call i64 @xName(i64 %4)
; # (push 0 (xName @) NIL)
  %9 = alloca i64, i64 3, align 16
  store i64 0, i64* %9
  %10 = getelementptr i64, i64* %9, i32 1
  store i64 %8, i64* %10
; # (symChar P)
  %11 = call i32 @symChar(i64* %9)
; # (while (> SNXBASE C) (unless (setq C (symChar P)) (ret $Nil)))
  br label %$5
$5:
  %12 = phi i64 [%7, %$3], [%21, %$9] ; # X
  %13 = phi i32 [%11, %$3], [%22, %$9] ; # C
; # (> SNXBASE C)
  %14 = icmp sgt i32 48, %13
  br i1 %14, label %$6, label %$7
$6:
  %15 = phi i64 [%12, %$5] ; # X
  %16 = phi i32 [%13, %$5] ; # C
; # (unless (setq C (symChar P)) (ret $Nil))
; # (symChar P)
  %17 = call i32 @symChar(i64* %9)
  %18 = icmp ne i32 %17, 0
  br i1 %18, label %$9, label %$8
$8:
  %19 = phi i64 [%15, %$6] ; # X
  %20 = phi i32 [%17, %$6] ; # C
; # (ret $Nil)
  ret i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
$9:
  %21 = phi i64 [%15, %$6] ; # X
  %22 = phi i32 [%17, %$6] ; # C
  br label %$5
$7:
  %23 = phi i64 [%12, %$5] ; # X
  %24 = phi i32 [%13, %$5] ; # C
; # (let (Q (link (ofs P 1) T) R (push 4 NIL ZERO NIL) N (if (pair (s...
; # (ofs P 1)
  %25 = getelementptr i64, i64* %9, i32 1
; # (link (ofs P 1) T)
  %26 = ptrtoint i64* %25 to i64
  %27 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %28 = load i64, i64* %27
  %29 = inttoptr i64 %26 to i64*
  %30 = getelementptr i64, i64* %29, i32 1
  store i64 %28, i64* %30
  %31 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %26, i64* %31
; # (push 4 NIL ZERO NIL)
  %32 = alloca i64, i64 4, align 16
  store i64 4, i64* %32
  %33 = getelementptr i64, i64* %32, i32 2
  store i64 2, i64* %33
; # (if (pair (shift X)) (evCnt Exe X) 24)
; # (shift X)
  %34 = inttoptr i64 %23 to i64*
  %35 = getelementptr i64, i64* %34, i32 1
  %36 = load i64, i64* %35
; # (pair (shift X))
  %37 = and i64 %36, 15
  %38 = icmp eq i64 %37, 0
  br i1 %38, label %$10, label %$11
$10:
  %39 = phi i64 [%36, %$7] ; # X
  %40 = phi i32 [%24, %$7] ; # C
; # (evCnt Exe X)
  %41 = call i64 @evCnt(i64 %0, i64 %39)
  br label %$12
$11:
  %42 = phi i64 [%36, %$7] ; # X
  %43 = phi i32 [%24, %$7] ; # C
  br label %$12
$12:
  %44 = phi i64 [%39, %$10], [%42, %$11] ; # X
  %45 = phi i32 [%40, %$10], [%43, %$11] ; # C
  %46 = phi i64 [%41, %$10], [24, %$11] ; # ->
; # (ofs R 2)
  %47 = getelementptr i64, i64* %32, i32 2
; # (link (ofs R 2))
  %48 = ptrtoint i64* %47 to i64
  %49 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %50 = load i64, i64* %49
  %51 = inttoptr i64 %48 to i64*
  %52 = getelementptr i64, i64* %51, i32 1
  store i64 %50, i64* %52
  %53 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %48, i64* %53
; # (when (or (and (>= C (char "a")) (>= (char "z") C)) (== C 128) (a...
; # (or (and (>= C (char "a")) (>= (char "z") C)) (== C 128) (and (>=...
; # (and (>= C (char "a")) (>= (char "z") C))
; # (>= C (char "a"))
  %54 = icmp sge i32 %45, 97
  br i1 %54, label %$15, label %$14
$15:
  %55 = phi i64 [%44, %$12] ; # X
  %56 = phi i32 [%45, %$12] ; # C
  %57 = phi i64 [%46, %$12] ; # N
; # (>= (char "z") C)
  %58 = icmp sge i32 122, %56
  br label %$14
$14:
  %59 = phi i64 [%44, %$12], [%55, %$15] ; # X
  %60 = phi i32 [%45, %$12], [%56, %$15] ; # C
  %61 = phi i64 [%46, %$12], [%57, %$15] ; # N
  %62 = phi i1 [0, %$12], [%58, %$15] ; # ->
  br i1 %62, label %$13, label %$16
$16:
  %63 = phi i64 [%59, %$14] ; # X
  %64 = phi i32 [%60, %$14] ; # C
  %65 = phi i64 [%61, %$14] ; # N
; # (== C 128)
  %66 = icmp eq i32 %64, 128
  br i1 %66, label %$13, label %$17
$17:
  %67 = phi i64 [%63, %$16] ; # X
  %68 = phi i32 [%64, %$16] ; # C
  %69 = phi i64 [%65, %$16] ; # N
; # (and (>= C 224) (>= 255 C))
; # (>= C 224)
  %70 = icmp sge i32 %68, 224
  br i1 %70, label %$19, label %$18
$19:
  %71 = phi i64 [%67, %$17] ; # X
  %72 = phi i32 [%68, %$17] ; # C
  %73 = phi i64 [%69, %$17] ; # N
; # (>= 255 C)
  %74 = icmp sge i32 255, %72
  br label %$18
$18:
  %75 = phi i64 [%67, %$17], [%71, %$19] ; # X
  %76 = phi i32 [%68, %$17], [%72, %$19] ; # C
  %77 = phi i64 [%69, %$17], [%73, %$19] ; # N
  %78 = phi i1 [0, %$17], [%74, %$19] ; # ->
  br label %$13
$13:
  %79 = phi i64 [%59, %$14], [%63, %$16], [%75, %$18] ; # X
  %80 = phi i32 [%60, %$14], [%64, %$16], [%76, %$18] ; # C
  %81 = phi i64 [%61, %$14], [%65, %$16], [%77, %$18] ; # N
  %82 = phi i1 [1, %$14], [1, %$16], [%78, %$18] ; # ->
  br i1 %82, label %$20, label %$21
$20:
  %83 = phi i64 [%79, %$13] ; # X
  %84 = phi i32 [%80, %$13] ; # C
  %85 = phi i64 [%81, %$13] ; # N
; # (& C -33)
  %86 = and i32 %84, -33
  br label %$21
$21:
  %87 = phi i64 [%79, %$13], [%83, %$20] ; # X
  %88 = phi i32 [%80, %$13], [%86, %$20] ; # C
  %89 = phi i64 [%81, %$13], [%85, %$20] ; # N
; # (charSym C R)
  call void @charSym(i32 %88, i64* %32)
; # (let Last C (loop (? (=0 (setq C (symChar P)))) (when (> C 32) (c...
; # (loop (? (=0 (setq C (symChar P)))) (when (> C 32) (cond ((or (lt...
  br label %$22
$22:
  %90 = phi i64 [%87, %$21], [%152, %$26] ; # X
  %91 = phi i32 [%88, %$21], [%153, %$26] ; # C
  %92 = phi i64 [%89, %$21], [%154, %$26] ; # N
  %93 = phi i32 [%88, %$21], [%155, %$26] ; # Last
; # (? (=0 (setq C (symChar P))))
; # (symChar P)
  %94 = call i32 @symChar(i64* %9)
; # (=0 (setq C (symChar P)))
  %95 = icmp eq i32 %94, 0
  br i1 %95, label %$24, label %$23
$23:
  %96 = phi i64 [%90, %$22] ; # X
  %97 = phi i32 [%94, %$22] ; # C
  %98 = phi i64 [%92, %$22] ; # N
  %99 = phi i32 [%93, %$22] ; # Last
; # (when (> C 32) (cond ((or (lt0 (dec 'C SNXBASE)) (>= C SNXSIZE) (...
; # (> C 32)
  %100 = icmp sgt i32 %97, 32
  br i1 %100, label %$25, label %$26
$25:
  %101 = phi i64 [%96, %$23] ; # X
  %102 = phi i32 [%97, %$23] ; # C
  %103 = phi i64 [%98, %$23] ; # N
  %104 = phi i32 [%99, %$23] ; # Last
; # (cond ((or (lt0 (dec 'C SNXBASE)) (>= C SNXSIZE) (=0 (setq C (i32...
; # (or (lt0 (dec 'C SNXBASE)) (>= C SNXSIZE) (=0 (setq C (i32 (val (...
; # (dec 'C SNXBASE)
  %105 = sub i32 %102, 48
; # (lt0 (dec 'C SNXBASE))
  %106 = icmp slt i32 %105, 0
  br i1 %106, label %$28, label %$29
$29:
  %107 = phi i64 [%101, %$25] ; # X
  %108 = phi i32 [%105, %$25] ; # C
  %109 = phi i64 [%103, %$25] ; # N
  %110 = phi i32 [%104, %$25] ; # Last
; # (>= C SNXSIZE)
  %111 = icmp sge i32 %108, 194
  br i1 %111, label %$28, label %$30
$30:
  %112 = phi i64 [%107, %$29] ; # X
  %113 = phi i32 [%108, %$29] ; # C
  %114 = phi i64 [%109, %$29] ; # N
  %115 = phi i32 [%110, %$29] ; # Last
; # (ofs $SnxTab C)
  %116 = getelementptr i8, i8* bitcast ([194 x i8]* @$SnxTab to i8*), i32 %113
; # (val (ofs $SnxTab C))
  %117 = load i8, i8* %116
; # (i32 (val (ofs $SnxTab C)))
  %118 = zext i8 %117 to i32
; # (=0 (setq C (i32 (val (ofs $SnxTab C)))))
  %119 = icmp eq i32 %118, 0
  br label %$28
$28:
  %120 = phi i64 [%101, %$25], [%107, %$29], [%112, %$30] ; # X
  %121 = phi i32 [%105, %$25], [%108, %$29], [%118, %$30] ; # C
  %122 = phi i64 [%103, %$25], [%109, %$29], [%114, %$30] ; # N
  %123 = phi i32 [%104, %$25], [%110, %$29], [%115, %$30] ; # Last
  %124 = phi i1 [1, %$25], [1, %$29], [%119, %$30] ; # ->
  br i1 %124, label %$32, label %$31
$32:
  %125 = phi i64 [%120, %$28] ; # X
  %126 = phi i32 [%121, %$28] ; # C
  %127 = phi i64 [%122, %$28] ; # N
  %128 = phi i32 [%123, %$28] ; # Last
  br label %$27
$31:
  %129 = phi i64 [%120, %$28] ; # X
  %130 = phi i32 [%121, %$28] ; # C
  %131 = phi i64 [%122, %$28] ; # N
  %132 = phi i32 [%123, %$28] ; # Last
; # (<> C Last)
  %133 = icmp ne i32 %130, %132
  br i1 %133, label %$34, label %$33
$34:
  %134 = phi i64 [%129, %$31] ; # X
  %135 = phi i32 [%130, %$31] ; # C
  %136 = phi i64 [%131, %$31] ; # N
  %137 = phi i32 [%132, %$31] ; # Last
; # (? (=0 (dec 'N)))
; # (dec 'N)
  %138 = sub i64 %136, 1
; # (=0 (dec 'N))
  %139 = icmp eq i64 %138, 0
  br i1 %139, label %$24, label %$35
$35:
  %140 = phi i64 [%134, %$34] ; # X
  %141 = phi i32 [%135, %$34] ; # C
  %142 = phi i64 [%138, %$34] ; # N
  %143 = phi i32 [%137, %$34] ; # Last
; # (charSym (setq Last C) R)
  call void @charSym(i32 %141, i64* %32)
  br label %$27
$33:
  %144 = phi i64 [%129, %$31] ; # X
  %145 = phi i32 [%130, %$31] ; # C
  %146 = phi i64 [%131, %$31] ; # N
  %147 = phi i32 [%132, %$31] ; # Last
  br label %$27
$27:
  %148 = phi i64 [%125, %$32], [%140, %$35], [%144, %$33] ; # X
  %149 = phi i32 [%126, %$32], [%141, %$35], [%145, %$33] ; # C
  %150 = phi i64 [%127, %$32], [%142, %$35], [%146, %$33] ; # N
  %151 = phi i32 [0, %$32], [%141, %$35], [%147, %$33] ; # Last
  br label %$26
$26:
  %152 = phi i64 [%96, %$23], [%148, %$27] ; # X
  %153 = phi i32 [%97, %$23], [%149, %$27] ; # C
  %154 = phi i64 [%98, %$23], [%150, %$27] ; # N
  %155 = phi i32 [%99, %$23], [%151, %$27] ; # Last
  br label %$22
$24:
  %156 = phi i64 [%90, %$22], [%134, %$34] ; # X
  %157 = phi i32 [%94, %$22], [%135, %$34] ; # C
  %158 = phi i64 [%92, %$22], [%138, %$34] ; # N
  %159 = phi i32 [%93, %$22], [%137, %$34] ; # Last
  %160 = phi i64 [0, %$22], [0, %$34] ; # ->
; # (val 3 R)
  %161 = getelementptr i64, i64* %32, i32 2
  %162 = load i64, i64* %161
; # (consStr (val 3 R))
  %163 = call i64 @consStr(i64 %162)
; # (drop *Safe)
  %164 = inttoptr i64 %26 to i64*
  %165 = getelementptr i64, i64* %164, i32 1
  %166 = load i64, i64* %165
  %167 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %166, i64* %167
  br label %$4
$4:
  %168 = phi i64 [%6, %$2], [%156, %$24] ; # X
  %169 = phi i64 [%4, %$2], [%163, %$24] ; # ->
  ret i64 %169
}

define i64 @FD(i64) align 8 {
$1:
; # (prog1 (eval (cadr Exe)) (when (ge0 (i32 (xCnt Exe @))) (initInFi...
; # (cadr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
; # (eval (cadr Exe))
  %6 = and i64 %5, 6
  %7 = icmp ne i64 %6, 0
  br i1 %7, label %$4, label %$3
$4:
  br label %$2
$3:
  %8 = and i64 %5, 8
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$6, label %$5
$6:
  %10 = inttoptr i64 %5 to i64*
  %11 = load i64, i64* %10
  br label %$2
$5:
  %12 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %13 = phi i64 [%5, %$4], [%11, %$6], [%12, %$5] ; # ->
; # (when (ge0 (i32 (xCnt Exe @))) (initInFile @ null) (initOutFile @...
; # (xCnt Exe @)
  %14 = call i64 @xCnt(i64 %0, i64 %13)
; # (i32 (xCnt Exe @))
  %15 = trunc i64 %14 to i32
; # (ge0 (i32 (xCnt Exe @)))
  %16 = icmp sge i32 %15, 0
  br i1 %16, label %$7, label %$8
$7:
; # (initInFile @ null)
  %17 = call i8* @initInFile(i32 %15, i8* null)
; # (initOutFile @)
  %18 = call i8* @initOutFile(i32 %15)
  br label %$8
$8:
  ret i64 %13
}
@$Chr64 = constant [65 x i8] c"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\00"
@$Stat64 = global i32 0
@$Next64 = global i32 0

define i64 @Base64(i64) align 8 {
$1:
; # (let X (cdr Exe) (cond ((atom X) (let C (val $Chr) (while (and (g...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (cond ((atom X) (let C (val $Chr) (while (and (ge0 C) (>= (char "...
; # (atom X)
  %4 = and i64 %3, 15
  %5 = icmp ne i64 %4, 0
  br i1 %5, label %$4, label %$3
$4:
  %6 = phi i64 [%3, %$1] ; # X
; # (let C (val $Chr) (while (and (ge0 C) (>= (char " ") C)) (setq C ...
; # (val $Chr)
  %7 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
; # (while (and (ge0 C) (>= (char " ") C)) (setq C (call $Get)))
  br label %$5
$5:
  %8 = phi i64 [%6, %$4], [%17, %$8] ; # X
  %9 = phi i32 [%7, %$4], [%20, %$8] ; # C
; # (and (ge0 C) (>= (char " ") C))
; # (ge0 C)
  %10 = icmp sge i32 %9, 0
  br i1 %10, label %$7, label %$6
$7:
  %11 = phi i64 [%8, %$5] ; # X
  %12 = phi i32 [%9, %$5] ; # C
; # (>= (char " ") C)
  %13 = icmp sge i32 32, %12
  br label %$6
$6:
  %14 = phi i64 [%8, %$5], [%11, %$7] ; # X
  %15 = phi i32 [%9, %$5], [%12, %$7] ; # C
  %16 = phi i1 [0, %$5], [%13, %$7] ; # ->
  br i1 %16, label %$8, label %$9
$8:
  %17 = phi i64 [%14, %$6] ; # X
  %18 = phi i32 [%15, %$6] ; # C
; # (call $Get)
  %19 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %20 = call i32 %19()
  br label %$5
$9:
  %21 = phi i64 [%14, %$6] ; # X
  %22 = phi i32 [%15, %$6] ; # C
; # (if (strchr $Chr64 C) (let N (i32 (- @ $Chr64)) (setq C (call $Ge...
; # (strchr $Chr64 C)
  %23 = call i8* @strchr(i8* bitcast ([65 x i8]* @$Chr64 to i8*), i32 %22)
  %24 = icmp ne i8* %23, null
  br i1 %24, label %$10, label %$11
$10:
  %25 = phi i64 [%21, %$9] ; # X
  %26 = phi i32 [%22, %$9] ; # C
; # (let N (i32 (- @ $Chr64)) (setq C (call $Get)) (case (val $Stat64...
; # (- @ $Chr64)
  %27 = ptrtoint i8* %23 to i64
  %28 = ptrtoint i8* bitcast ([65 x i8]* @$Chr64 to i8*) to i64
  %29 = sub i64 %27, %28
; # (i32 (- @ $Chr64))
  %30 = trunc i64 %29 to i32
; # (call $Get)
  %31 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %32 = call i32 %31()
; # (case (val $Stat64) (0 (unless (strchr $Chr64 C) (set $Stat64 0) ...
; # (val $Stat64)
  %33 = load i32, i32* @$Stat64
  switch i32 %33, label %$13 [
    i32 0, label %$15
    i32 1, label %$16
  ]
$15:
  %34 = phi i64 [%25, %$10] ; # X
  %35 = phi i32 [%32, %$10] ; # C
; # (unless (strchr $Chr64 C) (set $Stat64 0) (ret $Nil))
; # (strchr $Chr64 C)
  %36 = call i8* @strchr(i8* bitcast ([65 x i8]* @$Chr64 to i8*), i32 %35)
  %37 = icmp ne i8* %36, null
  br i1 %37, label %$18, label %$17
$17:
  %38 = phi i64 [%34, %$15] ; # X
  %39 = phi i32 [%35, %$15] ; # C
; # (set $Stat64 0)
  store i32 0, i32* @$Stat64
; # (ret $Nil)
  ret i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
$18:
  %40 = phi i64 [%34, %$15] ; # X
  %41 = phi i32 [%35, %$15] ; # C
; # (set $Next64 (i32 (- @ $Chr64)))
; # (- @ $Chr64)
  %42 = ptrtoint i8* %36 to i64
  %43 = ptrtoint i8* bitcast ([65 x i8]* @$Chr64 to i8*) to i64
  %44 = sub i64 %42, %43
; # (i32 (- @ $Chr64))
  %45 = trunc i64 %44 to i32
  store i32 %45, i32* @$Next64
; # (call $Get)
  %46 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %47 = call i32 %46()
; # (set $Stat64 (inc (val $Stat64)))
; # (val $Stat64)
  %48 = load i32, i32* @$Stat64
; # (inc (val $Stat64))
  %49 = add i32 %48, 1
  store i32 %49, i32* @$Stat64
; # (shl N 2)
  %50 = shl i32 %30, 2
; # (val $Next64)
  %51 = load i32, i32* @$Next64
; # (shr (val $Next64) 4)
  %52 = lshr i32 %51, 4
; # (| (shl N 2) (shr (val $Next64) 4))
  %53 = or i32 %50, %52
; # (i64 (| (shl N 2) (shr (val $Next64) 4)))
  %54 = sext i32 %53 to i64
; # (cnt (i64 (| (shl N 2) (shr (val $Next64) 4))))
  %55 = shl i64 %54, 4
  %56 = or i64 %55, 2
  br label %$14
$16:
  %57 = phi i64 [%25, %$10] ; # X
  %58 = phi i32 [%32, %$10] ; # C
; # (prog1 (cnt (i64 (| (shl (& (val $Next64) 15) 4) (shr N 2)))) (se...
; # (val $Next64)
  %59 = load i32, i32* @$Next64
; # (& (val $Next64) 15)
  %60 = and i32 %59, 15
; # (shl (& (val $Next64) 15) 4)
  %61 = shl i32 %60, 4
; # (shr N 2)
  %62 = lshr i32 %30, 2
; # (| (shl (& (val $Next64) 15) 4) (shr N 2))
  %63 = or i32 %61, %62
; # (i64 (| (shl (& (val $Next64) 15) 4) (shr N 2)))
  %64 = sext i32 %63 to i64
; # (cnt (i64 (| (shl (& (val $Next64) 15) 4) (shr N 2))))
  %65 = shl i64 %64, 4
  %66 = or i64 %65, 2
; # (set $Next64 N $Stat64 (inc (val $Stat64)))
  store i32 %30, i32* @$Next64
; # (val $Stat64)
  %67 = load i32, i32* @$Stat64
; # (inc (val $Stat64))
  %68 = add i32 %67, 1
  store i32 %68, i32* @$Stat64
  br label %$14
$13:
  %69 = phi i64 [%25, %$10] ; # X
  %70 = phi i32 [%32, %$10] ; # C
; # (set $Stat64 0)
  store i32 0, i32* @$Stat64
; # (val $Next64)
  %71 = load i32, i32* @$Next64
; # (& (val $Next64) 3)
  %72 = and i32 %71, 3
; # (shl (& (val $Next64) 3) 6)
  %73 = shl i32 %72, 6
; # (| (shl (& (val $Next64) 3) 6) N)
  %74 = or i32 %73, %30
; # (i64 (| (shl (& (val $Next64) 3) 6) N))
  %75 = sext i32 %74 to i64
; # (cnt (i64 (| (shl (& (val $Next64) 3) 6) N)))
  %76 = shl i64 %75, 4
  %77 = or i64 %76, 2
  br label %$14
$14:
  %78 = phi i64 [%40, %$18], [%57, %$16], [%69, %$13] ; # X
  %79 = phi i32 [%41, %$18], [%58, %$16], [%70, %$13] ; # C
  %80 = phi i64 [%56, %$18], [%66, %$16], [%77, %$13] ; # ->
  br label %$12
$11:
  %81 = phi i64 [%21, %$9] ; # X
  %82 = phi i32 [%22, %$9] ; # C
; # (when (== C (char "=")) (call $Get) (when (== (val $Stat64) 1) (c...
; # (== C (char "="))
  %83 = icmp eq i32 %82, 61
  br i1 %83, label %$19, label %$20
$19:
  %84 = phi i64 [%81, %$11] ; # X
  %85 = phi i32 [%82, %$11] ; # C
; # (call $Get)
  %86 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %87 = call i32 %86()
; # (when (== (val $Stat64) 1) (call $Get))
; # (val $Stat64)
  %88 = load i32, i32* @$Stat64
; # (== (val $Stat64) 1)
  %89 = icmp eq i32 %88, 1
  br i1 %89, label %$21, label %$22
$21:
  %90 = phi i64 [%84, %$19] ; # X
  %91 = phi i32 [%85, %$19] ; # C
; # (call $Get)
  %92 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %93 = call i32 %92()
  br label %$22
$22:
  %94 = phi i64 [%84, %$19], [%90, %$21] ; # X
  %95 = phi i32 [%85, %$19], [%91, %$21] ; # C
  br label %$20
$20:
  %96 = phi i64 [%81, %$11], [%94, %$22] ; # X
  %97 = phi i32 [%82, %$11], [%95, %$22] ; # C
; # (set $Stat64 0)
  store i32 0, i32* @$Stat64
  br label %$12
$12:
  %98 = phi i64 [%78, %$14], [%96, %$20] ; # X
  %99 = phi i32 [%79, %$14], [%97, %$20] ; # C
  %100 = phi i64 [%80, %$14], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$20] ; # ->
  br label %$2
$3:
  %101 = phi i64 [%3, %$1] ; # X
; # (car X)
  %102 = inttoptr i64 %101 to i64*
  %103 = load i64, i64* %102
; # (eval (car X))
  %104 = and i64 %103, 6
  %105 = icmp ne i64 %104, 0
  br i1 %105, label %$25, label %$24
$25:
  br label %$23
$24:
  %106 = and i64 %103, 8
  %107 = icmp ne i64 %106, 0
  br i1 %107, label %$27, label %$26
$27:
  %108 = inttoptr i64 %103 to i64*
  %109 = load i64, i64* %108
  br label %$23
$26:
  %110 = call i64 @evList(i64 %103)
  br label %$23
$23:
  %111 = phi i64 [%103, %$25], [%109, %$27], [%110, %$26] ; # ->
; # (nil? (eval (car X)))
  %112 = icmp eq i64 %111, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %112, label %$29, label %$28
$29:
  %113 = phi i64 [%101, %$23] ; # X
  br label %$2
$28:
  %114 = phi i64 [%101, %$23] ; # X
; # (let N (xCnt Exe @) (call $Put (val (ofs $Chr64 (shr N 2)))) (whe...
; # (xCnt Exe @)
  %115 = call i64 @xCnt(i64 %0, i64 %111)
; # (shr N 2)
  %116 = lshr i64 %115, 2
; # (ofs $Chr64 (shr N 2))
  %117 = getelementptr i8, i8* bitcast ([65 x i8]* @$Chr64 to i8*), i64 %116
; # (val (ofs $Chr64 (shr N 2)))
  %118 = load i8, i8* %117
; # (call $Put (val (ofs $Chr64 (shr N 2))))
  %119 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %119(i8 %118)
; # (when (nil? (eval (car (shift X)))) (call $Put (val (ofs $Chr64 (...
; # (shift X)
  %120 = inttoptr i64 %114 to i64*
  %121 = getelementptr i64, i64* %120, i32 1
  %122 = load i64, i64* %121
; # (car (shift X))
  %123 = inttoptr i64 %122 to i64*
  %124 = load i64, i64* %123
; # (eval (car (shift X)))
  %125 = and i64 %124, 6
  %126 = icmp ne i64 %125, 0
  br i1 %126, label %$32, label %$31
$32:
  br label %$30
$31:
  %127 = and i64 %124, 8
  %128 = icmp ne i64 %127, 0
  br i1 %128, label %$34, label %$33
$34:
  %129 = inttoptr i64 %124 to i64*
  %130 = load i64, i64* %129
  br label %$30
$33:
  %131 = call i64 @evList(i64 %124)
  br label %$30
$30:
  %132 = phi i64 [%124, %$32], [%130, %$34], [%131, %$33] ; # ->
; # (nil? (eval (car (shift X))))
  %133 = icmp eq i64 %132, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %133, label %$35, label %$36
$35:
  %134 = phi i64 [%122, %$30] ; # X
  %135 = phi i64 [%115, %$30] ; # N
; # (& N 3)
  %136 = and i64 %135, 3
; # (shl (& N 3) 4)
  %137 = shl i64 %136, 4
; # (ofs $Chr64 (shl (& N 3) 4))
  %138 = getelementptr i8, i8* bitcast ([65 x i8]* @$Chr64 to i8*), i64 %137
; # (val (ofs $Chr64 (shl (& N 3) 4)))
  %139 = load i8, i8* %138
; # (call $Put (val (ofs $Chr64 (shl (& N 3) 4))))
  %140 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %140(i8 %139)
; # (call $Put (char "="))
  %141 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %141(i8 61)
; # (call $Put (char "="))
  %142 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %142(i8 61)
; # (ret $Nil)
  ret i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
$36:
  %143 = phi i64 [%122, %$30] ; # X
  %144 = phi i64 [%115, %$30] ; # N
; # (let M (xCnt Exe @) (call $Put (val (ofs $Chr64 (| (shl (& N 3) 4...
; # (xCnt Exe @)
  %145 = call i64 @xCnt(i64 %0, i64 %132)
; # (& N 3)
  %146 = and i64 %144, 3
; # (shl (& N 3) 4)
  %147 = shl i64 %146, 4
; # (shr M 4)
  %148 = lshr i64 %145, 4
; # (| (shl (& N 3) 4) (shr M 4))
  %149 = or i64 %147, %148
; # (ofs $Chr64 (| (shl (& N 3) 4) (shr M 4)))
  %150 = getelementptr i8, i8* bitcast ([65 x i8]* @$Chr64 to i8*), i64 %149
; # (val (ofs $Chr64 (| (shl (& N 3) 4) (shr M 4))))
  %151 = load i8, i8* %150
; # (call $Put (val (ofs $Chr64 (| (shl (& N 3) 4) (shr M 4)))))
  %152 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %152(i8 %151)
; # (when (nil? (eval (cadr X))) (call $Put (val (ofs $Chr64 (shl (& ...
; # (cadr X)
  %153 = inttoptr i64 %143 to i64*
  %154 = getelementptr i64, i64* %153, i32 1
  %155 = load i64, i64* %154
  %156 = inttoptr i64 %155 to i64*
  %157 = load i64, i64* %156
; # (eval (cadr X))
  %158 = and i64 %157, 6
  %159 = icmp ne i64 %158, 0
  br i1 %159, label %$39, label %$38
$39:
  br label %$37
$38:
  %160 = and i64 %157, 8
  %161 = icmp ne i64 %160, 0
  br i1 %161, label %$41, label %$40
$41:
  %162 = inttoptr i64 %157 to i64*
  %163 = load i64, i64* %162
  br label %$37
$40:
  %164 = call i64 @evList(i64 %157)
  br label %$37
$37:
  %165 = phi i64 [%157, %$39], [%163, %$41], [%164, %$40] ; # ->
; # (nil? (eval (cadr X)))
  %166 = icmp eq i64 %165, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %166, label %$42, label %$43
$42:
  %167 = phi i64 [%143, %$37] ; # X
  %168 = phi i64 [%144, %$37] ; # N
; # (& M 15)
  %169 = and i64 %145, 15
; # (shl (& M 15) 2)
  %170 = shl i64 %169, 2
; # (ofs $Chr64 (shl (& M 15) 2))
  %171 = getelementptr i8, i8* bitcast ([65 x i8]* @$Chr64 to i8*), i64 %170
; # (val (ofs $Chr64 (shl (& M 15) 2)))
  %172 = load i8, i8* %171
; # (call $Put (val (ofs $Chr64 (shl (& M 15) 2))))
  %173 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %173(i8 %172)
; # (call $Put (char "="))
  %174 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %174(i8 61)
; # (ret $Nil)
  ret i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
$43:
  %175 = phi i64 [%143, %$37] ; # X
  %176 = phi i64 [%144, %$37] ; # N
; # (xCnt Exe @)
  %177 = call i64 @xCnt(i64 %0, i64 %165)
; # (& M 15)
  %178 = and i64 %145, 15
; # (shl (& M 15) 2)
  %179 = shl i64 %178, 2
; # (shr N 6)
  %180 = lshr i64 %177, 6
; # (| (shl (& M 15) 2) (shr N 6))
  %181 = or i64 %179, %180
; # (ofs $Chr64 (| (shl (& M 15) 2) (shr N 6)))
  %182 = getelementptr i8, i8* bitcast ([65 x i8]* @$Chr64 to i8*), i64 %181
; # (val (ofs $Chr64 (| (shl (& M 15) 2) (shr N 6))))
  %183 = load i8, i8* %182
; # (call $Put (val (ofs $Chr64 (| (shl (& M 15) 2) (shr N 6)))))
  %184 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %184(i8 %183)
; # (& N 63)
  %185 = and i64 %177, 63
; # (ofs $Chr64 (& N 63))
  %186 = getelementptr i8, i8* bitcast ([65 x i8]* @$Chr64 to i8*), i64 %185
; # (val (ofs $Chr64 (& N 63)))
  %187 = load i8, i8* %186
; # (call $Put (val (ofs $Chr64 (& N 63))))
  %188 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %188(i8 %187)
  br label %$2
$2:
  %189 = phi i64 [%98, %$12], [%113, %$29], [%175, %$43] ; # X
  %190 = phi i64 [%100, %$12], [%111, %$29], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64), %$43] ; # ->
  ret i64 %190
}

pil21/src/ht.l0000644000000000000000000002535514645230311010263 0ustar  # 15jul24 Software Lab. Alexander Burger

(symbols '(llvm))

(begin "ht" T
   "vers.l" "defs.l" "glob.l" "dec.l" )

(local) (Prin Fmt Pack Read In Out)

# External declarations
(local) (prin symByte prExt begString tglString endString findSym prSym
mkChar evCnt getChar)

(de T void prin (any))
(de T i8 symByte (i64*))
(de T void prExt (any))
(de T void begString (i64*))
(de T void tglString (i64*))
(de T endString ())
(de T i1 findSym (any any any))
(de T void prSym (any))
(de T mkChar (i32))
(de T i64 evCnt (any any))
(de T i32 getChar (i32))

# (ht:Prin 'sym ..) -> sym
(de Prin (Exe)
   (let X (cdr Exe)
      (loop
         (let Y (eval (car X))
            (unless (nil? Y)
               (if
                  (or
                     (num? Y)
                     (pair Y)
                     (sym? (val (tail Y))) )
                  (prin Y)
                  (let P (push 0 (name (val (tail Y))))  # [cnt name]
                     (while (symByte P)
                        (case @
                           ((char "<") (outString ($ "<")))
                           ((char ">") (outString ($ ">")))
                           ((char "&") (outString ($ "&")))
                           ((char "\"") (outString ($ """)))
                           ((hex "FF")
                              (call $Put (hex "F7"))
                              (call $Put (hex "BF"))
                              (call $Put (hex "BF"))
                              (call $Put (hex "BF")) )
                           (T
                              (let B @
                                 (call $Put B)
                                 (when (& B (hex "80"))  # Multi-byte
                                    (call $Put (symByte P))  # Second byte
                                    (when (& B (hex "20"))
                                       (call $Put (symByte P))  # Third byte
                                       (when (& B (hex "10"))
                                          (call $Put (symByte P)) ) ) ) ) ) ) ) ) ) )  # Fourth byte
            (? (atom (shift X)) Y) ) ) ) )

(local) (putHex htEncode htFmt)

(de void putHex ((i8 . B))
   (call $Put (char "%"))  # Prefix with "%"
   (call $Put  # Upper nibble
      (+
         (if (> (& (shr B 4) 15) 9)
            (+ @ 7)
            @ )
         (char "0") ) )
   (call $Put  # Lower nibble
      (+
         (if (> (& B 15) 9)
            (+ @ 7)
            @ )
         (char "0") ) ) )

(de void htEncode ((i8 . B) (i64* . P))
   (while B
      (if (strchr ($ " \"#%&:;<=>?\\_") (i32 B))
         (putHex B)
         (call $Put B)
         (when (& B (hex "80"))  # Multi-byte
            (call $Put (symByte P))  # Second byte
            (when (& B (hex "20"))
               (call $Put (symByte P))  # Third byte
               (when (& B (hex "10"))
                  (call $Put (symByte P)) ) ) ) )  # Fourth byte
      (setq B (symByte P)) ) )

(de void htFmt (X)
   (cond
      ((nil? X))
      ((num? X)
         (call $Put (char "+"))  # Prefix with "+"
         (prin X) )
      ((pair X)
         (loop
            (call $Put (char "_"))  # Prefix with "_"
            (htFmt (++ X))
            (? (atom X)) ) )
      ((sym? (val (tail X)))  # External symbol
         (call $Put (char "-"))  # Prefix with "-"
         (prExt (name (& @ -9))) )
      ((== (name @) ZERO))
      (T
         (let (Nm @  P (push 0 Nm)  B (symByte P))  # [cnt name]
            (cond
               ((findSym X Nm (val $Intern))  # Internal symbol
                  (call $Put (char "$"))  # Prefix with "$"
                  (htEncode B P) )
               ((or  # Special
                     (== B (char "$"))
                     (== B (char "+"))
                     (== B (char "-")) )
                  (putHex B)
                  (htEncode (symByte P) P) )
               (T (htEncode B P)) ) ) ) ) )

# (ht:Fmt 'any ..) -> sym
(de Fmt (Exe)
   (let (X (cdr Exe)  P (push 4 NIL ZERO NIL NIL NIL))  # [cnt last name link fun ptr]
      (begString P)
      (loop
         (htFmt
            (prog2
               (tglString P)
               (eval (car X))
               (tglString P) ) )
         (? (atom (shift X)))
         (call $Put (char "&")) )
      (endString) ) )

(local) (getHex head)

(de i8 getHex (Sym)
   (if (> (- (firstByte Sym) (char "0")) 9)
      (- (& @ (hex "DF")) 7)
      @ ) )

(de head ((i8* . S) Lst)
   (let B (val S)
      (loop
         (? (<> B (firstByte (++ Lst))) 0)
         (? (=0 (setq B (val (inc 'S)))) Lst) ) ) )

# (ht:Pack 'lst ['flg']) -> sym
(de Pack (Exe)
   (let
      (X (cdr Exe)
         Lst (save (eval (++ X)))
         Flg (nil? (eval (car X))) )
      (begString (push 4 NIL ZERO NIL NIL NIL))  # [cnt last name link fun ptr]
      (while (pair Lst)
         (let (C (++ Lst)  B (firstByte C))
            (cond
               ((== B (char "%"))  # Hex-escaped
                  (call $Put
                     (if Flg
                        B
                        (|
                           (shl (getHex (++ Lst)) 4)  # Upper nibble
                           (getHex (++ Lst)) ) ) ) )  # Lower nibble
               ((<> B (char "&")) (prSym C))  # Normal character
               ((head ($ "lt;") Lst)
                  (call $Put (char "<"))
                  (setq Lst @) )
               ((head ($ "gt;") Lst)
                  (call $Put (char ">"))
                  (setq Lst @) )
               ((head ($ "amp;") Lst)
                  (call $Put (char "&"))
                  (setq Lst @) )
               ((head ($ "quot;") Lst)
                  (call $Put (char "\""))
                  (setq Lst @) )
               ((head ($ "nbsp;") Lst)
                  (call $Put (char " "))
                  (setq Lst @) )
               ((== (firstByte (car Lst)) (char "#"))
                  (let
                     (L (shift Lst)
                        D (firstByte (++ L))  # Digit
                        N (i32 (- D (char "0"))) )  # Character
                     (loop
                        (?
                           (or
                              (> (char "0") D)
                              (> D (char "9")) )
                           (call $Put (char "&"))
                           (call $Put (char "#")) )
                        (? (== (setq D (firstByte (++ L))) (char ";"))
                           (prSym (mkChar N))
                           (setq Lst L) )
                        (setq N
                           (+
                              (* N 10)
                              (i32 (- D (char "0"))) ) ) ) ) )
               (T (call $Put (char "&"))) ) ) )
      (endString) ) )

# Read content length bytes
# (ht:Read 'cnt) -> lst
(de Read (Exe)
   (let (N (evCnt Exe (cdr Exe))  C (val $Chr))
      (if
         (or
            (le0 N)
            (and
               (=0 C)
               (lt0 (setq C (call $Get))) ) )
         $Nil
         (let C (getChar C)
            (when (>= C (hex "80"))  # Multi-byte
               (dec 'N)
               (when (>= C (hex "800"))
                  (dec 'N)
                  (when (>= C (hex "10000"))
                     (dec 'N) ) ) )
            (if (lt0 (dec 'N))
               $Nil
               (let (X (cons (mkChar C) $Nil)  R (save X))
                  (loop
                     (? (=0 N) (set $Chr 0) R)
                     (? (lt0 (setq C (call $Get))) $Nil)
                     (setq C (getChar C))
                     (when (>= C (hex "80"))  # Multi-byte
                        (dec 'N)
                        (when (>= C (hex "800"))
                           (dec 'N)
                           (when (>= C (hex "10000"))
                              (dec 'N) ) ) )
                     (? (lt0 (dec 'N)) $Nil)
                     (setq X
                        (set 2 X (cons (mkChar C) $Nil)) ) ) ) ) ) ) ) )

# Chunked Encoding
(local) (CHUNK $CnkCnt $SvGet $SvPut $CnkBuf)

(setq CHUNK 4000)
(var $CnkCnt i32 0)  # Chunk size count
(var $SvGet (i32) null)  # Saved $Get function
(var $SvPut (void i8) null)  # Saved $Put function
(array $CnkBuf i8 . CHUNK)  # Chunk buffer

(local) (chrHex chunkSize getChunked)

(de i32 chrHex ((i32 . C))
   (cond
      ((and
            (>= C (char "0"))
            (>= (char "9") C) )
         (- C 48) )  # Decimal digit
      ((and
            (>=
               (setq C (& C (hex "DF")))
               (char "A") )
            (>= (char "F") C) )
         (- C 55) )  # Hex letter
      (T -1) ) )

(de void chunkSize ()
   (let C (if (val $Chr) @ (call $SvGet))
      (when (ge0 (set $CnkCnt (chrHex C)))
         (while (ge0 (chrHex (setq C (call $SvGet))))
            (set $CnkCnt (| @ (shl (val $CnkCnt) 4))) )
         (loop
            (? (== C (char "\n"))
               (call $SvGet)
               (when (=0 (val $CnkCnt))
                  (call $SvGet)  # Skip '\r' of empty line
                  (set $Chr 0) ) )
            (? (lt0 C))
            (setq C (call $SvGet)) ) ) ) )

(de i32 getChunked ()
   (if (le0 (val $CnkCnt))
      (set $Chr -1)  # Return EOF
      (call $SvGet)
      (when (=0 (set $CnkCnt (dec @)))  # Decrement count
         (call $SvGet)  # Skip '\n' and '\r'
         (call $SvGet)
         (chunkSize) )
      (val $Chr) ) )

# (ht:In 'flg . prg) -> any
(de In (Exe)
   (let X (cdr Exe)
      (if (nil? (eval (++ X)))  # 'flg'
         (run X)  # 'prg'
         (set
            (i8** $SvGet) (val (i8** $Get))
            $Get (fun (i32) getChunked) )
         (chunkSize)
         (prog1
            (run X)  # 'prg'
            (set (i8** $Get) (val (i8** $SvGet)))
            (set $Chr 0) ) ) ) )

(local) (outHex wrChunk putChunked)

(de void outHex ((i32 . N))
   (when (> N 15)
      (outHex (shr N 4))
      (setq N (& N 15)) )
   (when (> N 9)
      (setq N (+ N 39)) )  # Make lower case letter
   (call $SvPut (+ (i8 N) (char "0"))) )

(de void wrChunk ((i32 . Cnt))
   (outHex Cnt)  # Print count as hex
   (call $SvPut (char "\r"))
   (call $SvPut (char "\n"))
   (let P $CnkBuf  # Output chunk buffer
      (loop
         (call $SvPut (val P))
         (? (=0 (dec 'Cnt)))
         (inc 'P) ) )
   (call $SvPut (char "\r"))
   (call $SvPut (char "\n")) )

(de void putChunked ((i8 . B))
   (let I (val $CnkCnt)
      (set (ofs $CnkBuf I) B)
      (ifn (== (inc I) CHUNK)
         (set $CnkCnt @)
         (wrChunk @)
         (set $CnkCnt 0) ) ) )

# (ht:Out 'flg . prg) -> any
(de Out (Exe)
   (let (X (cdr Exe)  F (eval (++ X)))
      (if (nil? F)  # 'flg'
         (setq X (run X))  # 'prg'
         (set
            $CnkCnt 0  # Clear count
            (i8** $SvPut) (val (i8** $Put))
            $Put (fun (void i8) putChunked) )
         (setq X (run X))  # 'prg'
         (when (val $CnkCnt)
            (wrChunk @) )
         (set (i8** $Put) (val (i8** $SvPut)))
         (unless (t? F)
            (outString ($ "0\r\n\r\n")) ) )
      (flush (val $OutFile))
      X ) )

(end)
pil21/src/ht.ll0000644000000000000000000020246414771742747010462 0ustar  source_filename = "ht.l"

declare {i64, i1} @llvm.uadd.with.overflow.i64(i64, i64)
declare {i64, i1} @llvm.usub.with.overflow.i64(i64, i64)
declare i64 @llvm.fshl.i64(i64, i64, i64)
declare i64 @llvm.fshr.i64(i64, i64, i64)
declare void @llvm.memcpy.p0i8.p0i8.i64(i8*, i8*, i64, i1)
declare void @llvm.memset.p0i8.i64(i8*, i8, i64, i1)
declare i8* @llvm.stacksave()
declare void @llvm.stackrestore(i8*)

@$AV0 = external global i8*
@$AV = external global i8**
@$PilHome = external global i8*
@$PilLen = external global i64
@$UsrHome = external global i8*
@$UsrLen = external global i64
@$Heaps = external global i64
@$Avail = external global i64
@$Extern = external global i64
@$ExtCnt = external global i64
@$ExtSkip = external global i64
@$Coroutines = external global i8*
@$Current = external global i8*
@$CrtLast = external global i8*
@$CrtFree = external global i8*
@$StkLimit = external global i8*
@$StkSizeT = external global i64
@$StkSize = external global i64
@$Stdin = external global i8*
@$Stdout = external global i8*
@$LinePtr = external global i8*
@$LineBuf = external global i8*
@$LinePrmt = external global i8*
@$ReplPrmt = external global i8*
@$ContPrmt = external global i8*
@$Ret = external global i64
@$TtyPid = external global i32
@$InFDs = external global i32
@$InFiles = external global i8**
@$OutFiles = external global i8**
@$IoCnt = external global i32
@$IoIx = external global i64
@$IoChar = external global i64
@$PutBin = external global void(i8)*
@$GetBin = external global i32()*
@$OutFDs = external global i32
@$Nfds = external global i32
@$Poll = external global i64*
@$SeedL = external global i64
@$SeedH = external global i64
@$USec = external global i64
@$Rt = external global i64
@$Child = external global i8*
@$Children = external global i32
@$Slot = external global i32
@$Spkr = external global i32
@$Mic = external global i32
@$SpMiPipe = external global [2 x i32]
@$Talking = external global i32
@$Hear = external global i32
@$Tell = external global i32
@$TellBuf = external global i8*
@$Ptr = external global i8*
@$End = external global i8*
@$BufX = external global i8*
@$PtrX = external global i8*
@$EndX = external global i8*
@$ExtN = external global i32
@$Extn = external global i32
@$StrP = external global i64*
@$GcCount = external global i64
@$DbFiles = external global i8*
@$DbFile = external global i8*
@$DBs = external global i32
@$MaxBlkSize = external global i32
@$DbBlock = external global i8*
@$BlkIndex = external global i64
@$BlkLink = external global i64
@$BlkPtr = external global i8*
@$BlkEnd = external global i8*
@$DbJnl = external global i8*
@$DbLog = external global i8*
@$Signal = external global [16 x i32]
@SymTab = external global [888 x i64]
@gcData = external global [53 x i64]
@cbFuns = external global [24 x i64]
@env = external global [25 x i64]
@$Cell = external global [2 x i64]
@$Version = external global [3 x i64]
@$TBuf = external global [2 x i8]
@$Month = external global [13 x i8]
@$Repl = external global i1
@$PRepl = external global i1
@$Tc = external global i1
@$Jam = external global i1
@$InBye = external global i1
@$Sync = external global i1
@$Empty = constant [1 x i8] c"\00"
@$Delim = constant [16 x i8] c" \09\0A\0D\22'(),[]`{}~\00"
declare i8* @malloc(i64)
declare i8* @realloc(i8*, i64)
declare void @free(i8*)
declare i32 @fork()
declare i8* @getenv(i8*)
declare i32 @setenv(i8*, i8*, i32)
declare i8* @getcwd(i8*, i64)
declare i32 @chdir(i8*)
declare i32 @getpid()
declare i32 @getpgrp()
declare i32 @setsid()
declare i32 @alarm(i32)
declare i32 @setpgid(i32, i32)
declare i32 @execvp(i8*, i8**)
declare i32 @isatty(i32)
declare i32 @openpty(i32*, i32*, i8*, i8*, i8*)
declare i32 @login_tty(i32)
declare i32 @tcgetattr(i32, i8*)
declare i32 @tcgetpgrp(i32)
declare i32 @tcsetpgrp(i32, i32)
declare i64 @read(i32, i8*, i64)
declare i64 @write(i32, i8*, i64)
declare i64 @pread(i32, i8*, i64, i64)
declare i64 @pwrite(i32, i8*, i64, i64)
declare i32 @fread(i8*, i64, i64, i8*)
declare i32 @fwrite(i8*, i64, i64, i8*)
declare i32 @putc_unlocked(i32, i8*)
declare i32 @getc_unlocked(i8*)
declare i8* @fopen(i8*, i8*)
declare i32 @fflush(i8*)
declare i32 @feof(i8*)
declare i32 @fclose(i8*)
declare i32 @fileno(i8*)
declare i32 @fsync(i32)
declare i32 @pipe(i32*)
declare i32 @memcmp(i8*, i8*, i64)
declare i64 @strlen(i8*)
declare i8* @strcpy(i8*, i8*)
declare i8* @strdup(i8*)
declare i32 @strcmp(i8*, i8*)
declare i8* @strchr(i8*, i32)
declare i8* @strrchr(i8*, i32)
declare i8* @dlsym(i8*, i8*)
declare i8* @dlerror()
declare i32 @dup(i32)
declare i32 @dup2(i32, i32)
declare i32 @close(i32)
declare i8* @signal(i32, i8*)
declare i32 @waitpid(i32, i32*, i32)
declare i32 @poll(i64*, i32, i64)
declare i32 @setjmp(i8*)
declare void @longjmp(i8*, i32)
declare i32 @kill(i32, i32)
declare void @exit(i32)
declare void @add_history(i8*)
declare i8*** @history_list()
declare void @clear_history()
@TgOS = external global i8
@TgCPU = external global i8
@PipeBufSize = external global i32
@Fsign = external global i1
@Fdigit = external global i64
declare i8* @stderrMsg(i8*, i8*)
declare void @gPrintf(i8*, i32, i8*, i8*)
declare i8* @strErrno()
declare i32 @openRd(i8*)
declare i32 @openWr(i8*)
declare i32 @openRdWr(i8*)
declare i32 @openRdWrExcl(i8*)
declare i32 @openRdWrCreate(i8*)
declare i32 @openRdWrAppend(i8*)
declare i32 @openWrAppend(i8*)
declare i1 @fseekOfs(i8*, i32)
declare i1 @fseek0(i8*)
declare i1 @seek0(i32)
declare i1 @truncate0(i32)
declare i32 @socketPair(i32*)
declare i32 @fcntlCloExec(i32)
declare void @fcntlSetFl(i32, i32)
declare i32 @nonBlocking(i32)
declare void @fcntlSetOwn(i32, i32)
declare i8* @getDir(i8*)
declare void @initReadline()
declare i8* @gReadline(i8*)
declare void @rlHide()
declare void @rlShow()
declare void @rlSigBeg()
declare void @rlSigEnd()
declare i8* @currentLine()
@Sig = external global i32
@SigDfl = external global i8*
@SigIgn = external global i8*
declare i32 @gSignal(i32)
declare void @iSignal(i32, i8*)
declare void @sigUnblock(i32)
declare void @sigChld(i32)
declare i32 @waitWuntraced(i32, i32*)
declare i32 @wifStopped(i32*)
declare i32 @nErrno()
declare i32 @gErrno()
@Tio = external global i1
@OrgTermio = external global i8
@Termio = external global i8*
declare void @stopTerm()
declare void @setRaw()
declare void @setCooked()
declare i1 @reopenTty(i8*)
declare i64 @getUsec(i1)
declare i64 @getMsec()
declare i64 @getDate()
declare i64 @getGmDate()
declare i64 @getTime()
declare i64 @getGmTime()
declare i8* @ulimStk()
declare i64 @fileInfo(i1, i1, i8*, i64*)
declare void @pollIn(i32, i64*)
declare void @pollOut(i32, i64*)
declare void @pollIgn(i64*)
declare i32 @gPoll(i64*, i32, i64)
declare i1 @readyIn(i64*)
declare i1 @readyOut(i64*)
declare i32 @rdLock(i32, i64, i64, i1)
declare i32 @wrLock(i32, i64, i64, i1)
declare i32 @unLock(i32, i64, i64)
declare i32 @getLock(i32, i64, i64)
@JmpBufSize = external global i64
@QuitRst = external global i8
declare i8* @dlOpen(i8*)
declare i8* @ffiPrep(i8*, i8*, i64)
declare i64 @ffiCall(i8*, i64)
declare i64 @boxFloat(i32, i64)
declare i64 @boxFlt()
declare i64 @boxDouble(i64, i64)
declare i64 @boxDbl()
declare void @bufFloat(i64, i64, i8*)
declare void @bufDouble(i64, i64, i8*)
declare i1 @chance(i64)
declare i1 @isLowc(i32)
declare i1 @isUppc(i32)
declare i1 @isLetterOrDigit(i32)
declare i32 @toUpperCase(i32)
declare i32 @toLowerCase(i32)
declare i64 @dbg(i64, i64)
declare i1 @equal(i64, i64)
declare i64 @compare(i64, i64)
declare i64 @evList(i64)
declare i64 @cons(i64, i64)
declare i64 @cons2(i64, i64, i64)
declare i64 @cons3(i64, i64, i64, i64)
declare i64 @consStr(i64)
declare i64 @bufSize(i64)
declare i8* @bufString(i64, i8*)
declare i64 @mkStr(i8*)
declare i8 @firstByte(i64)
declare void @pack(i64, i64*)
declare i1 @subStr(i64, i64)
declare i1 @flush(i8*)
declare void @flushAll()
declare void @newline()
declare void @space()
declare void @outWord(i64)
declare void @outString(i8*)
declare void @print(i64)
declare i64 @repl(i64, i8*, i64)
declare void @dbFetch(i64, i64)
declare void @dbTouch(i64, i64)
declare void @dbZap(i64)
declare void @putSrc(i64, i64)
declare i64 @brkLoad(i64)
declare void @prin(i64)
declare i8 @symByte(i64*)
declare void @prExt(i64)
declare void @begString(i64*)
declare void @tglString(i64*)
declare i64 @endString()
declare i1 @findSym(i64, i64, i64)
declare void @prSym(i64)
declare i64 @mkChar(i32)
declare i64 @evCnt(i64, i64)
declare i32 @getChar(i32)

define i64 @Prin(i64) align 8 {
$1:
; # (let X (cdr Exe) (loop (let Y (eval (car X)) (unless (nil? Y) (if...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (loop (let Y (eval (car X)) (unless (nil? Y) (if (or (num? Y) (pa...
  br label %$2
$2:
  %4 = phi i64 [%3, %$1], [%88, %$35] ; # X
; # (let Y (eval (car X)) (unless (nil? Y) (if (or (num? Y) (pair Y) ...
; # (car X)
  %5 = inttoptr i64 %4 to i64*
  %6 = load i64, i64* %5
; # (eval (car X))
  %7 = and i64 %6, 6
  %8 = icmp ne i64 %7, 0
  br i1 %8, label %$5, label %$4
$5:
  br label %$3
$4:
  %9 = and i64 %6, 8
  %10 = icmp ne i64 %9, 0
  br i1 %10, label %$7, label %$6
$7:
  %11 = inttoptr i64 %6 to i64*
  %12 = load i64, i64* %11
  br label %$3
$6:
  %13 = call i64 @evList(i64 %6)
  br label %$3
$3:
  %14 = phi i64 [%6, %$5], [%12, %$7], [%13, %$6] ; # ->
; # (unless (nil? Y) (if (or (num? Y) (pair Y) (sym? (val (tail Y))))...
; # (nil? Y)
  %15 = icmp eq i64 %14, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %15, label %$9, label %$8
$8:
  %16 = phi i64 [%4, %$3] ; # X
; # (if (or (num? Y) (pair Y) (sym? (val (tail Y)))) (prin Y) (let P ...
; # (or (num? Y) (pair Y) (sym? (val (tail Y))))
; # (num? Y)
  %17 = and i64 %14, 6
  %18 = icmp ne i64 %17, 0
  br i1 %18, label %$10, label %$11
$11:
  %19 = phi i64 [%16, %$8] ; # X
; # (pair Y)
  %20 = and i64 %14, 15
  %21 = icmp eq i64 %20, 0
  br i1 %21, label %$10, label %$12
$12:
  %22 = phi i64 [%19, %$11] ; # X
; # (tail Y)
  %23 = add i64 %14, -8
; # (val (tail Y))
  %24 = inttoptr i64 %23 to i64*
  %25 = load i64, i64* %24
; # (sym? (val (tail Y)))
  %26 = and i64 %25, 8
  %27 = icmp ne i64 %26, 0
  br label %$10
$10:
  %28 = phi i64 [%16, %$8], [%19, %$11], [%22, %$12] ; # X
  %29 = phi i1 [1, %$8], [1, %$11], [%27, %$12] ; # ->
  br i1 %29, label %$13, label %$14
$13:
  %30 = phi i64 [%28, %$10] ; # X
; # (prin Y)
  call void @prin(i64 %14)
  br label %$15
$14:
  %31 = phi i64 [%28, %$10] ; # X
; # (let P (push 0 (name (val (tail Y)))) (while (symByte P) (case @ ...
; # (tail Y)
  %32 = add i64 %14, -8
; # (val (tail Y))
  %33 = inttoptr i64 %32 to i64*
  %34 = load i64, i64* %33
; # (name (val (tail Y)))
  br label %$16
$16:
  %35 = phi i64 [%34, %$14], [%41, %$17] ; # Tail
  %36 = and i64 %35, 6
  %37 = icmp ne i64 %36, 0
  br i1 %37, label %$18, label %$17
$17:
  %38 = phi i64 [%35, %$16] ; # Tail
  %39 = inttoptr i64 %38 to i64*
  %40 = getelementptr i64, i64* %39, i32 1
  %41 = load i64, i64* %40
  br label %$16
$18:
  %42 = phi i64 [%35, %$16] ; # Tail
; # (push 0 (name (val (tail Y))))
  %43 = alloca i64, i64 2, align 16
  store i64 0, i64* %43
  %44 = getelementptr i64, i64* %43, i32 1
  store i64 %42, i64* %44
; # (while (symByte P) (case @ ((char "<") (outString ($ "<"))) ((...
  br label %$19
$19:
  %45 = phi i64 [%31, %$18], [%78, %$23] ; # X
; # (symByte P)
  %46 = call i8 @symByte(i64* %43)
  %47 = icmp ne i8 %46, 0
  br i1 %47, label %$20, label %$21
$20:
  %48 = phi i64 [%45, %$19] ; # X
; # (case @ ((char "<") (outString ($ "<"))) ((char ">") (outStrin...
  switch i8 %46, label %$22 [
    i8 60, label %$24
    i8 62, label %$25
    i8 38, label %$26
    i8 34, label %$27
    i8 255, label %$28
  ]
$24:
  %49 = phi i64 [%48, %$20] ; # X
; # (outString ($ "<"))
  call void @outString(i8* bitcast ([5 x i8]* @$1 to i8*))
  br label %$23
$25:
  %50 = phi i64 [%48, %$20] ; # X
; # (outString ($ ">"))
  call void @outString(i8* bitcast ([5 x i8]* @$2 to i8*))
  br label %$23
$26:
  %51 = phi i64 [%48, %$20] ; # X
; # (outString ($ "&"))
  call void @outString(i8* bitcast ([6 x i8]* @$3 to i8*))
  br label %$23
$27:
  %52 = phi i64 [%48, %$20] ; # X
; # (outString ($ """))
  call void @outString(i8* bitcast ([7 x i8]* @$4 to i8*))
  br label %$23
$28:
  %53 = phi i64 [%48, %$20] ; # X
; # (call $Put (hex "F7"))
  %54 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %54(i8 247)
; # (call $Put (hex "BF"))
  %55 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %55(i8 191)
; # (call $Put (hex "BF"))
  %56 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %56(i8 191)
; # (call $Put (hex "BF"))
  %57 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %57(i8 191)
  br label %$23
$22:
  %58 = phi i64 [%48, %$20] ; # X
; # (let B @ (call $Put B) (when (& B (hex "80")) (call $Put (symByte...
; # (call $Put B)
  %59 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %59(i8 %46)
; # (when (& B (hex "80")) (call $Put (symByte P)) (when (& B (hex "2...
; # (& B (hex "80"))
  %60 = and i8 %46, 128
  %61 = icmp ne i8 %60, 0
  br i1 %61, label %$29, label %$30
$29:
  %62 = phi i64 [%58, %$22] ; # X
; # (symByte P)
  %63 = call i8 @symByte(i64* %43)
; # (call $Put (symByte P))
  %64 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %64(i8 %63)
; # (when (& B (hex "20")) (call $Put (symByte P)) (when (& B (hex "1...
; # (& B (hex "20"))
  %65 = and i8 %46, 32
  %66 = icmp ne i8 %65, 0
  br i1 %66, label %$31, label %$32
$31:
  %67 = phi i64 [%62, %$29] ; # X
; # (symByte P)
  %68 = call i8 @symByte(i64* %43)
; # (call $Put (symByte P))
  %69 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %69(i8 %68)
; # (when (& B (hex "10")) (call $Put (symByte P)))
; # (& B (hex "10"))
  %70 = and i8 %46, 16
  %71 = icmp ne i8 %70, 0
  br i1 %71, label %$33, label %$34
$33:
  %72 = phi i64 [%67, %$31] ; # X
; # (symByte P)
  %73 = call i8 @symByte(i64* %43)
; # (call $Put (symByte P))
  %74 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %74(i8 %73)
  br label %$34
$34:
  %75 = phi i64 [%67, %$31], [%72, %$33] ; # X
  br label %$32
$32:
  %76 = phi i64 [%62, %$29], [%75, %$34] ; # X
  br label %$30
$30:
  %77 = phi i64 [%58, %$22], [%76, %$32] ; # X
  br label %$23
$23:
  %78 = phi i64 [%49, %$24], [%50, %$25], [%51, %$26], [%52, %$27], [%53, %$28], [%77, %$30] ; # X
  br label %$19
$21:
  %79 = phi i64 [%45, %$19] ; # X
  br label %$15
$15:
  %80 = phi i64 [%30, %$13], [%79, %$21] ; # X
  br label %$9
$9:
  %81 = phi i64 [%4, %$3], [%80, %$15] ; # X
; # (? (atom (shift X)) Y)
; # (shift X)
  %82 = inttoptr i64 %81 to i64*
  %83 = getelementptr i64, i64* %82, i32 1
  %84 = load i64, i64* %83
; # (atom (shift X))
  %85 = and i64 %84, 15
  %86 = icmp ne i64 %85, 0
  br i1 %86, label %$37, label %$35
$37:
  %87 = phi i64 [%84, %$9] ; # X
  br label %$36
$35:
  %88 = phi i64 [%84, %$9] ; # X
  br label %$2
$36:
  %89 = phi i64 [%87, %$37] ; # X
  %90 = phi i64 [%14, %$37] ; # ->
  ret i64 %90
}

define void @putHex(i8) align 8 {
$1:
; # (call $Put (char "%"))
  %1 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %1(i8 37)
; # (if (> (& (shr B 4) 15) 9) (+ @ 7) @)
; # (shr B 4)
  %2 = lshr i8 %0, 4
; # (& (shr B 4) 15)
  %3 = and i8 %2, 15
; # (> (& (shr B 4) 15) 9)
  %4 = icmp ugt i8 %3, 9
  br i1 %4, label %$2, label %$3
$2:
; # (+ @ 7)
  %5 = add i8 %3, 7
  br label %$4
$3:
  br label %$4
$4:
  %6 = phi i8 [%5, %$2], [%3, %$3] ; # ->
; # (+ (if (> (& (shr B 4) 15) 9) (+ @ 7) @) (char "0"))
  %7 = add i8 %6, 48
; # (call $Put (+ (if (> (& (shr B 4) 15) 9) (+ @ 7) @) (char "0")))
  %8 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %8(i8 %7)
; # (if (> (& B 15) 9) (+ @ 7) @)
; # (& B 15)
  %9 = and i8 %0, 15
; # (> (& B 15) 9)
  %10 = icmp ugt i8 %9, 9
  br i1 %10, label %$5, label %$6
$5:
; # (+ @ 7)
  %11 = add i8 %9, 7
  br label %$7
$6:
  br label %$7
$7:
  %12 = phi i8 [%11, %$5], [%9, %$6] ; # ->
; # (+ (if (> (& B 15) 9) (+ @ 7) @) (char "0"))
  %13 = add i8 %12, 48
; # (call $Put (+ (if (> (& B 15) 9) (+ @ 7) @) (char "0")))
  %14 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %14(i8 %13)
  ret void
}

define void @htEncode(i8, i64*) align 8 {
$1:
; # (while B (if (strchr ($ " \"#%&:;<=>?\\_") (i32 B)) (putHex B) (c...
  br label %$2
$2:
  %2 = phi i8 [%0, %$1], [%30, %$7] ; # B
  %3 = icmp ne i8 %2, 0
  br i1 %3, label %$3, label %$4
$3:
  %4 = phi i8 [%2, %$2] ; # B
; # (if (strchr ($ " \"#%&:;<=>?\\_") (i32 B)) (putHex B) (call $Put ...
; # (i32 B)
  %5 = zext i8 %4 to i32
; # (strchr ($ " \"#%&:;<=>?\\_") (i32 B))
  %6 = call i8* @strchr(i8* bitcast ([14 x i8]* @$5 to i8*), i32 %5)
  %7 = icmp ne i8* %6, null
  br i1 %7, label %$5, label %$6
$5:
  %8 = phi i8 [%4, %$3] ; # B
; # (putHex B)
  call void @putHex(i8 %8)
  br label %$7
$6:
  %9 = phi i8 [%4, %$3] ; # B
; # (call $Put B)
  %10 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %10(i8 %9)
; # (when (& B (hex "80")) (call $Put (symByte P)) (when (& B (hex "2...
; # (& B (hex "80"))
  %11 = and i8 %9, 128
  %12 = icmp ne i8 %11, 0
  br i1 %12, label %$8, label %$9
$8:
  %13 = phi i8 [%9, %$6] ; # B
; # (symByte P)
  %14 = call i8 @symByte(i64* %1)
; # (call $Put (symByte P))
  %15 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %15(i8 %14)
; # (when (& B (hex "20")) (call $Put (symByte P)) (when (& B (hex "1...
; # (& B (hex "20"))
  %16 = and i8 %13, 32
  %17 = icmp ne i8 %16, 0
  br i1 %17, label %$10, label %$11
$10:
  %18 = phi i8 [%13, %$8] ; # B
; # (symByte P)
  %19 = call i8 @symByte(i64* %1)
; # (call $Put (symByte P))
  %20 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %20(i8 %19)
; # (when (& B (hex "10")) (call $Put (symByte P)))
; # (& B (hex "10"))
  %21 = and i8 %18, 16
  %22 = icmp ne i8 %21, 0
  br i1 %22, label %$12, label %$13
$12:
  %23 = phi i8 [%18, %$10] ; # B
; # (symByte P)
  %24 = call i8 @symByte(i64* %1)
; # (call $Put (symByte P))
  %25 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %25(i8 %24)
  br label %$13
$13:
  %26 = phi i8 [%18, %$10], [%23, %$12] ; # B
  br label %$11
$11:
  %27 = phi i8 [%13, %$8], [%26, %$13] ; # B
  br label %$9
$9:
  %28 = phi i8 [%9, %$6], [%27, %$11] ; # B
  br label %$7
$7:
  %29 = phi i8 [%8, %$5], [%28, %$9] ; # B
; # (symByte P)
  %30 = call i8 @symByte(i64* %1)
  br label %$2
$4:
  %31 = phi i8 [%2, %$2] ; # B
  ret void
}

define void @htFmt(i64) align 8 {
$1:
; # (cond ((nil? X)) ((num? X) (call $Put (char "+")) (prin X)) ((pai...
; # (nil? X)
  %1 = icmp eq i64 %0, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %1, label %$2, label %$3
$3:
  %2 = phi i64 [%0, %$1] ; # X
; # (num? X)
  %3 = and i64 %2, 6
  %4 = icmp ne i64 %3, 0
  br i1 %4, label %$5, label %$4
$5:
  %5 = phi i64 [%2, %$3] ; # X
; # (call $Put (char "+"))
  %6 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %6(i8 43)
; # (prin X)
  call void @prin(i64 %5)
  br label %$2
$4:
  %7 = phi i64 [%2, %$3] ; # X
; # (pair X)
  %8 = and i64 %7, 15
  %9 = icmp eq i64 %8, 0
  br i1 %9, label %$7, label %$6
$7:
  %10 = phi i64 [%7, %$4] ; # X
; # (loop (call $Put (char "_")) (htFmt (++ X)) (? (atom X)))
  br label %$8
$8:
  %11 = phi i64 [%10, %$7], [%19, %$9] ; # X
; # (call $Put (char "_"))
  %12 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %12(i8 95)
; # (++ X)
  %13 = inttoptr i64 %11 to i64*
  %14 = load i64, i64* %13
  %15 = getelementptr i64, i64* %13, i32 1
  %16 = load i64, i64* %15
; # (htFmt (++ X))
  call void @htFmt(i64 %14)
; # (? (atom X))
; # (atom X)
  %17 = and i64 %16, 15
  %18 = icmp ne i64 %17, 0
  br i1 %18, label %$10, label %$9
$9:
  %19 = phi i64 [%16, %$8] ; # X
  br label %$8
$10:
  %20 = phi i64 [%16, %$8] ; # X
  %21 = phi i64 [0, %$8] ; # ->
  br label %$2
$6:
  %22 = phi i64 [%7, %$4] ; # X
; # (tail X)
  %23 = add i64 %22, -8
; # (val (tail X))
  %24 = inttoptr i64 %23 to i64*
  %25 = load i64, i64* %24
; # (sym? (val (tail X)))
  %26 = and i64 %25, 8
  %27 = icmp ne i64 %26, 0
  br i1 %27, label %$12, label %$11
$12:
  %28 = phi i64 [%22, %$6] ; # X
; # (call $Put (char "-"))
  %29 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %29(i8 45)
; # (& @ -9)
  %30 = and i64 %25, -9
; # (name (& @ -9))
  br label %$13
$13:
  %31 = phi i64 [%30, %$12], [%37, %$14] ; # Tail
  %32 = and i64 %31, 6
  %33 = icmp ne i64 %32, 0
  br i1 %33, label %$15, label %$14
$14:
  %34 = phi i64 [%31, %$13] ; # Tail
  %35 = inttoptr i64 %34 to i64*
  %36 = getelementptr i64, i64* %35, i32 1
  %37 = load i64, i64* %36
  br label %$13
$15:
  %38 = phi i64 [%31, %$13] ; # Tail
; # (prExt (name (& @ -9)))
  call void @prExt(i64 %38)
  br label %$2
$11:
  %39 = phi i64 [%22, %$6] ; # X
; # (name @)
  br label %$16
$16:
  %40 = phi i64 [%25, %$11], [%46, %$17] ; # Tail
  %41 = and i64 %40, 6
  %42 = icmp ne i64 %41, 0
  br i1 %42, label %$18, label %$17
$17:
  %43 = phi i64 [%40, %$16] ; # Tail
  %44 = inttoptr i64 %43 to i64*
  %45 = getelementptr i64, i64* %44, i32 1
  %46 = load i64, i64* %45
  br label %$16
$18:
  %47 = phi i64 [%40, %$16] ; # Tail
; # (== (name @) ZERO)
  %48 = icmp eq i64 %47, 2
  br i1 %48, label %$2, label %$19
$19:
  %49 = phi i64 [%39, %$18] ; # X
; # (let (Nm @ P (push 0 Nm) B (symByte P)) (cond ((findSym X Nm (val...
; # (push 0 Nm)
  %50 = alloca i64, i64 2, align 16
  store i64 0, i64* %50
  %51 = getelementptr i64, i64* %50, i32 1
  store i64 %47, i64* %51
; # (symByte P)
  %52 = call i8 @symByte(i64* %50)
; # (cond ((findSym X Nm (val $Intern)) (call $Put (char "$")) (htEnc...
; # (val $Intern)
  %53 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 0) to i64) to i64*
  %54 = load i64, i64* %53
; # (findSym X Nm (val $Intern))
  %55 = call i1 @findSym(i64 %49, i64 %47, i64 %54)
  br i1 %55, label %$22, label %$21
$22:
  %56 = phi i64 [%49, %$19] ; # X
; # (call $Put (char "$"))
  %57 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %57(i8 36)
; # (htEncode B P)
  call void @htEncode(i8 %52, i64* %50)
  br label %$20
$21:
  %58 = phi i64 [%49, %$19] ; # X
; # (or (== B (char "$")) (== B (char "+")) (== B (char "-")))
; # (== B (char "$"))
  %59 = icmp eq i8 %52, 36
  br i1 %59, label %$23, label %$24
$24:
  %60 = phi i64 [%58, %$21] ; # X
; # (== B (char "+"))
  %61 = icmp eq i8 %52, 43
  br i1 %61, label %$23, label %$25
$25:
  %62 = phi i64 [%60, %$24] ; # X
; # (== B (char "-"))
  %63 = icmp eq i8 %52, 45
  br label %$23
$23:
  %64 = phi i64 [%58, %$21], [%60, %$24], [%62, %$25] ; # X
  %65 = phi i1 [1, %$21], [1, %$24], [%63, %$25] ; # ->
  br i1 %65, label %$27, label %$26
$27:
  %66 = phi i64 [%64, %$23] ; # X
; # (putHex B)
  call void @putHex(i8 %52)
; # (symByte P)
  %67 = call i8 @symByte(i64* %50)
; # (htEncode (symByte P) P)
  call void @htEncode(i8 %67, i64* %50)
  br label %$20
$26:
  %68 = phi i64 [%64, %$23] ; # X
; # (htEncode B P)
  call void @htEncode(i8 %52, i64* %50)
  br label %$20
$20:
  %69 = phi i64 [%56, %$22], [%66, %$27], [%68, %$26] ; # X
  br label %$2
$2:
  %70 = phi i64 [%0, %$1], [%5, %$5], [%20, %$10], [%28, %$15], [%39, %$18], [%69, %$20] ; # X
  ret void
}

define i64 @Fmt(i64) align 8 {
$1:
; # (let (X (cdr Exe) P (push 4 NIL ZERO NIL NIL NIL)) (begString P) ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (push 4 NIL ZERO NIL NIL NIL)
  %4 = alloca i64, i64 6, align 16
  store i64 4, i64* %4
  %5 = getelementptr i64, i64* %4, i32 2
  store i64 2, i64* %5
; # (begString P)
  call void @begString(i64* %4)
; # (loop (htFmt (prog2 (tglString P) (eval (car X)) (tglString P))) ...
  br label %$2
$2:
  %6 = phi i64 [%3, %$1], [%22, %$8] ; # X
; # (prog2 (tglString P) (eval (car X)) (tglString P))
; # (tglString P)
  call void @tglString(i64* %4)
; # (car X)
  %7 = inttoptr i64 %6 to i64*
  %8 = load i64, i64* %7
; # (eval (car X))
  %9 = and i64 %8, 6
  %10 = icmp ne i64 %9, 0
  br i1 %10, label %$5, label %$4
$5:
  br label %$3
$4:
  %11 = and i64 %8, 8
  %12 = icmp ne i64 %11, 0
  br i1 %12, label %$7, label %$6
$7:
  %13 = inttoptr i64 %8 to i64*
  %14 = load i64, i64* %13
  br label %$3
$6:
  %15 = call i64 @evList(i64 %8)
  br label %$3
$3:
  %16 = phi i64 [%8, %$5], [%14, %$7], [%15, %$6] ; # ->
; # (tglString P)
  call void @tglString(i64* %4)
; # (htFmt (prog2 (tglString P) (eval (car X)) (tglString P)))
  call void @htFmt(i64 %16)
; # (? (atom (shift X)))
; # (shift X)
  %17 = inttoptr i64 %6 to i64*
  %18 = getelementptr i64, i64* %17, i32 1
  %19 = load i64, i64* %18
; # (atom (shift X))
  %20 = and i64 %19, 15
  %21 = icmp ne i64 %20, 0
  br i1 %21, label %$9, label %$8
$8:
  %22 = phi i64 [%19, %$3] ; # X
; # (call $Put (char "&"))
  %23 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %23(i8 38)
  br label %$2
$9:
  %24 = phi i64 [%19, %$3] ; # X
  %25 = phi i64 [0, %$3] ; # ->
; # (endString)
  %26 = call i64 @endString()
  ret i64 %26
}

define i8 @getHex(i64) align 8 {
$1:
; # (if (> (- (firstByte Sym) (char "0")) 9) (- (& @ (hex "DF")) 7) @...
; # (firstByte Sym)
  %1 = call i8 @firstByte(i64 %0)
; # (- (firstByte Sym) (char "0"))
  %2 = sub i8 %1, 48
; # (> (- (firstByte Sym) (char "0")) 9)
  %3 = icmp ugt i8 %2, 9
  br i1 %3, label %$2, label %$3
$2:
; # (& @ (hex "DF"))
  %4 = and i8 %2, 223
; # (- (& @ (hex "DF")) 7)
  %5 = sub i8 %4, 7
  br label %$4
$3:
  br label %$4
$4:
  %6 = phi i8 [%5, %$2], [%2, %$3] ; # ->
  ret i8 %6
}

define i64 @head(i8*, i64) align 8 {
$1:
; # (let B (val S) (loop (? (<> B (firstByte (++ Lst))) 0) (? (=0 (se...
; # (val S)
  %2 = load i8, i8* %0
; # (loop (? (<> B (firstByte (++ Lst))) 0) (? (=0 (setq B (val (inc ...
  br label %$2
$2:
  %3 = phi i8* [%0, %$1], [%24, %$6] ; # S
  %4 = phi i64 [%1, %$1], [%25, %$6] ; # Lst
  %5 = phi i8 [%2, %$1], [%26, %$6] ; # B
; # (? (<> B (firstByte (++ Lst))) 0)
; # (++ Lst)
  %6 = inttoptr i64 %4 to i64*
  %7 = load i64, i64* %6
  %8 = getelementptr i64, i64* %6, i32 1
  %9 = load i64, i64* %8
; # (firstByte (++ Lst))
  %10 = call i8 @firstByte(i64 %7)
; # (<> B (firstByte (++ Lst)))
  %11 = icmp ne i8 %5, %10
  br i1 %11, label %$5, label %$3
$5:
  %12 = phi i8* [%3, %$2] ; # S
  %13 = phi i64 [%9, %$2] ; # Lst
  %14 = phi i8 [%5, %$2] ; # B
  br label %$4
$3:
  %15 = phi i8* [%3, %$2] ; # S
  %16 = phi i64 [%9, %$2] ; # Lst
  %17 = phi i8 [%5, %$2] ; # B
; # (? (=0 (setq B (val (inc 'S)))) Lst)
; # (inc 'S)
  %18 = getelementptr i8, i8* %15, i32 1
; # (val (inc 'S))
  %19 = load i8, i8* %18
; # (=0 (setq B (val (inc 'S))))
  %20 = icmp eq i8 %19, 0
  br i1 %20, label %$7, label %$6
$7:
  %21 = phi i8* [%18, %$3] ; # S
  %22 = phi i64 [%16, %$3] ; # Lst
  %23 = phi i8 [%19, %$3] ; # B
  br label %$4
$6:
  %24 = phi i8* [%18, %$3] ; # S
  %25 = phi i64 [%16, %$3] ; # Lst
  %26 = phi i8 [%19, %$3] ; # B
  br label %$2
$4:
  %27 = phi i8* [%12, %$5], [%21, %$7] ; # S
  %28 = phi i64 [%13, %$5], [%22, %$7] ; # Lst
  %29 = phi i8 [%14, %$5], [%23, %$7] ; # B
  %30 = phi i64 [0, %$5], [%22, %$7] ; # ->
  ret i64 %30
}

define i64 @Pack(i64) align 8 {
$1:
; # (let (X (cdr Exe) Lst (save (eval (++ X))) Flg (nil? (eval (car X...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (save (eval (++ X)))
  %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %17 = load i64, i64* %16
  %18 = alloca i64, i64 2, align 16
  %19 = ptrtoint i64* %18 to i64
  %20 = inttoptr i64 %19 to i64*
  store i64 %15, i64* %20
  %21 = add i64 %19, 8
  %22 = inttoptr i64 %21 to i64*
  store i64 %17, i64* %22
  %23 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %19, i64* %23
; # (car X)
  %24 = inttoptr i64 %7 to i64*
  %25 = load i64, i64* %24
; # (eval (car X))
  %26 = and i64 %25, 6
  %27 = icmp ne i64 %26, 0
  br i1 %27, label %$9, label %$8
$9:
  br label %$7
$8:
  %28 = and i64 %25, 8
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %$11, label %$10
$11:
  %30 = inttoptr i64 %25 to i64*
  %31 = load i64, i64* %30
  br label %$7
$10:
  %32 = call i64 @evList(i64 %25)
  br label %$7
$7:
  %33 = phi i64 [%25, %$9], [%31, %$11], [%32, %$10] ; # ->
; # (nil? (eval (car X)))
  %34 = icmp eq i64 %33, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
; # (push 4 NIL ZERO NIL NIL NIL)
  %35 = alloca i64, i64 6, align 16
  store i64 4, i64* %35
  %36 = getelementptr i64, i64* %35, i32 2
  store i64 2, i64* %36
; # (begString (push 4 NIL ZERO NIL NIL NIL))
  call void @begString(i64* %35)
; # (while (pair Lst) (let (C (++ Lst) B (firstByte C)) (cond ((== B ...
  br label %$12
$12:
  %37 = phi i64 [%15, %$7], [%159, %$15] ; # Lst
; # (pair Lst)
  %38 = and i64 %37, 15
  %39 = icmp eq i64 %38, 0
  br i1 %39, label %$13, label %$14
$13:
  %40 = phi i64 [%37, %$12] ; # Lst
; # (let (C (++ Lst) B (firstByte C)) (cond ((== B (char "%")) (call ...
; # (++ Lst)
  %41 = inttoptr i64 %40 to i64*
  %42 = load i64, i64* %41
  %43 = getelementptr i64, i64* %41, i32 1
  %44 = load i64, i64* %43
; # (firstByte C)
  %45 = call i8 @firstByte(i64 %42)
; # (cond ((== B (char "%")) (call $Put (if Flg B (| (shl (getHex (++...
; # (== B (char "%"))
  %46 = icmp eq i8 %45, 37
  br i1 %46, label %$17, label %$16
$17:
  %47 = phi i64 [%44, %$13] ; # Lst
; # (if Flg B (| (shl (getHex (++ Lst)) 4) (getHex (++ Lst))))
  br i1 %34, label %$18, label %$19
$18:
  %48 = phi i64 [%47, %$17] ; # Lst
  br label %$20
$19:
  %49 = phi i64 [%47, %$17] ; # Lst
; # (++ Lst)
  %50 = inttoptr i64 %49 to i64*
  %51 = load i64, i64* %50
  %52 = getelementptr i64, i64* %50, i32 1
  %53 = load i64, i64* %52
; # (getHex (++ Lst))
  %54 = call i8 @getHex(i64 %51)
; # (shl (getHex (++ Lst)) 4)
  %55 = shl i8 %54, 4
; # (++ Lst)
  %56 = inttoptr i64 %53 to i64*
  %57 = load i64, i64* %56
  %58 = getelementptr i64, i64* %56, i32 1
  %59 = load i64, i64* %58
; # (getHex (++ Lst))
  %60 = call i8 @getHex(i64 %57)
; # (| (shl (getHex (++ Lst)) 4) (getHex (++ Lst)))
  %61 = or i8 %55, %60
  br label %$20
$20:
  %62 = phi i64 [%48, %$18], [%59, %$19] ; # Lst
  %63 = phi i8 [%45, %$18], [%61, %$19] ; # ->
; # (call $Put (if Flg B (| (shl (getHex (++ Lst)) 4) (getHex (++ Lst...
  %64 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %64(i8 %63)
  br label %$15
$16:
  %65 = phi i64 [%44, %$13] ; # Lst
; # (<> B (char "&"))
  %66 = icmp ne i8 %45, 38
  br i1 %66, label %$22, label %$21
$22:
  %67 = phi i64 [%65, %$16] ; # Lst
; # (prSym C)
  call void @prSym(i64 %42)
  br label %$15
$21:
  %68 = phi i64 [%65, %$16] ; # Lst
; # (head ($ "lt;") Lst)
  %69 = call i64 @head(i8* bitcast ([4 x i8]* @$6 to i8*), i64 %68)
  %70 = icmp ne i64 %69, 0
  br i1 %70, label %$24, label %$23
$24:
  %71 = phi i64 [%68, %$21] ; # Lst
; # (call $Put (char "<"))
  %72 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %72(i8 60)
  br label %$15
$23:
  %73 = phi i64 [%68, %$21] ; # Lst
; # (head ($ "gt;") Lst)
  %74 = call i64 @head(i8* bitcast ([4 x i8]* @$7 to i8*), i64 %73)
  %75 = icmp ne i64 %74, 0
  br i1 %75, label %$26, label %$25
$26:
  %76 = phi i64 [%73, %$23] ; # Lst
; # (call $Put (char ">"))
  %77 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %77(i8 62)
  br label %$15
$25:
  %78 = phi i64 [%73, %$23] ; # Lst
; # (head ($ "amp;") Lst)
  %79 = call i64 @head(i8* bitcast ([5 x i8]* @$8 to i8*), i64 %78)
  %80 = icmp ne i64 %79, 0
  br i1 %80, label %$28, label %$27
$28:
  %81 = phi i64 [%78, %$25] ; # Lst
; # (call $Put (char "&"))
  %82 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %82(i8 38)
  br label %$15
$27:
  %83 = phi i64 [%78, %$25] ; # Lst
; # (head ($ "quot;") Lst)
  %84 = call i64 @head(i8* bitcast ([6 x i8]* @$9 to i8*), i64 %83)
  %85 = icmp ne i64 %84, 0
  br i1 %85, label %$30, label %$29
$30:
  %86 = phi i64 [%83, %$27] ; # Lst
; # (call $Put (char "\""))
  %87 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %87(i8 34)
  br label %$15
$29:
  %88 = phi i64 [%83, %$27] ; # Lst
; # (head ($ "nbsp;") Lst)
  %89 = call i64 @head(i8* bitcast ([6 x i8]* @$10 to i8*), i64 %88)
  %90 = icmp ne i64 %89, 0
  br i1 %90, label %$32, label %$31
$32:
  %91 = phi i64 [%88, %$29] ; # Lst
; # (call $Put (char " "))
  %92 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %92(i8 32)
  br label %$15
$31:
  %93 = phi i64 [%88, %$29] ; # Lst
; # (car Lst)
  %94 = inttoptr i64 %93 to i64*
  %95 = load i64, i64* %94
; # (firstByte (car Lst))
  %96 = call i8 @firstByte(i64 %95)
; # (== (firstByte (car Lst)) (char "#"))
  %97 = icmp eq i8 %96, 35
  br i1 %97, label %$34, label %$33
$34:
  %98 = phi i64 [%93, %$31] ; # Lst
; # (let (L (shift Lst) D (firstByte (++ L)) N (i32 (- D (char "0")))...
; # (shift Lst)
  %99 = inttoptr i64 %98 to i64*
  %100 = getelementptr i64, i64* %99, i32 1
  %101 = load i64, i64* %100
; # (++ L)
  %102 = inttoptr i64 %101 to i64*
  %103 = load i64, i64* %102
  %104 = getelementptr i64, i64* %102, i32 1
  %105 = load i64, i64* %104
; # (firstByte (++ L))
  %106 = call i8 @firstByte(i64 %103)
; # (- D (char "0"))
  %107 = sub i8 %106, 48
; # (i32 (- D (char "0")))
  %108 = zext i8 %107 to i32
; # (loop (? (or (> (char "0") D) (> D (char "9"))) (call $Put (char ...
  br label %$35
$35:
  %109 = phi i64 [%101, %$34], [%145, %$41] ; # Lst
  %110 = phi i64 [%105, %$34], [%146, %$41] ; # L
  %111 = phi i8 [%106, %$34], [%147, %$41] ; # D
  %112 = phi i32 [%108, %$34], [%152, %$41] ; # N
; # (? (or (> (char "0") D) (> D (char "9"))) (call $Put (char "&")) ...
; # (or (> (char "0") D) (> D (char "9")))
; # (> (char "0") D)
  %113 = icmp ugt i8 48, %111
  br i1 %113, label %$36, label %$37
$37:
  %114 = phi i64 [%109, %$35] ; # Lst
  %115 = phi i64 [%110, %$35] ; # L
  %116 = phi i8 [%111, %$35] ; # D
  %117 = phi i32 [%112, %$35] ; # N
; # (> D (char "9"))
  %118 = icmp ugt i8 %116, 57
  br label %$36
$36:
  %119 = phi i64 [%109, %$35], [%114, %$37] ; # Lst
  %120 = phi i64 [%110, %$35], [%115, %$37] ; # L
  %121 = phi i8 [%111, %$35], [%116, %$37] ; # D
  %122 = phi i32 [%112, %$35], [%117, %$37] ; # N
  %123 = phi i1 [1, %$35], [%118, %$37] ; # ->
  br i1 %123, label %$40, label %$38
$40:
  %124 = phi i64 [%119, %$36] ; # Lst
  %125 = phi i64 [%120, %$36] ; # L
  %126 = phi i8 [%121, %$36] ; # D
  %127 = phi i32 [%122, %$36] ; # N
; # (call $Put (char "&"))
  %128 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %128(i8 38)
; # (call $Put (char "#"))
  %129 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %129(i8 35)
  br label %$39
$38:
  %130 = phi i64 [%119, %$36] ; # Lst
  %131 = phi i64 [%120, %$36] ; # L
  %132 = phi i8 [%121, %$36] ; # D
  %133 = phi i32 [%122, %$36] ; # N
; # (? (== (setq D (firstByte (++ L))) (char ";")) (prSym (mkChar N))...
; # (++ L)
  %134 = inttoptr i64 %131 to i64*
  %135 = load i64, i64* %134
  %136 = getelementptr i64, i64* %134, i32 1
  %137 = load i64, i64* %136
; # (firstByte (++ L))
  %138 = call i8 @firstByte(i64 %135)
; # (== (setq D (firstByte (++ L))) (char ";"))
  %139 = icmp eq i8 %138, 59
  br i1 %139, label %$42, label %$41
$42:
  %140 = phi i64 [%130, %$38] ; # Lst
  %141 = phi i64 [%137, %$38] ; # L
  %142 = phi i8 [%138, %$38] ; # D
  %143 = phi i32 [%133, %$38] ; # N
; # (mkChar N)
  %144 = call i64 @mkChar(i32 %143)
; # (prSym (mkChar N))
  call void @prSym(i64 %144)
  br label %$39
$41:
  %145 = phi i64 [%130, %$38] ; # Lst
  %146 = phi i64 [%137, %$38] ; # L
  %147 = phi i8 [%138, %$38] ; # D
  %148 = phi i32 [%133, %$38] ; # N
; # (* N 10)
  %149 = mul i32 %148, 10
; # (- D (char "0"))
  %150 = sub i8 %147, 48
; # (i32 (- D (char "0")))
  %151 = zext i8 %150 to i32
; # (+ (* N 10) (i32 (- D (char "0"))))
  %152 = add i32 %149, %151
  br label %$35
$39:
  %153 = phi i64 [%124, %$40], [%141, %$42] ; # Lst
  %154 = phi i64 [%125, %$40], [%141, %$42] ; # L
  %155 = phi i8 [%126, %$40], [%142, %$42] ; # D
  %156 = phi i32 [%127, %$40], [%143, %$42] ; # N
  br label %$15
$33:
  %157 = phi i64 [%93, %$31] ; # Lst
; # (call $Put (char "&"))
  %158 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
  call void %158(i8 38)
  br label %$15
$15:
  %159 = phi i64 [%62, %$20], [%67, %$22], [%69, %$24], [%74, %$26], [%79, %$28], [%84, %$30], [%89, %$32], [%153, %$39], [%157, %$33] ; # Lst
  br label %$12
$14:
  %160 = phi i64 [%37, %$12] ; # Lst
; # (endString)
  %161 = call i64 @endString()
; # (drop *Safe)
  %162 = inttoptr i64 %19 to i64*
  %163 = getelementptr i64, i64* %162, i32 1
  %164 = load i64, i64* %163
  %165 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %164, i64* %165
  ret i64 %161
}

define i64 @Read(i64) align 8 {
$1:
; # (let (N (evCnt Exe (cdr Exe)) C (val $Chr)) (if (or (le0 N) (and ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (evCnt Exe (cdr Exe))
  %4 = call i64 @evCnt(i64 %0, i64 %3)
; # (val $Chr)
  %5 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
; # (if (or (le0 N) (and (=0 C) (lt0 (setq C (call $Get))))) $Nil (le...
; # (or (le0 N) (and (=0 C) (lt0 (setq C (call $Get)))))
; # (le0 N)
  %6 = icmp sle i64 %4, 0
  br i1 %6, label %$2, label %$3
$3:
  %7 = phi i64 [%4, %$1] ; # N
  %8 = phi i32 [%5, %$1] ; # C
; # (and (=0 C) (lt0 (setq C (call $Get))))
; # (=0 C)
  %9 = icmp eq i32 %8, 0
  br i1 %9, label %$5, label %$4
$5:
  %10 = phi i64 [%7, %$3] ; # N
  %11 = phi i32 [%8, %$3] ; # C
; # (call $Get)
  %12 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %13 = call i32 %12()
; # (lt0 (setq C (call $Get)))
  %14 = icmp slt i32 %13, 0
  br label %$4
$4:
  %15 = phi i64 [%7, %$3], [%10, %$5] ; # N
  %16 = phi i32 [%8, %$3], [%13, %$5] ; # C
  %17 = phi i1 [0, %$3], [%14, %$5] ; # ->
  br label %$2
$2:
  %18 = phi i64 [%4, %$1], [%15, %$4] ; # N
  %19 = phi i32 [%5, %$1], [%16, %$4] ; # C
  %20 = phi i1 [1, %$1], [%17, %$4] ; # ->
  br i1 %20, label %$6, label %$7
$6:
  %21 = phi i64 [%18, %$2] ; # N
  %22 = phi i32 [%19, %$2] ; # C
  br label %$8
$7:
  %23 = phi i64 [%18, %$2] ; # N
  %24 = phi i32 [%19, %$2] ; # C
; # (let C (getChar C) (when (>= C (hex "80")) (dec 'N) (when (>= C (...
; # (getChar C)
  %25 = call i32 @getChar(i32 %24)
; # (when (>= C (hex "80")) (dec 'N) (when (>= C (hex "800")) (dec 'N...
; # (>= C (hex "80"))
  %26 = icmp sge i32 %25, 128
  br i1 %26, label %$9, label %$10
$9:
  %27 = phi i64 [%23, %$7] ; # N
  %28 = phi i32 [%25, %$7] ; # C
; # (dec 'N)
  %29 = sub i64 %27, 1
; # (when (>= C (hex "800")) (dec 'N) (when (>= C (hex "10000")) (dec...
; # (>= C (hex "800"))
  %30 = icmp sge i32 %28, 2048
  br i1 %30, label %$11, label %$12
$11:
  %31 = phi i64 [%29, %$9] ; # N
  %32 = phi i32 [%28, %$9] ; # C
; # (dec 'N)
  %33 = sub i64 %31, 1
; # (when (>= C (hex "10000")) (dec 'N))
; # (>= C (hex "10000"))
  %34 = icmp sge i32 %32, 65536
  br i1 %34, label %$13, label %$14
$13:
  %35 = phi i64 [%33, %$11] ; # N
  %36 = phi i32 [%32, %$11] ; # C
; # (dec 'N)
  %37 = sub i64 %35, 1
  br label %$14
$14:
  %38 = phi i64 [%33, %$11], [%37, %$13] ; # N
  %39 = phi i32 [%32, %$11], [%36, %$13] ; # C
  br label %$12
$12:
  %40 = phi i64 [%29, %$9], [%38, %$14] ; # N
  %41 = phi i32 [%28, %$9], [%39, %$14] ; # C
  br label %$10
$10:
  %42 = phi i64 [%23, %$7], [%40, %$12] ; # N
  %43 = phi i32 [%25, %$7], [%41, %$12] ; # C
; # (if (lt0 (dec 'N)) $Nil (let (X (cons (mkChar C) $Nil) R (save X)...
; # (dec 'N)
  %44 = sub i64 %42, 1
; # (lt0 (dec 'N))
  %45 = icmp slt i64 %44, 0
  br i1 %45, label %$15, label %$16
$15:
  %46 = phi i64 [%44, %$10] ; # N
  %47 = phi i32 [%43, %$10] ; # C
  br label %$17
$16:
  %48 = phi i64 [%44, %$10] ; # N
  %49 = phi i32 [%43, %$10] ; # C
; # (let (X (cons (mkChar C) $Nil) R (save X)) (loop (? (=0 N) (set $...
; # (mkChar C)
  %50 = call i64 @mkChar(i32 %49)
; # (cons (mkChar C) $Nil)
  %51 = call i64 @cons(i64 %50, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
; # (save X)
  %52 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  %53 = load i64, i64* %52
  %54 = alloca i64, i64 2, align 16
  %55 = ptrtoint i64* %54 to i64
  %56 = inttoptr i64 %55 to i64*
  store i64 %51, i64* %56
  %57 = add i64 %55, 8
  %58 = inttoptr i64 %57 to i64*
  store i64 %53, i64* %58
  %59 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %55, i64* %59
; # (loop (? (=0 N) (set $Chr 0) R) (? (lt0 (setq C (call $Get))) $Ni...
  br label %$18
$18:
  %60 = phi i64 [%48, %$16], [%109, %$30] ; # N
  %61 = phi i32 [%49, %$16], [%110, %$30] ; # C
  %62 = phi i64 [%51, %$16], [%113, %$30] ; # X
; # (? (=0 N) (set $Chr 0) R)
; # (=0 N)
  %63 = icmp eq i64 %60, 0
  br i1 %63, label %$21, label %$19
$21:
  %64 = phi i64 [%60, %$18] ; # N
  %65 = phi i32 [%61, %$18] ; # C
  %66 = phi i64 [%62, %$18] ; # X
; # (set $Chr 0)
  store i32 0, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
  br label %$20
$19:
  %67 = phi i64 [%60, %$18] ; # N
  %68 = phi i32 [%61, %$18] ; # C
  %69 = phi i64 [%62, %$18] ; # X
; # (? (lt0 (setq C (call $Get))) $Nil)
; # (call $Get)
  %70 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
  %71 = call i32 %70()
; # (lt0 (setq C (call $Get)))
  %72 = icmp slt i32 %71, 0
  br i1 %72, label %$23, label %$22
$23:
  %73 = phi i64 [%67, %$19] ; # N
  %74 = phi i32 [%71, %$19] ; # C
  %75 = phi i64 [%69, %$19] ; # X
  br label %$20
$22:
  %76 = phi i64 [%67, %$19] ; # N
  %77 = phi i32 [%71, %$19] ; # C
  %78 = phi i64 [%69, %$19] ; # X
; # (getChar C)
  %79 = call i32 @getChar(i32 %77)
; # (when (>= C (hex "80")) (dec 'N) (when (>= C (hex "800")) (dec 'N...
; # (>= C (hex "80"))
  %80 = icmp sge i32 %79, 128
  br i1 %80, label %$24, label %$25
$24:
  %81 = phi i64 [%76, %$22] ; # N
  %82 = phi i32 [%79, %$22] ; # C
  %83 = phi i64 [%78, %$22] ; # X
; # (dec 'N)
  %84 = sub i64 %81, 1
; # (when (>= C (hex "800")) (dec 'N) (when (>= C (hex "10000")) (dec...
; # (>= C (hex "800"))
  %85 = icmp sge i32 %82, 2048
  br i1 %85, label %$26, label %$27
$26:
  %86 = phi i64 [%84, %$24] ; # N
  %87 = phi i32 [%82, %$24] ; # C
  %88 = phi i64 [%83, %$24] ; # X
; # (dec 'N)
  %89 = sub i64 %86, 1
; # (when (>= C (hex "10000")) (dec 'N))
; # (>= C (hex "10000"))
  %90 = icmp sge i32 %87, 65536
  br i1 %90, label %$28, label %$29
$28:
  %91 = phi i64 [%89, %$26] ; # N
  %92 = phi i32 [%87, %$26] ; # C
  %93 = phi i64 [%88, %$26] ; # X
; # (dec 'N)
  %94 = sub i64 %91, 1
  br label %$29
$29:
  %95 = phi i64 [%89, %$26], [%94, %$28] ; # N
  %96 = phi i32 [%87, %$26], [%92, %$28] ; # C
  %97 = phi i64 [%88, %$26], [%93, %$28] ; # X
  br label %$27
$27:
  %98 = phi i64 [%84, %$24], [%95, %$29] ; # N
  %99 = phi i32 [%82, %$24], [%96, %$29] ; # C
  %100 = phi i64 [%83, %$24], [%97, %$29] ; # X
  br label %$25
$25:
  %101 = phi i64 [%76, %$22], [%98, %$27] ; # N
  %102 = phi i32 [%79, %$22], [%99, %$27] ; # C
  %103 = phi i64 [%78, %$22], [%100, %$27] ; # X
; # (? (lt0 (dec 'N)) $Nil)
; # (dec 'N)
  %104 = sub i64 %101, 1
; # (lt0 (dec 'N))
  %105 = icmp slt i64 %104, 0
  br i1 %105, label %$31, label %$30
$31:
  %106 = phi i64 [%104, %$25] ; # N
  %107 = phi i32 [%102, %$25] ; # C
  %108 = phi i64 [%103, %$25] ; # X
  br label %$20
$30:
  %109 = phi i64 [%104, %$25] ; # N
  %110 = phi i32 [%102, %$25] ; # C
  %111 = phi i64 [%103, %$25] ; # X
; # (set 2 X (cons (mkChar C) $Nil))
; # (mkChar C)
  %112 = call i64 @mkChar(i32 %110)
; # (cons (mkChar C) $Nil)
  %113 = call i64 @cons(i64 %112, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64))
  %114 = inttoptr i64 %111 to i64*
  %115 = getelementptr i64, i64* %114, i32 1
  store i64 %113, i64* %115
  br label %$18
$20:
  %116 = phi i64 [%64, %$21], [%73, %$23], [%106, %$31] ; # N
  %117 = phi i32 [%65, %$21], [%74, %$23], [%107, %$31] ; # C
  %118 = phi i64 [%66, %$21], [%75, %$23], [%108, %$31] ; # X
  %119 = phi i64 [%51, %$21], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$23], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$31] ; # ->
; # (drop *Safe)
  %120 = inttoptr i64 %55 to i64*
  %121 = getelementptr i64, i64* %120, i32 1
  %122 = load i64, i64* %121
  %123 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 0) to i64) to i64*
  store i64 %122, i64* %123
  br label %$17
$17:
  %124 = phi i64 [%46, %$15], [%116, %$20] ; # N
  %125 = phi i32 [%47, %$15], [%117, %$20] ; # C
  %126 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$15], [%119, %$20] ; # ->
  br label %$8
$8:
  %127 = phi i64 [%21, %$6], [%124, %$17] ; # N
  %128 = phi i32 [%22, %$6], [%24, %$17] ; # C
  %129 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64), %$6], [%126, %$17] ; # ->
  ret i64 %129
}
@$CnkCnt = global i32 0
@$SvGet = global i32()* null
@$SvPut = global void(i8)* null
@$CnkBuf = global [4000 x i8] zeroinitializer

define i32 @chrHex(i32) align 8 {
$1:
; # (cond ((and (>= C (char "0")) (>= (char "9") C)) (- C 48)) ((and ...
; # (and (>= C (char "0")) (>= (char "9") C))
; # (>= C (char "0"))
  %1 = icmp sge i32 %0, 48
  br i1 %1, label %$4, label %$3
$4:
  %2 = phi i32 [%0, %$1] ; # C
; # (>= (char "9") C)
  %3 = icmp sge i32 57, %2
  br label %$3
$3:
  %4 = phi i32 [%0, %$1], [%2, %$4] ; # C
  %5 = phi i1 [0, %$1], [%3, %$4] ; # ->
  br i1 %5, label %$6, label %$5
$6:
  %6 = phi i32 [%4, %$3] ; # C
; # (- C 48)
  %7 = sub i32 %6, 48
  br label %$2
$5:
  %8 = phi i32 [%4, %$3] ; # C
; # (and (>= (setq C (& C (hex "DF"))) (char "A")) (>= (char "F") C))...
; # (& C (hex "DF"))
  %9 = and i32 %8, 223
; # (>= (setq C (& C (hex "DF"))) (char "A"))
  %10 = icmp sge i32 %9, 65
  br i1 %10, label %$8, label %$7
$8:
  %11 = phi i32 [%9, %$5] ; # C
; # (>= (char "F") C)
  %12 = icmp sge i32 70, %11
  br label %$7
$7:
  %13 = phi i32 [%9, %$5], [%11, %$8] ; # C
  %14 = phi i1 [0, %$5], [%12, %$8] ; # ->
  br i1 %14, label %$10, label %$9
$10:
  %15 = phi i32 [%13, %$7] ; # C
; # (- C 55)
  %16 = sub i32 %15, 55
  br label %$2
$9:
  %17 = phi i32 [%13, %$7] ; # C
  br label %$2
$2:
  %18 = phi i32 [%6, %$6], [%15, %$10], [%17, %$9] ; # C
  %19 = phi i32 [%7, %$6], [%16, %$10], [-1, %$9] ; # ->
  ret i32 %19
}

define void @chunkSize() align 8 {
$1:
; # (let C (if (val $Chr) @ (call $SvGet)) (when (ge0 (set $CnkCnt (c...
; # (if (val $Chr) @ (call $SvGet))
; # (val $Chr)
  %0 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
  %1 = icmp ne i32 %0, 0
  br i1 %1, label %$2, label %$3
$2:
  br label %$4
$3:
; # (call $SvGet)
  %2 = load i32()*, i32()** @$SvGet
  %3 = call i32 %2()
  br label %$4
$4:
  %4 = phi i32 [%0, %$2], [%3, %$3] ; # ->
; # (when (ge0 (set $CnkCnt (chrHex C))) (while (ge0 (chrHex (setq C ...
; # (set $CnkCnt (chrHex C))
; # (chrHex C)
  %5 = call i32 @chrHex(i32 %4)
  store i32 %5, i32* @$CnkCnt
; # (ge0 (set $CnkCnt (chrHex C)))
  %6 = icmp sge i32 %5, 0
  br i1 %6, label %$5, label %$6
$5:
  %7 = phi i32 [%4, %$4] ; # C
; # (while (ge0 (chrHex (setq C (call $SvGet)))) (set $CnkCnt (| @ (s...
  br label %$7
$7:
  %8 = phi i32 [%7, %$5], [%13, %$8] ; # C
; # (call $SvGet)
  %9 = load i32()*, i32()** @$SvGet
  %10 = call i32 %9()
; # (chrHex (setq C (call $SvGet)))
  %11 = call i32 @chrHex(i32 %10)
; # (ge0 (chrHex (setq C (call $SvGet))))
  %12 = icmp sge i32 %11, 0
  br i1 %12, label %$8, label %$9
$8:
  %13 = phi i32 [%10, %$7] ; # C
; # (set $CnkCnt (| @ (shl (val $CnkCnt) 4)))
; # (val $CnkCnt)
  %14 = load i32, i32* @$CnkCnt
; # (shl (val $CnkCnt) 4)
  %15 = shl i32 %14, 4
; # (| @ (shl (val $CnkCnt) 4))
  %16 = or i32 %11, %15
  store i32 %16, i32* @$CnkCnt
  br label %$7
$9:
  %17 = phi i32 [%10, %$7] ; # C
; # (loop (? (== C (char "^J")) (call $SvGet) (when (=0 (val $CnkCnt)...
  br label %$10
$10:
  %18 = phi i32 [%17, %$9], [%33, %$16] ; # C
; # (? (== C (char "^J")) (call $SvGet) (when (=0 (val $CnkCnt)) (cal...
; # (== C (char "^J"))
  %19 = icmp eq i32 %18, 10
  br i1 %19, label %$13, label %$11
$13:
  %20 = phi i32 [%18, %$10] ; # C
; # (call $SvGet)
  %21 = load i32()*, i32()** @$SvGet
  %22 = call i32 %21()
; # (when (=0 (val $CnkCnt)) (call $SvGet) (set $Chr 0))
; # (val $CnkCnt)
  %23 = load i32, i32* @$CnkCnt
; # (=0 (val $CnkCnt))
  %24 = icmp eq i32 %23, 0
  br i1 %24, label %$14, label %$15
$14:
  %25 = phi i32 [%20, %$13] ; # C
; # (call $SvGet)
  %26 = load i32()*, i32()** @$SvGet
  %27 = call i32 %26()
; # (set $Chr 0)
  store i32 0, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
  br label %$15
$15:
  %28 = phi i32 [%20, %$13], [%25, %$14] ; # C
  br label %$12
$11:
  %29 = phi i32 [%18, %$10] ; # C
; # (? (lt0 C))
; # (lt0 C)
  %30 = icmp slt i32 %29, 0
  br i1 %30, label %$12, label %$16
$16:
  %31 = phi i32 [%29, %$11] ; # C
; # (call $SvGet)
  %32 = load i32()*, i32()** @$SvGet
  %33 = call i32 %32()
  br label %$10
$12:
  %34 = phi i32 [%28, %$15], [%29, %$11] ; # C
  br label %$6
$6:
  %35 = phi i32 [%4, %$4], [%34, %$12] ; # C
  ret void
}

define i32 @getChunked() align 8 {
$1:
; # (if (le0 (val $CnkCnt)) (set $Chr -1) (call $SvGet) (when (=0 (se...
; # (val $CnkCnt)
  %0 = load i32, i32* @$CnkCnt
; # (le0 (val $CnkCnt))
  %1 = icmp sle i32 %0, 0
  br i1 %1, label %$2, label %$3
$2:
; # (set $Chr -1)
  store i32 -1, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
  br label %$4
$3:
; # (call $SvGet)
  %2 = load i32()*, i32()** @$SvGet
  %3 = call i32 %2()
; # (when (=0 (set $CnkCnt (dec @))) (call $SvGet) (call $SvGet) (chu...
; # (set $CnkCnt (dec @))
; # (dec @)
  %4 = sub i32 %0, 1
  store i32 %4, i32* @$CnkCnt
; # (=0 (set $CnkCnt (dec @)))
  %5 = icmp eq i32 %4, 0
  br i1 %5, label %$5, label %$6
$5:
; # (call $SvGet)
  %6 = load i32()*, i32()** @$SvGet
  %7 = call i32 %6()
; # (call $SvGet)
  %8 = load i32()*, i32()** @$SvGet
  %9 = call i32 %8()
; # (chunkSize)
  call void @chunkSize()
  br label %$6
$6:
; # (val $Chr)
  %10 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
  br label %$4
$4:
  %11 = phi i32 [-1, %$2], [%10, %$6] ; # ->
  ret i32 %11
}

define i64 @In(i64) align 8 {
$1:
; # (let X (cdr Exe) (if (nil? (eval (++ X))) (run X) (set (i8** $SvG...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (if (nil? (eval (++ X))) (run X) (set (i8** $SvGet) (val (i8** $G...
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (nil? (eval (++ X)))
  %16 = icmp eq i64 %15, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %16, label %$7, label %$8
$7:
  %17 = phi i64 [%7, %$2] ; # X
; # (run X)
  br label %$10
$10:
  %18 = phi i64 [%17, %$7], [%40, %$19] ; # Prg
  %19 = inttoptr i64 %18 to i64*
  %20 = load i64, i64* %19
  %21 = getelementptr i64, i64* %19, i32 1
  %22 = load i64, i64* %21
  %23 = and i64 %22, 15
  %24 = icmp ne i64 %23, 0
  br i1 %24, label %$13, label %$11
$13:
  %25 = phi i64 [%22, %$10] ; # Prg
  %26 = and i64 %20, 6
  %27 = icmp ne i64 %26, 0
  br i1 %27, label %$16, label %$15
$16:
  br label %$14
$15:
  %28 = and i64 %20, 8
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %$18, label %$17
$18:
  %30 = inttoptr i64 %20 to i64*
  %31 = load i64, i64* %30
  br label %$14
$17:
  %32 = call i64 @evList(i64 %20)
  br label %$14
$14:
  %33 = phi i64 [%20, %$16], [%31, %$18], [%32, %$17] ; # ->
  br label %$12
$11:
  %34 = phi i64 [%22, %$10] ; # Prg
  %35 = and i64 %20, 15
  %36 = icmp eq i64 %35, 0
  br i1 %36, label %$20, label %$19
$20:
  %37 = phi i64 [%34, %$11] ; # Prg
  %38 = call i64 @evList(i64 %20)
  %39 = icmp ne i64 %38, 0
  br label %$19
$19:
  %40 = phi i64 [%34, %$11], [%37, %$20] ; # Prg
  %41 = phi i1 [0, %$11], [%39, %$20] ; # ->
  br label %$10
$12:
  %42 = phi i64 [%25, %$14] ; # Prg
  %43 = phi i64 [%33, %$14] ; # ->
  br label %$9
$8:
  %44 = phi i64 [%7, %$2] ; # X
; # (set (i8** $SvGet) (val (i8** $Get)) $Get (fun (i32) getChunked))...
; # (i8** $SvGet)
  %45 = bitcast i32()** @$SvGet to i8**
; # (i8** $Get)
  %46 = bitcast i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**) to i8**
; # (val (i8** $Get))
  %47 = load i8*, i8** %46
  store i8* %47, i8** %45
; # (fun (i32) getChunked)
  store i32()* @getChunked, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**)
; # (chunkSize)
  call void @chunkSize()
; # (prog1 (run X) (set (i8** $Get) (val (i8** $SvGet))) (set $Chr 0)...
; # (run X)
  br label %$21
$21:
  %48 = phi i64 [%44, %$8], [%70, %$30] ; # Prg
  %49 = inttoptr i64 %48 to i64*
  %50 = load i64, i64* %49
  %51 = getelementptr i64, i64* %49, i32 1
  %52 = load i64, i64* %51
  %53 = and i64 %52, 15
  %54 = icmp ne i64 %53, 0
  br i1 %54, label %$24, label %$22
$24:
  %55 = phi i64 [%52, %$21] ; # Prg
  %56 = and i64 %50, 6
  %57 = icmp ne i64 %56, 0
  br i1 %57, label %$27, label %$26
$27:
  br label %$25
$26:
  %58 = and i64 %50, 8
  %59 = icmp ne i64 %58, 0
  br i1 %59, label %$29, label %$28
$29:
  %60 = inttoptr i64 %50 to i64*
  %61 = load i64, i64* %60
  br label %$25
$28:
  %62 = call i64 @evList(i64 %50)
  br label %$25
$25:
  %63 = phi i64 [%50, %$27], [%61, %$29], [%62, %$28] ; # ->
  br label %$23
$22:
  %64 = phi i64 [%52, %$21] ; # Prg
  %65 = and i64 %50, 15
  %66 = icmp eq i64 %65, 0
  br i1 %66, label %$31, label %$30
$31:
  %67 = phi i64 [%64, %$22] ; # Prg
  %68 = call i64 @evList(i64 %50)
  %69 = icmp ne i64 %68, 0
  br label %$30
$30:
  %70 = phi i64 [%64, %$22], [%67, %$31] ; # Prg
  %71 = phi i1 [0, %$22], [%69, %$31] ; # ->
  br label %$21
$23:
  %72 = phi i64 [%55, %$25] ; # Prg
  %73 = phi i64 [%63, %$25] ; # ->
; # (set (i8** $Get) (val (i8** $SvGet)))
; # (i8** $Get)
  %74 = bitcast i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 96) to i32()**) to i8**
; # (i8** $SvGet)
  %75 = bitcast i32()** @$SvGet to i8**
; # (val (i8** $SvGet))
  %76 = load i8*, i8** %75
  store i8* %76, i8** %74
; # (set $Chr 0)
  store i32 0, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 168) to i32*)
  br label %$9
$9:
  %77 = phi i64 [%17, %$12], [%44, %$23] ; # X
  %78 = phi i64 [%43, %$12], [%73, %$23] ; # ->
  ret i64 %78
}

define void @outHex(i32) align 8 {
$1:
; # (when (> N 15) (outHex (shr N 4)) (setq N (& N 15)))
; # (> N 15)
  %1 = icmp sgt i32 %0, 15
  br i1 %1, label %$2, label %$3
$2:
  %2 = phi i32 [%0, %$1] ; # N
; # (shr N 4)
  %3 = lshr i32 %2, 4
; # (outHex (shr N 4))
  call void @outHex(i32 %3)
; # (& N 15)
  %4 = and i32 %2, 15
  br label %$3
$3:
  %5 = phi i32 [%0, %$1], [%4, %$2] ; # N
; # (when (> N 9) (setq N (+ N 39)))
; # (> N 9)
  %6 = icmp sgt i32 %5, 9
  br i1 %6, label %$4, label %$5
$4:
  %7 = phi i32 [%5, %$3] ; # N
; # (+ N 39)
  %8 = add i32 %7, 39
  br label %$5
$5:
  %9 = phi i32 [%5, %$3], [%8, %$4] ; # N
; # (i8 N)
  %10 = trunc i32 %9 to i8
; # (+ (i8 N) (char "0"))
  %11 = add i8 %10, 48
; # (call $SvPut (+ (i8 N) (char "0")))
  %12 = load void(i8)*, void(i8)** @$SvPut
  call void %12(i8 %11)
  ret void
}

define void @wrChunk(i32) align 8 {
$1:
; # (outHex Cnt)
  call void @outHex(i32 %0)
; # (call $SvPut (char "^M"))
  %1 = load void(i8)*, void(i8)** @$SvPut
  call void %1(i8 13)
; # (call $SvPut (char "^J"))
  %2 = load void(i8)*, void(i8)** @$SvPut
  call void %2(i8 10)
; # (let P $CnkBuf (loop (call $SvPut (val P)) (? (=0 (dec 'Cnt))) (i...
; # (loop (call $SvPut (val P)) (? (=0 (dec 'Cnt))) (inc 'P))
  br label %$2
$2:
  %3 = phi i32 [%0, %$1], [%9, %$3] ; # Cnt
  %4 = phi i8* [bitcast ([4000 x i8]* @$CnkBuf to i8*), %$1], [%11, %$3] ; # P
; # (val P)
  %5 = load i8, i8* %4
; # (call $SvPut (val P))
  %6 = load void(i8)*, void(i8)** @$SvPut
  call void %6(i8 %5)
; # (? (=0 (dec 'Cnt)))
; # (dec 'Cnt)
  %7 = sub i32 %3, 1
; # (=0 (dec 'Cnt))
  %8 = icmp eq i32 %7, 0
  br i1 %8, label %$4, label %$3
$3:
  %9 = phi i32 [%7, %$2] ; # Cnt
  %10 = phi i8* [%4, %$2] ; # P
; # (inc 'P)
  %11 = getelementptr i8, i8* %10, i32 1
  br label %$2
$4:
  %12 = phi i32 [%7, %$2] ; # Cnt
  %13 = phi i8* [%4, %$2] ; # P
  %14 = phi i64 [0, %$2] ; # ->
; # (call $SvPut (char "^M"))
  %15 = load void(i8)*, void(i8)** @$SvPut
  call void %15(i8 13)
; # (call $SvPut (char "^J"))
  %16 = load void(i8)*, void(i8)** @$SvPut
  call void %16(i8 10)
  ret void
}

define void @putChunked(i8) align 8 {
$1:
; # (let I (val $CnkCnt) (set (ofs $CnkBuf I) B) (ifn (== (inc I) CHU...
; # (val $CnkCnt)
  %1 = load i32, i32* @$CnkCnt
; # (set (ofs $CnkBuf I) B)
; # (ofs $CnkBuf I)
  %2 = getelementptr i8, i8* bitcast ([4000 x i8]* @$CnkBuf to i8*), i32 %1
  store i8 %0, i8* %2
; # (ifn (== (inc I) CHUNK) (set $CnkCnt @) (wrChunk @) (set $CnkCnt ...
; # (inc I)
  %3 = add i32 %1, 1
; # (== (inc I) CHUNK)
  %4 = icmp eq i32 %3, 4000
  br i1 %4, label %$3, label %$2
$2:
; # (set $CnkCnt @)
  store i32 %3, i32* @$CnkCnt
  br label %$4
$3:
; # (wrChunk @)
  call void @wrChunk(i32 %3)
; # (set $CnkCnt 0)
  store i32 0, i32* @$CnkCnt
  br label %$4
$4:
  %5 = phi i32 [%3, %$2], [0, %$3] ; # ->
  ret void
}

define i64 @Out(i64) align 8 {
$1:
; # (let (X (cdr Exe) F (eval (++ X))) (if (nil? F) (setq X (run X)) ...
; # (cdr Exe)
  %1 = inttoptr i64 %0 to i64*
  %2 = getelementptr i64, i64* %1, i32 1
  %3 = load i64, i64* %2
; # (++ X)
  %4 = inttoptr i64 %3 to i64*
  %5 = load i64, i64* %4
  %6 = getelementptr i64, i64* %4, i32 1
  %7 = load i64, i64* %6
; # (eval (++ X))
  %8 = and i64 %5, 6
  %9 = icmp ne i64 %8, 0
  br i1 %9, label %$4, label %$3
$4:
  br label %$2
$3:
  %10 = and i64 %5, 8
  %11 = icmp ne i64 %10, 0
  br i1 %11, label %$6, label %$5
$6:
  %12 = inttoptr i64 %5 to i64*
  %13 = load i64, i64* %12
  br label %$2
$5:
  %14 = call i64 @evList(i64 %5)
  br label %$2
$2:
  %15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
; # (if (nil? F) (setq X (run X)) (set $CnkCnt 0 (i8** $SvPut) (val (...
; # (nil? F)
  %16 = icmp eq i64 %15, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 8) to i64)
  br i1 %16, label %$7, label %$8
$7:
  %17 = phi i64 [%7, %$2] ; # X
; # (run X)
  br label %$10
$10:
  %18 = phi i64 [%17, %$7], [%40, %$19] ; # Prg
  %19 = inttoptr i64 %18 to i64*
  %20 = load i64, i64* %19
  %21 = getelementptr i64, i64* %19, i32 1
  %22 = load i64, i64* %21
  %23 = and i64 %22, 15
  %24 = icmp ne i64 %23, 0
  br i1 %24, label %$13, label %$11
$13:
  %25 = phi i64 [%22, %$10] ; # Prg
  %26 = and i64 %20, 6
  %27 = icmp ne i64 %26, 0
  br i1 %27, label %$16, label %$15
$16:
  br label %$14
$15:
  %28 = and i64 %20, 8
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %$18, label %$17
$18:
  %30 = inttoptr i64 %20 to i64*
  %31 = load i64, i64* %30
  br label %$14
$17:
  %32 = call i64 @evList(i64 %20)
  br label %$14
$14:
  %33 = phi i64 [%20, %$16], [%31, %$18], [%32, %$17] ; # ->
  br label %$12
$11:
  %34 = phi i64 [%22, %$10] ; # Prg
  %35 = and i64 %20, 15
  %36 = icmp eq i64 %35, 0
  br i1 %36, label %$20, label %$19
$20:
  %37 = phi i64 [%34, %$11] ; # Prg
  %38 = call i64 @evList(i64 %20)
  %39 = icmp ne i64 %38, 0
  br label %$19
$19:
  %40 = phi i64 [%34, %$11], [%37, %$20] ; # Prg
  %41 = phi i1 [0, %$11], [%39, %$20] ; # ->
  br label %$10
$12:
  %42 = phi i64 [%25, %$14] ; # Prg
  %43 = phi i64 [%33, %$14] ; # ->
  br label %$9
$8:
  %44 = phi i64 [%7, %$2] ; # X
; # (set $CnkCnt 0 (i8** $SvPut) (val (i8** $Put)) $Put (fun (void i8...
  store i32 0, i32* @$CnkCnt
; # (i8** $SvPut)
  %45 = bitcast void(i8)** @$SvPut to i8**
; # (i8** $Put)
  %46 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**) to i8**
; # (val (i8** $Put))
  %47 = load i8*, i8** %46
  store i8* %47, i8** %45
; # (fun (void i8) putChunked)
  store void(i8)* @putChunked, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**)
; # (run X)
  br label %$21
$21:
  %48 = phi i64 [%44, %$8], [%70, %$30] ; # Prg
  %49 = inttoptr i64 %48 to i64*
  %50 = load i64, i64* %49
  %51 = getelementptr i64, i64* %49, i32 1
  %52 = load i64, i64* %51
  %53 = and i64 %52, 15
  %54 = icmp ne i64 %53, 0
  br i1 %54, label %$24, label %$22
$24:
  %55 = phi i64 [%52, %$21] ; # Prg
  %56 = and i64 %50, 6
  %57 = icmp ne i64 %56, 0
  br i1 %57, label %$27, label %$26
$27:
  br label %$25
$26:
  %58 = and i64 %50, 8
  %59 = icmp ne i64 %58, 0
  br i1 %59, label %$29, label %$28
$29:
  %60 = inttoptr i64 %50 to i64*
  %61 = load i64, i64* %60
  br label %$25
$28:
  %62 = call i64 @evList(i64 %50)
  br label %$25
$25:
  %63 = phi i64 [%50, %$27], [%61, %$29], [%62, %$28] ; # ->
  br label %$23
$22:
  %64 = phi i64 [%52, %$21] ; # Prg
  %65 = and i64 %50, 15
  %66 = icmp eq i64 %65, 0
  br i1 %66, label %$31, label %$30
$31:
  %67 = phi i64 [%64, %$22] ; # Prg
  %68 = call i64 @evList(i64 %50)
  %69 = icmp ne i64 %68, 0
  br label %$30
$30:
  %70 = phi i64 [%64, %$22], [%67, %$31] ; # Prg
  %71 = phi i1 [0, %$22], [%69, %$31] ; # ->
  br label %$21
$23:
  %72 = phi i64 [%55, %$25] ; # Prg
  %73 = phi i64 [%63, %$25] ; # ->
; # (when (val $CnkCnt) (wrChunk @))
; # (val $CnkCnt)
  %74 = load i32, i32* @$CnkCnt
  %75 = icmp ne i32 %74, 0
  br i1 %75, label %$32, label %$33
$32:
  %76 = phi i64 [%73, %$23] ; # X
; # (wrChunk @)
  call void @wrChunk(i32 %74)
  br label %$33
$33:
  %77 = phi i64 [%73, %$23], [%76, %$32] ; # X
; # (set (i8** $Put) (val (i8** $SvPut)))
; # (i8** $Put)
  %78 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 88) to void(i8)**) to i8**
; # (i8** $SvPut)
  %79 = bitcast void(i8)** @$SvPut to i8**
; # (val (i8** $SvPut))
  %80 = load i8*, i8** %79
  store i8* %80, i8** %78
; # (unless (t? F) (outString ($ "0^M^J^M^J")))
; # (t? F)
  %81 = icmp eq i64 %15, ptrtoint (i8* getelementptr (i8, i8* bitcast ([888 x i64]* @SymTab to i8*), i32 280) to i64)
  br i1 %81, label %$35, label %$34
$34:
  %82 = phi i64 [%77, %$33] ; # X
; # (outString ($ "0^M^J^M^J"))
  call void @outString(i8* bitcast ([6 x i8]* @$11 to i8*))
  br label %$35
$35:
  %83 = phi i64 [%77, %$33], [%82, %$34] ; # X
  br label %$9
$9:
  %84 = phi i64 [%43, %$12], [%83, %$35] ; # X
; # (val $OutFile)
  %85 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([25 x i64]* @env to i8*), i32 80) to i8**)
; # (flush (val $OutFile))
  %86 = call i1 @flush(i8* %85)
  ret i64 %84
}

@$11 = private constant [6 x i8] c"0\0D\0A\0D\0A\00"
@$10 = private constant [6 x i8] c"nbsp;\00"
@$9 = private constant [6 x i8] c"quot;\00"
@$8 = private constant [5 x i8] c"amp;\00"
@$7 = private constant [4 x i8] c"gt;\00"
@$6 = private constant [4 x i8] c"lt;\00"
@$5 = private constant [14 x i8] c" \22#%&:;<=>?\_\00"
@$4 = private constant [7 x i8] c""\00"
@$3 = private constant [6 x i8] c"&\00"
@$2 = private constant [5 x i8] c">\00"
@$1 = private constant [5 x i8] c"<\00"
pil21/src/balance.c0000644000000000000000000000401010262666115011213 0ustar  /* balance.c
 * 06jul05abu
 */

#include 
#include 
#include 
#include 
#include 
#include 
#include 

int Len, Siz;
char *Line, **Data;

static void giveup(char *msg) {
   fprintf(stderr, "balance: %s\n", msg);
   exit(1);
}

static char *getLine(FILE *fp) {
	int i, c;
   char *s;

   i = 0;
   while ((c = getc_unlocked(fp)) != '\n') {
      if (c == EOF)
         return NULL;
      Line[i] = c;
      if (++i == Len  &&  !(Line = realloc(Line, Len *= 2)))
         giveup("No memory");
   }
   Line[i] = '\0';
   if (!(s = strdup(Line)))
      giveup("No memory");
   return s;
}

static void balance(char **data, int len) {
   if (len) {
      int n = (len + 1) / 2;
      char **p = data + n - 1;

      printf("%s\n", *p);
      balance(data, n - 1);
      balance(p + 1, len - n);
   }
}

// balance [- [ ..]]
// balance []
int main(int ac, char *av[]) {
   int cnt;
   char *s;
   pid_t pid = 0;
   FILE *fp = stdin;

   if (ac > 1) {
      if (*av[1] == '-') {
         int pfd[2];

         if (pipe(pfd) < 0)
            giveup("Pipe error\n");
         if ((pid = fork()) == 0) {
            close(pfd[0]);
            if (pfd[1] != STDOUT_FILENO)
               dup2(pfd[1], STDOUT_FILENO),  close(pfd[1]);
            execvp(av[1]+1, av+1);
         }
         if (pid < 0)
            giveup("Fork error\n");
         close(pfd[1]);
         if (!(fp = fdopen(pfd[0], "r")))
            giveup("Pipe open error\n");
      }
      else if (!(fp = fopen(av[1], "r")))
         giveup("File open error\n");
   }
   Line = malloc(Len = 4096);
   Data = malloc((Siz = 4096) * sizeof(char*));
   for (cnt = 0;  s = getLine(fp);  ++cnt) {
      if (cnt == Siz  &&  !(Data = realloc(Data, (Siz *= 2) * sizeof(char*))))
         giveup("No memory");
      Data[cnt] = s;
   }
   if (pid) {
      fclose(fp);
      while (waitpid(pid, NULL, 0) < 0)
         if (errno != EINTR)
            giveup("Pipe close error\n");
   }
   balance(Data, cnt);
   return 0;
}
pil21/src/ssl.c0000644000000000000000000002616714332777734010464 0ustar  // 09nov22 Software Lab. Alexander Burger

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

#include 
#include 
#include 
#include 

typedef enum {NO,YES} bool;

static bool Safe, Hold, Done;

static char Node[40];  // 0000:0000:0000:0000:0000:0000:0000:0000

static char Ciphers[] = "EECDH+AESGCM:EDH+AESGCM:AES256+EECDH:AES256+EDH";

static char Get[] =
   "GET /%s HTTP/1.0\r\n"
   "User-Agent: PicoLisp\r\n"
   "Host: %s:%s\r\n"
   "Accept-Charset: utf-8\r\n\r\n";

static void giveup(char *msg) {
   fprintf(stderr, "ssl: %s", msg);
   putc('\n',stderr);
   exit(1);
}

static int sslConnect(SSL *ssl, char *node, char *service) {
   struct addrinfo hints, *lst, *p;
   int n, fd, sd;
   char *q;

   if (strchr(node, '/')  &&  (fd = open(node, O_RDONLY)) >= 0) {
      if ((n = read(fd, Node, sizeof(Node))) > 0) {
         if ((q = strchr(Node, '\n')) && q < Node+n)
            *q = '\0';
         node = Node;
      }
      close(fd);
   }
   memset(&hints, 0, sizeof(hints));
   hints.ai_family = AF_UNSPEC;
   hints.ai_socktype = SOCK_STREAM;
   if (getaddrinfo(node, service, &hints, &lst) == 0) {
      for (p = lst; p; p = p->ai_next) {
         if ((sd = socket(p->ai_family, p->ai_socktype, 0)) >= 0) {
            if (connect(sd, p->ai_addr, p->ai_addrlen) == 0) {
               SSL_set_fd(ssl, sd);
               if (SSL_connect(ssl) == 1) {
                  X509 *cert;

                  freeaddrinfo(lst);
                  if (Safe)
                     return sd;
                  if (cert = SSL_get_peer_certificate(ssl)) {
                     X509_free(cert);
                     if (SSL_get_verify_result(ssl) == X509_V_OK)
                        return sd;
                  }
                  return -1;
               }
            }
            close(sd);
         }
      }
      freeaddrinfo(lst);
   }
   return -1;
}

static void sslClose(SSL *ssl, int sd) {
   SSL_shutdown(ssl);
   SSL_clear(ssl);
   close(sd);
}

static bool sslFile(SSL *ssl, char *file) {
   int fd, n;
   char buf[BUFSIZ];

   if (file[0] == '-') {
      if (file[1] != '\0')
         return SSL_write(ssl, file+1, strlen(file)-1) >= 0;
      fd = STDIN_FILENO;
   }
   else if ((fd = open(file, O_RDONLY)) < 0)
      return NO;
   while ((n = read(fd, buf, sizeof(buf))) > 0)
      if (SSL_write(ssl, buf, n) < 0) {
         close(fd);
         return NO;
      }
   close(fd);
   return n == 0;
}

static off_t lockFile(int fd) {
   struct flock fl;
   struct stat st;

   fl.l_type = F_WRLCK;
   fl.l_whence = SEEK_SET;
   fl.l_start = 0;
   fl.l_len = 0;
   if (fcntl(fd, F_SETLKW, &fl) < 0)
      giveup("Can't lock");
   if (fstat(fd, &st) < 0)
      giveup("Can't access");
   if (st.st_size == 0)
      giveup("Size error");
   return st.st_size;
}

static void doSigTerm(int n __attribute__((unused))) {
   if (Hold)
      Done = YES;
   else
      exit(0);
}

static void iSigTerm(int n) {
   struct sigaction act;

   act.sa_handler = doSigTerm;
   sigemptyset(&act.sa_mask);
   act.sa_flags = 0;
   sigaction(n, &act, NULL);
}

// ssl host port [url key file]
// ssl host port url key file dir sec [min] [dir ..]
int main(int ac, char *av[]) {
   bool dbg;
   SSL_CTX *ctx;
   SSL *ssl;
   int i, n, sec, lim, getLen, lenLen, fd, sd;
   char *file, *dir, *data;
   DIR *dp;
   struct dirent *p;
   struct stat st;
   off_t size, size2;
   char get[1024], buf[4096], nm[4096], len[64];

   if (dbg = strcmp(av[ac-1], "+") == 0)
      --ac;
   if (!(ac >= 3 && ac <= 6  ||  ac >= 8))
      giveup("host port [url key file] | host port url key file dir sec [min] [dir ..]");
   if (*av[2] == '-')
      ++av[2],  Safe = YES;
   if (ac <= 3)
      getLen = 0;
   else {
      if (strlen(Get)+strlen(av[1])+strlen(av[2])+strlen(av[3]) >= sizeof(get))
         giveup("Names too long");
      getLen = sprintf(get, Get, av[3], av[1], av[2]);
   }

   SSL_library_init();
   SSL_load_error_strings();
   if (!(ctx = SSL_CTX_new(SSLv23_client_method())) || !SSL_CTX_set_default_verify_paths(ctx)) {
      ERR_print_errors_fp(stderr);
      giveup("SSL init");
   }
   SSL_CTX_set_options(ctx,
      SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3 | SSL_OP_NO_TLSv1 |
      SSL_OP_NO_TLSv1_1 | SSL_OP_ALL | SSL_OP_NO_COMPRESSION );
   SSL_CTX_set_cipher_list(ctx, Ciphers);
   ssl = SSL_new(ctx);
   SSL_set_tlsext_host_name(ssl, av[1]);
   if (!Safe) {
      X509_VERIFY_PARAM *par = SSL_get0_param(ssl);
      X509_VERIFY_PARAM_set_hostflags(par, X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS);
      X509_VERIFY_PARAM_set1_host(par, av[1], 0);
      SSL_set_verify(ssl, SSL_VERIFY_PEER, NULL);
   }

   signal(SIGCHLD,SIG_IGN);  /* Prevent zombies */
   signal(SIGPIPE, SIG_IGN);
   if (ac <= 6) {
      if (sslConnect(ssl, av[1], av[2]) < 0) {
         ERR_print_errors_fp(stderr);
         exit(1);
      }
      if (getLen  &&  SSL_write(ssl, get, getLen) < 0) {
         ERR_print_errors_fp(stderr);
         giveup("SSL GET");
      }
      if (ac > 4) {
         if (*av[4]  &&  !sslFile(ssl,av[4]))
            giveup("Can't send");
         if (ac > 5  &&  *av[5]  &&  !sslFile(ssl,av[5]))
            giveup("Can't send");
      }
      if (!getLen  &&  !fork()) {
         while ((n = read(STDIN_FILENO, buf, sizeof(buf))) > 0)
            SSL_write(ssl, buf, n);
         return 0;
      }
      while ((n = SSL_read(ssl, buf, sizeof(buf))) > 0)
         write(STDOUT_FILENO, buf, n);
      if (dbg)
         ERR_print_errors_fp(stderr);
      return 0;
   }
   if (!dbg) {
      if ((n = fork()) < 0)
         giveup("Can't detach");
      if (n)
         return 0;
      setsid();
   }
   file = av[5];
   dir = av[6];
   sec = atoi(av[7]);
   iSigTerm(SIGINT);
   iSigTerm(SIGTERM);
   lim = 0;
   if (ac >= 9 && *av[8]) {
      if ((lim = atoi(av[8])) == 0) {
         printf("%d\n", getpid());
         fflush(stdout);
      }
      else {
         iSigTerm(SIGALRM);
         alarm(lim *= 60);
      }
   }
   for (;;) {
      if (*file && (fd = open(file, O_RDWR)) >= 0) {
         if (fstat(fd,&st) < 0  ||  st.st_size == 0)
            close(fd);
         else {
            lenLen = sprintf(len, "%ld\n", size = lockFile(fd));
            if ((data = malloc(size)) == NULL)
               giveup("Can't alloc");
            if (read(fd, data, size) != size)
               giveup("Can't read");
            close(fd);
            alarm(0);
            for (nm[0] = '\0', i = 9;  i < ac;  ++i) {
               if (dp = opendir(av[i])) {
                  int max = 0;
                  char *q;

                  while (p = readdir(dp))
                     if ((n = (int)strtol(p->d_name, &q, 10)) > max  &&  !*q)
                        max = n;
                  if (nm[0]) {
                     snprintf(buf, sizeof(buf), "%s%d", av[i], max + 1);
                     link(nm, buf);
                  }
                  else {
                     snprintf(nm, sizeof(nm), "%s%d", av[i], max + 1);
                     if ((fd = open(nm, O_CREAT|O_EXCL|O_WRONLY, 0666)) < 0)
                        nm[0] = '\0';
                     else {
                        write(fd, data, size);
                        close(fd);
                     }
                  }
                  closedir(dp);
               }
            }
            if (!*av[4])
               goto truncate;
            for (;;) {
               if ((sd = sslConnect(ssl, av[1], av[2])) >= 0) {
                  if (SSL_write(ssl, get, getLen) == getLen  &&
                        sslFile(ssl,av[4])  &&                    // key
                        SSL_write(ssl, len, lenLen) == lenLen  && // length
                        SSL_write(ssl, data, size) == size  &&    // data
                        SSL_write(ssl, "T", 1) == 1  &&           // ack
                        SSL_read(ssl, buf, 1) == 1  &&  buf[0] == 'T' ) {
                     sslClose(ssl,sd);
                  truncate:
                     if ((fd = open(file, O_RDWR)) < 0)
                        giveup("Can't re-open");
                     if (size2 = lockFile(fd) - size) {
                        if ((data = realloc(data, size2)) == NULL)
                           giveup("Can't re-alloc");
                        if (pread(fd, data, size2, size) != size2)
                           giveup("Can't re-read");
                        Hold = YES;
                        if (pwrite(fd, data, size2, 0) != size2)
                           giveup("Can't re-write");
                     }
                     if (ftruncate(fd, size2) < 0)
                        giveup("Can't truncate");
                     close(fd);
                     Hold = NO;
                     if (Done)
                        exit(0);
                     break;
                  }
                  sslClose(ssl,sd);
               }
               if (dbg)
                  ERR_print_errors_fp(stderr);
               sleep(sec);
            }
            alarm(lim);
            free(data);
         }
      }
      if (*av[4] && *dir && (dp = opendir(dir))) {
         char *pwd = getcwd(NULL, 0);

         while (p = readdir(dp)) {
            if (p->d_name[0] == '=') {
               snprintf(nm, sizeof(nm), "%s%s", dir, p->d_name);
               if ((n = readlink(nm, buf, sizeof(buf))) > 0)
                  if (stat(nm, &st) < 0)
                     unlink(nm);
                  else {
                     buf[n] = '\0';
                     for (i = 9;  i < ac;  ++i) {
                        if (chdir(av[i]) == 0) {
                           char *q = av[i];
                           char nm2[4096];

                           nm2[0] = '\0';
                           do
                              if (*q == '/')
                                 strcat(nm2, "../");
                           while (*++q);
                           strcat(nm2, dir);
                           strcat(nm2, buf);
                           symlink(nm2, p->d_name);
                           chdir(pwd);
                        }
                     }
                     lenLen = sprintf(len, "%ld\n", st.st_size);
                     buf[n++] = '\n';
                     alarm(lim);
                     if ((sd = sslConnect(ssl, av[1], av[2])) >= 0) {
                        if (SSL_write(ssl, get, getLen) == getLen  &&
                              sslFile(ssl,av[4])  &&                    // key
                              SSL_write(ssl, buf, n) == n  &&           // path
                              SSL_write(ssl, len, lenLen) == lenLen  && // length
                              sslFile(ssl, nm)  &&                      // file
                              SSL_write(ssl, "T", 1) == 1  &&           // ack
                              SSL_read(ssl, buf, 1) == 1  &&  buf[0] == 'T' )
                           unlink(nm);
                        sslClose(ssl,sd);
                     }
                     if (dbg)
                        ERR_print_errors_fp(stderr);
                  }
            }
         }
         free(pwd);
         closedir(dp);
      }
      sleep(sec);
   }
}
pil21/src/httpGate.c0000644000000000000000000003406314450730717011424 0ustar  // 04jul23 Software Lab. Alexander Burger

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

#include 
#include 
#include 

typedef enum {NO,YES} bool;

typedef struct name {
   char *key, *ins;
   struct name *less, *more;
   int port;
   uid_t uid;
   gid_t gid;
   char *dir, *log, *ev[5], *av[1];
} name;

static bool Hup;
static name *Names;
static char *Config;
static int CliSock, SrvSock;
static char Ciphers[] = "EECDH+AESGCM:EDH+AESGCM:AES256+EECDH:AES256+EDH";

static char Head_302[] =
   "HTTP/1.0 302 Found\r\n"
   "Server: PicoLisp\r\n"
   "Location: %s\r\n"
   "\r\n";

static char Head_410[] =
   "HTTP/1.0 410 Gone\r\n"
   "Server: PicoLisp\r\n"
   "Content-Type: text/html; charset=utf-8\r\n"
   "\r\n";

static void giveup(char *msg) {
   fprintf(stderr, "httpGate: %s\n", msg);
   exit(1);
}

static int readNames(void) {
   FILE *fp;
   name *np, **t;
   int port, cnt;
   struct passwd *pw;
   char *p, *q, *ps, line[4096];
   static char delim[] = " \n";

   if (!(fp = fopen(Config, "r")))     // Lines ordered by
      giveup("Can't open name file");  // bin/balance -sort
   port = 8080;
   while (p = fgets(line, 4096, fp)) {
      while (*p == ' ')
         ++p;
      if (*p  &&  *p != '\n'  &&  *p != '#') {
         np = malloc(sizeof(name));
         np->less = np->more = NULL;
         p = strtok(p, delim);
         np->ins = NULL;
         if (q = strchr(p, '/')) {
            *q++ = '\0';
            np->ins = strdup(q);
         }
         np->key = strdup(p);
         if ((np->port = atoi(ps = strtok(NULL, delim))) == 0)
            np->dir = strdup(strtok(NULL, delim));
         else {
            if (!(pw = getpwnam(strtok(NULL, delim))) || pw->pw_uid == 0 || pw->pw_gid == 0) {
               free(np->key);
               free(np);
               continue;
            }
            np->uid = pw->pw_uid;
            np->gid = pw->pw_gid;
            p = np->ev[0] = malloc(5 + strlen(np->key) + 1);
            strcpy(p, "NAME="), strcpy(p+5, np->key);
            p = np->ev[1] = malloc(5 + strlen(pw->pw_dir) + 1);
            strcpy(p, "HOME="), strcpy(p+5, pw->pw_dir);
            p = np->ev[2] = malloc(5 + strlen(ps) + 1);
            strcpy(p, "PORT="), strcpy(p+5, ps);
            p = np->ev[3] = malloc(5 + strlen(q = getenv("LANG")) + 1);
            strcpy(p, "LANG="), strcpy(p+5, q);
            np->ev[4] = NULL;
            np->dir = strdup(strtok(NULL, delim));
            np->log = *(p = strtok(NULL, delim)) == '^'? NULL : strdup(p);
            cnt = 0;
            while (p = strtok(NULL, delim)) {
               if (*p == '^')
                  np->av[cnt] = strdup("");
               else {
                  p = np->av[cnt] = strdup(p);
                  while (p = strchr(p, '^'))
                     *p++ = ' ';
               }
               np = realloc(np, sizeof(name) + ++cnt * sizeof(char*));
            }
            np->av[cnt] = NULL;
         }
         p = np->key;
         if (!Names  ||  p[0] == '@' && p[1] == '\0')
            port = np->port;
         for (t = &Names;  *t;  t = strcasecmp(p, (*t)->key) >= 0? &(*t)->more : &(*t)->less);
         *t = np;
      }
   }
   fclose(fp);
   return port;
}

static void freeNames(name *np) {
   int i;

   free(np->key);
   if (np->less)
      freeNames(np->less);
   if (np->more)
      freeNames(np->more);
   free(np->dir);
   if (np->port) {
      free(np->log);
      for (i = 0; i < 4; ++i)
         free(np->ev[i]);
      for (i = 0; np->av[i]; ++i)
         free(np->av[i]);
   }
   free(np);
}

static name *findName(char *p, char *q) {
   name *np;
   int n, c;

   if (p == q) {
      if (Names && !Names->more && !Names->less)
         return Names;
      p = "@";
   }
   c = *q,  *q = '\0';
   for (np = Names;  np;  np = n > 0? np->more : np->less)
      if ((n = strcasecmp(p, np->key)) == 0) {
         *q = c;
         return np;
      }
   *q = c;
   return NULL;
}

static int slow(SSL *ssl, int fd, char *p, int cnt) {
   int n;

   while ((n = ssl? SSL_read(ssl, p, cnt) : read(fd, p, cnt)) < 0)
      if (errno != EINTR)
         return 0;
   return n;
}

static int rdLine(SSL *ssl, int fd, char *p, int cnt) {
   int n, len;

   for (len = 0;;) {
      if ((n = ssl? SSL_read(ssl, p, cnt) : read(fd, p, cnt)) <= 0) {
         if (!n || errno != EINTR)
            return 0;
      }
      else {
         len += n;
         if (memchr(p, '\n', n))
            return len;
         p += n;
         if ((cnt -= n) == 0)
            return 0;
      }
   }
}

static void wrBytes(int fd, char *p, int cnt) {
   int n;

   do
      if ((n = write(fd, p, cnt)) >= 0)
         p += n, cnt -= n;
      else if (errno != EINTR)
         exit(1);
   while (cnt);
}

static void sslWrite(SSL *ssl, void *p, int cnt) {
   if (SSL_write(ssl, p, cnt) <= 0)
      exit(1);
}

static bool setDH(SSL_CTX *ctx) {
   EC_KEY *ecdh;

   if (!(ecdh = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1)))
      return NO;
   if (!SSL_CTX_set_tmp_ecdh(ctx, ecdh))
      return NO;
   EC_KEY_free(ecdh);
   SSL_CTX_set_cipher_list(ctx, Ciphers);
   return YES;
}

static int gatePort(unsigned short port) {
   int sd, n;
   struct sockaddr_in6 addr;

   if ((sd = socket(AF_INET6, SOCK_STREAM, 0)) < 0)
      exit(1);
   n = 0;
#ifndef __OpenBSD__
   if (setsockopt(sd, IPPROTO_IPV6, IPV6_V6ONLY, &n, sizeof(n)) < 0)
      exit(1);
#endif
   memset(&addr, 0, sizeof(addr));
   addr.sin6_family = AF_INET6;
   addr.sin6_addr = in6addr_any;
   n = 1;
   if (setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, &n, sizeof(n)) < 0)
      exit(1);
   addr.sin6_port = htons(port);
   if (bind(sd, (struct sockaddr*)&addr, sizeof(addr)) < 0)
      exit(1);
   if (listen(sd,5) < 0)
      exit(1);
   return sd;
}

static int gateConnect(int port, name *np) {
   int sd;
   struct sockaddr_in6 addr;

   if ((sd = socket(AF_INET6, SOCK_STREAM, 0)) < 0)
      exit(1);
   memset(&addr, 0, sizeof(addr));
   addr.sin6_family = AF_INET6;
   addr.sin6_addr = in6addr_loopback;
   addr.sin6_port = htons((unsigned short)port);
   if (connect(sd, (struct sockaddr*)&addr, sizeof(addr)) >= 0)
      return sd;
   if (np) {
      int fd;
      pid_t pid;

      if (np->log) {
         struct flock fl;
         char log[strlen(np->dir) + 1 + strlen(np->log) + 1];

         if (np->log[0] == '/')
            strcat(log, np->log);
         else
            sprintf(log, "%s/%s", np->dir, np->log);
         if ((fd = open(log, O_RDWR)) >= 0) {
            fl.l_type = F_WRLCK;
            fl.l_whence = SEEK_SET;
            fl.l_start = 0;
            fl.l_len = 0;
            if (fcntl(fd, F_SETLK, &fl) < 0) {
               if (errno != EACCES  &&  errno != EAGAIN  ||
                           fcntl(fd, F_SETLKW, &fl) < 0  ||
                           connect(sd, (struct sockaddr*)&addr, sizeof(addr)) < 0)
                  return -1;
               close(fd);
               return sd;
            }
         }
      }
      if ((pid = fork()) == 0) {
         if (setgid(np->gid) == 0 && setuid(np->uid) == 0 && chdir(np->dir) == 0) {
            setpgid(0,0);
            if (np->log)
               freopen(np->log, "a", stdout);
            dup2(STDOUT_FILENO, STDERR_FILENO);
            execve(np->av[0], np->av, np->ev);
            exit(1);
         }
      }
      if (pid > 0) {
         setpgid(pid,0);
         int i = 200;
         do {
            usleep(100000);  // 100 ms
            if (connect(sd, (struct sockaddr*)&addr, sizeof(addr)) >= 0) {
               if (np->log  &&  fd >= 0)
                  close(fd);
               return sd;
            }
         } while (--i);
      }
   }
   return -1;
}


static pid_t Buddy;

static void doSigAlarm(int n __attribute__((unused))) {
   kill(Buddy, SIGTERM);
   shutdown(CliSock, SHUT_RDWR);
   shutdown(SrvSock, SHUT_RDWR);
   exit(0);
}

static void doSigUsr1(int n __attribute__((unused))) {
   alarm(420);
}

static void doSigHup(int n __attribute__((unused))) {
   Hup = YES;
}

static void iSignal(int n, void (*foo)(int)) {
   struct sigaction act;

   act.sa_handler = foo;
   sigemptyset(&act.sa_mask);
   act.sa_flags = 0;
   sigaction(n, &act, NULL);
}

int main(int ac, char *av[]) {
   int cnt = ac>4? ac-3 : 1, ports[cnt], n, sd;
   struct sockaddr_in6 addr;
   char s[INET6_ADDRSTRLEN];
   char *p, *q, *gate;
   SSL_CTX *ctx;
   SSL *ssl;

   if (ac < 3)
      giveup("port dflt [pem [deny ..]]");
   sd = gatePort(atoi(av[1]));  // e.g. 80 or 443
   ports[0] = (int)strtol(p = av[2], &q, 10);  // e.g. 8080
   if (q == p  ||  *q != '\0')
      Config = p,  ports[0] = readNames();
   if (ac == 3 || *av[3] == '\0')
      ssl = NULL,  gate = "X-Pil: *Gate=http\r\nX-Pil: *Adr=%s\r\n";
   else {
      SSL_library_init();
      SSL_load_error_strings();
      if (p = strchr(av[3], ','))
         *p++ = '\0';
      else
         p = av[3];
      if (!(ctx = SSL_CTX_new(SSLv23_server_method())) ||
         !SSL_CTX_use_PrivateKey_file(ctx, av[3], SSL_FILETYPE_PEM) ||
            !SSL_CTX_use_certificate_chain_file(ctx, p) ||
               !SSL_CTX_check_private_key(ctx) || !setDH(ctx) ) {
         ERR_print_errors_fp(stderr);
         giveup("SSL init");
      }
      SSL_CTX_set_options(ctx,
         SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3 | SSL_OP_NO_TLSv1 | SSL_OP_NO_TLSv1_1 |
         SSL_OP_ALL | SSL_OP_CIPHER_SERVER_PREFERENCE | SSL_OP_NO_COMPRESSION );
      ssl = SSL_new(ctx),  gate = "X-Pil: *Gate=https\r\nX-Pil: *Adr=%s\r\n";
   }
   for (n = 1; n < cnt; ++n)
      ports[n] = atoi(av[n+3]);
   signal(SIGCHLD, SIG_IGN);  /* Prevent zombies */
   if ((n = fork()) < 0)
      giveup("detach");
   if (n)
      return 0;
   setsid();
   if (Config)
      iSignal(SIGHUP, doSigHup);
   else
      signal(SIGHUP, SIG_IGN);
   for (;;) {
      if (Hup) {
         Hup = NO;
         freeNames(Names);
         Names = NULL;
         ports[0] = readNames();
      }
      socklen_t len = sizeof(addr);
      if ((CliSock = accept(sd, (struct sockaddr*)&addr, &len)) >= 0 && (n = fork()) >= 0) {
         if (!n) {
            name *np;
            int fd, port, i;
            char buf[4096], buf2[64];

            close(sd);

            alarm(420);
            if (ssl) {
               SSL_set_fd(ssl, CliSock);
               if (SSL_accept(ssl) < 0)
                  return 1;
            }
            n = rdLine(ssl, CliSock, buf, sizeof(buf));
            alarm(0);
            if (n < 6)
               return 1;

            /* "GET /url HTTP/1.x"
             * "GET /8080/url HTTP/1.x"
             * "POST /url HTTP/1.x"
             * "POST /8080/url HTTP/1.x"
             */
            if ((p = strchr(buf, ' ')) && *++p == '/')
               ++p;
            else
               return 1;

            np = NULL;
            port = (int)strtol(p, &q, 10);
            if (q == p  ||  *q != ' ' && *q != '/' && *q != '?') {
               if ((q = strpbrk(p, " /?")) && (np = findName(p, q)))
                  port = np->port;
               else
                  q = p,  port = (np = findName(p, q))? np->port : ports[0];  // "@"?
            }
            else if (port < 1024) {
               if (np = findName(p, q))
                  port = np->port;
               else
                  return 1;
            }
            else
               for (i = 1; i < cnt; ++i)
                  if (port == ports[i])
                     return 1;

            if (np && port == 0) {
               i = sprintf(buf, Head_302, np->dir);
               if (ssl)
                  sslWrite(ssl, buf, i);
               else
                  wrBytes(CliSock, buf, i);
               return 0;
            }
            if ((SrvSock = gateConnect(port, np)) < 0) {
               if (!memchr(q,'~', buf + n - q))
                  return 1;
               if ((fd = open("void", O_RDONLY)) < 0)
                  return 1;
               alarm(420);
               if (ssl)
                  sslWrite(ssl, Head_410, strlen(Head_410));
               else
                  wrBytes(CliSock, Head_410, strlen(Head_410));
               alarm(0);
               while ((n = read(fd, buf, sizeof(buf))) > 0) {
                  alarm(420);
                  if (ssl)
                     sslWrite(ssl, buf, n);
                  else
                     wrBytes(CliSock, buf, n);
                  alarm(0);
               }
               return 0;
            }

            wrBytes(SrvSock, buf, p - buf);
            if (np  &&  (p = np->ins))
               wrBytes(SrvSock, p, strlen(p));
            else if (*q == '/')
               ++q;
            p = q;
            while (*p++ != '\n')
               if (p >= buf + n)
                  return 1;
            wrBytes(SrvSock, q, p - q);
            inet_ntop(AF_INET6, &addr.sin6_addr, s, INET6_ADDRSTRLEN);
            wrBytes(SrvSock, buf2, sprintf(buf2, gate, s));
            if (ssl)
               wrBytes(SrvSock, buf2, sprintf(buf2, "X-Pil: *Cipher=%s\r\n", SSL_get_cipher(ssl)));
            wrBytes(SrvSock, p, buf + n - p);

            iSignal(SIGALRM, doSigAlarm);
            iSignal(SIGUSR1, doSigUsr1);
            if (Buddy = fork()) {
               for (;;) {
                  alarm(420);
                  n = slow(ssl, CliSock, buf, sizeof(buf));
                  alarm(0);
                  if (!n)
                     break;
                  wrBytes(SrvSock, buf, n);
               }
               shutdown(CliSock, SHUT_RD);
               shutdown(SrvSock, SHUT_WR);
            }
            else {
               Buddy = getppid();
               while ((n = read(SrvSock, buf, sizeof(buf))) > 0) {
                  kill(Buddy, SIGUSR1);
                  alarm(420);
                  if (ssl)
                     sslWrite(ssl, buf, n);
                  else
                     wrBytes(CliSock, buf, n);
                  alarm(0);
               }
               shutdown(SrvSock, SHUT_RD);
               shutdown(CliSock, SHUT_WR);
            }
            return 0;
         }
         close(CliSock);
      }
   }
}
pil21/lib/map0000644000000000000000000020200714771742740010157 0ustar  llvm~$ (277 "@src/lib/llvm.l" llvm pico)
llvm~$AV (6 "@src/glob.l" llvm pico)
llvm~$AV0 (5 "@src/glob.l" llvm pico)
llvm~$Alarm (560 "@src/glob.l" llvm pico)
llvm~$At (128 "@src/glob.l" llvm pico)
llvm~$At2 (129 "@src/glob.l" llvm pico)
llvm~$At3 (130 "@src/glob.l" llvm pico)
llvm~$Avail (12 "@src/glob.l" llvm pico)
llvm~$B (122 "@src/glob.l" llvm pico)
llvm~$Bind (642 "@src/glob.l" llvm pico)
llvm~$BlkEnd (76 "@src/glob.l" llvm pico)
llvm~$BlkIndex (73 "@src/glob.l" llvm pico)
llvm~$BlkLink (74 "@src/glob.l" llvm pico)
llvm~$BlkPtr (75 "@src/glob.l" llvm pico)
llvm~$Break (643 "@src/glob.l" llvm pico)
llvm~$BufX (59 "@src/glob.l" llvm pico)
llvm~$Bye (151 "@src/glob.l" llvm pico)
llvm~$C (120 "@src/glob.l" llvm pico)
llvm~$CPU (112 "@src/glob.l" llvm pico)
llvm~$Catch (645 "@src/glob.l" llvm pico)
llvm~$Cb (612 "@src/glob.l" llvm pico)
llvm~$Cell (668 "@src/glob.l" llvm pico)
llvm~$Child (47 "@src/glob.l" llvm pico)
llvm~$Children (48 "@src/glob.l" llvm pico)
llvm~$Chr (662 "@src/glob.l" llvm pico)
llvm~$Class (137 "@src/glob.l" llvm pico)
llvm~$Complete (153 "@src/glob.l" llvm pico)
llvm~$ContPrmt (29 "@src/glob.l" llvm pico)
llvm~$Coroutines (16 "@src/glob.l" llvm pico)
llvm~$CrtFree (19 "@src/glob.l" llvm pico)
llvm~$CrtLast (18 "@src/glob.l" llvm pico)
llvm~$CtlFrames (649 "@src/glob.l" llvm pico)
llvm~$Current (17 "@src/glob.l" llvm pico)
llvm~$D (676 "@src/glob.l" llvm pico)
llvm~$DB (115 "@src/glob.l" llvm pico)
llvm~$DBs (70 "@src/glob.l" llvm pico)
llvm~$Db1 (126 "@src/glob.l" llvm pico)
llvm~$DbBlock (72 "@src/glob.l" llvm pico)
llvm~$DbFile (69 "@src/glob.l" llvm pico)
llvm~$DbFiles (68 "@src/glob.l" llvm pico)
llvm~$DbJnl (77 "@src/glob.l" llvm pico)
llvm~$DbLog (78 "@src/glob.l" llvm pico)
llvm~$Dbg (152 "@src/glob.l" llvm pico)
llvm~$Delim (697 "@src/glob.l" llvm pico)
llvm~$Empty (696 "@src/glob.l" llvm pico)
llvm~$End (58 "@src/glob.l" llvm pico)
llvm~$EndX (61 "@src/glob.l" llvm pico)
llvm~$EnvPad (665 "@src/glob.l" llvm pico)
llvm~$Err (147 "@src/glob.l" llvm pico)
llvm~$ErrFrames (648 "@src/glob.l" llvm pico)
llvm~$Ext (134 "@src/glob.l" llvm pico)
llvm~$ExtCnt (14 "@src/glob.l" llvm pico)
llvm~$ExtN (62 "@src/glob.l" llvm pico)
llvm~$ExtSkip (15 "@src/glob.l" llvm pico)
llvm~$Extern (13 "@src/glob.l" llvm pico)
llvm~$Extn (63 "@src/glob.l" llvm pico)
llvm~$Fork (150 "@src/glob.l" llvm pico)
llvm~$GcCount (65 "@src/glob.l" llvm pico)
llvm~$Get (653 "@src/glob.l" llvm pico)
llvm~$GetBin (39 "@src/glob.l" llvm pico)
llvm~$Heaps (11 "@src/glob.l" llvm pico)
llvm~$Hear (54 "@src/glob.l" llvm pico)
llvm~$Hup (139 "@src/glob.l" llvm pico)
llvm~$I (123 "@src/glob.l" llvm pico)
llvm~$InBye (692 "@src/glob.l" llvm pico)
llvm~$InFDs (32 "@src/glob.l" llvm pico)
llvm~$InFile (650 "@src/glob.l" llvm pico)
llvm~$InFiles (33 "@src/glob.l" llvm pico)
llvm~$InFrames (646 "@src/glob.l" llvm pico)
llvm~$Intern (557 "@src/glob.l" llvm pico)
llvm~$IoChar (37 "@src/glob.l" llvm pico)
llvm~$IoCnt (35 "@src/glob.l" llvm pico)
llvm~$IoIx (36 "@src/glob.l" llvm pico)
llvm~$Jam (691 "@src/glob.l" llvm pico)
llvm~$Key (659 "@src/glob.l" llvm pico)
llvm~$LastSym (542 "@src/glob.l" llvm pico)
llvm~$LineBuf (26 "@src/glob.l" llvm pico)
llvm~$LinePrmt (27 "@src/glob.l" llvm pico)
llvm~$LinePtr (25 "@src/glob.l" llvm pico)
llvm~$Link (641 "@src/glob.l" llvm pico)
llvm~$Lisp (562 "@src/glob.l" llvm pico)
llvm~$LispEnd (609 "@src/glob.l" llvm pico)
llvm~$M (675 "@src/glob.l" llvm pico)
llvm~$Make (660 "@src/glob.l" llvm pico)
llvm~$MaxBlkSize (71 "@src/glob.l" llvm pico)
llvm~$Meth (116 "@src/glob.l" llvm pico)
llvm~$Mic (51 "@src/glob.l" llvm pico)
llvm~$Month (684 "@src/glob.l" llvm pico)
llvm~$Msg (148 "@src/glob.l" llvm pico)
llvm~$N (119 "@src/glob.l" llvm pico)
llvm~$Next (657 "@src/glob.l" llvm pico)
llvm~$Nfds (41 "@src/glob.l" llvm pico)
llvm~$Nil (101 "@src/glob.l" llvm pico)
llvm~$NsLink (644 "@src/glob.l" llvm pico)
llvm~$OS (111 "@src/glob.l" llvm pico)
llvm~$OutFDs (40 "@src/glob.l" llvm pico)
llvm~$OutFile (651 "@src/glob.l" llvm pico)
llvm~$OutFiles (34 "@src/glob.l" llvm pico)
llvm~$OutFrames (647 "@src/glob.l" llvm pico)
llvm~$P (124 "@src/glob.l" llvm pico)
llvm~$PPid (114 "@src/glob.l" llvm pico)
llvm~$PRepl (689 "@src/glob.l" llvm pico)
llvm~$Parser (654 "@src/glob.l" llvm pico)
llvm~$Penv (1311 "@src/subr.l" llvm pico)
llvm~$Pico (105 "@src/glob.l" llvm pico)
llvm~$Pico1 (107 "@src/glob.l" llvm pico)
llvm~$PicoT (104 "@src/glob.l" llvm pico)
llvm~$Pid (113 "@src/glob.l" llvm pico)
llvm~$PilHome (7 "@src/glob.l" llvm pico)
llvm~$PilLen (8 "@src/glob.l" llvm pico)
llvm~$Pnl (1312 "@src/subr.l" llvm pico)
llvm~$Poll (42 "@src/glob.l" llvm pico)
llvm~$Priv (109 "@src/glob.l" llvm pico)
llvm~$PrivT (108 "@src/glob.l" llvm pico)
llvm~$Prompt (132 "@src/glob.l" llvm pico)
llvm~$Protect (663 "@src/glob.l" llvm pico)
llvm~$Ptr (57 "@src/glob.l" llvm pico)
llvm~$PtrX (60 "@src/glob.l" llvm pico)
llvm~$Put (652 "@src/glob.l" llvm pico)
llvm~$PutBin (38 "@src/glob.l" llvm pico)
llvm~$Quote (117 "@src/glob.l" llvm pico)
llvm~$Remark (154 "@src/glob.l" llvm pico)
llvm~$Repl (688 "@src/glob.l" llvm pico)
llvm~$ReplPrmt (28 "@src/glob.l" llvm pico)
llvm~$Ret (30 "@src/glob.l" llvm pico)
llvm~$Rt (46 "@src/glob.l" llvm pico)
llvm~$Rule (136 "@src/glob.l" llvm pico)
llvm~$Run (138 "@src/glob.l" llvm pico)
llvm~$S (121 "@src/glob.l" llvm pico)
llvm~$Scl (135 "@src/glob.l" llvm pico)
llvm~$SeedH (44 "@src/glob.l" llvm pico)
llvm~$SeedL (43 "@src/glob.l" llvm pico)
llvm~$Sig1 (140 "@src/glob.l" llvm pico)
llvm~$Sig2 (141 "@src/glob.l" llvm pico)
llvm~$Sigio (561 "@src/glob.l" llvm pico)
llvm~$Signal (81 "@src/glob.l" llvm pico)
llvm~$Slot (49 "@src/glob.l" llvm pico)
llvm~$Solo (127 "@src/glob.l" llvm pico)
llvm~$SpMiPipe (52 "@src/glob.l" llvm pico)
llvm~$Spkr (50 "@src/glob.l" llvm pico)
llvm~$Stdin (23 "@src/glob.l" llvm pico)
llvm~$Stdout (24 "@src/glob.l" llvm pico)
llvm~$StkLimit (20 "@src/glob.l" llvm pico)
llvm~$StkSize (22 "@src/glob.l" llvm pico)
llvm~$StkSizeT (21 "@src/glob.l" llvm pico)
llvm~$StrP (64 "@src/glob.l" llvm pico)
llvm~$Sync (693 "@src/glob.l" llvm pico)
llvm~$T (118 "@src/glob.l" llvm pico)
llvm~$TBuf (679 "@src/glob.l" llvm pico)
llvm~$TStp1 (143 "@src/glob.l" llvm pico)
llvm~$TStp2 (144 "@src/glob.l" llvm pico)
llvm~$Talking (53 "@src/glob.l" llvm pico)
llvm~$Tc (690 "@src/glob.l" llvm pico)
llvm~$TcoLnk (656 "@src/glob.l" llvm pico)
llvm~$TcoPar (655 "@src/glob.l" llvm pico)
llvm~$Tell (55 "@src/glob.l" llvm pico)
llvm~$TellBuf (56 "@src/glob.l" llvm pico)
llvm~$Term (145 "@src/glob.l" llvm pico)
llvm~$This (131 "@src/glob.l" llvm pico)
llvm~$Tilde (103 "@src/glob.l" llvm pico)
llvm~$Trace (664 "@src/glob.l" llvm pico)
llvm~$Transient (558 "@src/glob.l" llvm pico)
llvm~$TtyPid (31 "@src/glob.l" llvm pico)
llvm~$Typ (658 "@src/glob.l" llvm pico)
llvm~$USec (45 "@src/glob.l" llvm pico)
llvm~$Uni (149 "@src/glob.l" llvm pico)
llvm~$Up (146 "@src/glob.l" llvm pico)
llvm~$UsrHome (9 "@src/glob.l" llvm pico)
llvm~$UsrLen (10 "@src/glob.l" llvm pico)
llvm~$Version (673 "@src/glob.l" llvm pico)
llvm~$W (125 "@src/glob.l" llvm pico)
llvm~$Winch (142 "@src/glob.l" llvm pico)
llvm~$Y (674 "@src/glob.l" llvm pico)
llvm~$Yoke (661 "@src/glob.l" llvm pico)
llvm~$Zap (133 "@src/glob.l" llvm pico)
llvm~$pico (106 "@src/glob.l" llvm pico)
llvm~$priv (110 "@src/glob.l" llvm pico)
llvm~$rem (164 "@src/glob.l" llvm pico)
llvm~% (973 "@src/lib/llvm.l" llvm pico)
llvm~& (973 "@src/lib/llvm.l" llvm pico)
llvm~* (973 "@src/lib/llvm.l" llvm pico)
llvm~*C-Defs (73 "@src/lib/llvm.l" llvm pico)
llvm~+ (903 "@src/lib/llvm.l" llvm pico)
llvm~++ (1072 "@src/lib/llvm.l" llvm pico)
llvm~+bind (198 "@src/lib/llvm.l" llvm pico)
llvm~+lbl (195 "@src/lib/llvm.l" llvm pico)
llvm~+phi (150 "@src/lib/llvm.l" llvm pico)
llvm~- (903 "@src/lib/llvm.l" llvm pico)
llvm~-ZERO (53 "@src/lib/llvm.l" llvm pico)
llvm~/ (973 "@src/lib/llvm.l" llvm pico)
llvm~292MY (8 "@src/defs.l" llvm pico)
llvm~: (1453 "@src/lib/llvm.l" llvm pico)
llvm~< (868 "@src/lib/llvm.l" llvm pico)
llvm~<= (868 "@src/lib/llvm.l" llvm pico)
llvm~<> (858 "@src/lib/llvm.l" llvm pico)
llvm~=0 (881 "@src/lib/llvm.l" llvm pico)
llvm~== (858 "@src/lib/llvm.l" llvm pico)
llvm~> (868 "@src/lib/llvm.l" llvm pico)
llvm~>= (868 "@src/lib/llvm.l" llvm pico)
llvm~? (1379 "@src/lib/llvm.l" llvm pico)
llvm~BEG (20 "@src/defs.l" llvm pico)
llvm~BLK (33 "@src/defs.l" llvm pico)
llvm~BLKMASK (33 "@src/defs.l" llvm pico)
llvm~BLKSIZE (33 "@src/defs.l" llvm pico)
llvm~BLKTAG (33 "@src/defs.l" llvm pico)
llvm~BUFSIZ (8 "@src/defs.l" llvm pico)
llvm~CELLS (8 "@src/defs.l" llvm pico)
llvm~DB1 (8 "@src/defs.l" llvm pico)
llvm~DOT (20 "@src/defs.l" llvm pico)
llvm~EACCES (63 "@src/defs.l" llvm pico)
llvm~EAGAIN (63 "@src/defs.l" llvm pico)
llvm~EBADF (63 "@src/defs.l" llvm pico)
llvm~ECONNRESET (63 "@src/defs.l" llvm pico)
llvm~EINTR (63 "@src/defs.l" llvm pico)
llvm~END (20 "@src/defs.l" llvm pico)
llvm~ENOENT (63 "@src/defs.l" llvm pico)
llvm~EPIPE (63 "@src/defs.l" llvm pico)
llvm~EXTERN (20 "@src/defs.l" llvm pico)
llvm~HEAP (8 "@src/defs.l" llvm pico)
llvm~INTERN (20 "@src/defs.l" llvm pico)
llvm~NIX (20 "@src/defs.l" llvm pico)
llvm~NO (50 "@src/lib/llvm.l" llvm pico)
llvm~NUMBER (20 "@src/defs.l" llvm pico)
llvm~ONE (54 "@src/lib/llvm.l" llvm pico)
llvm~SIGALRM (43 "@src/defs.l" llvm pico)
llvm~SIGCHLD (43 "@src/defs.l" llvm pico)
llvm~SIGCONT (43 "@src/defs.l" llvm pico)
llvm~SIGHUP (43 "@src/defs.l" llvm pico)
llvm~SIGINT (43 "@src/defs.l" llvm pico)
llvm~SIGIO (43 "@src/defs.l" llvm pico)
llvm~SIGPIPE (43 "@src/defs.l" llvm pico)
llvm~SIGSTOP (43 "@src/defs.l" llvm pico)
llvm~SIGTERM (43 "@src/defs.l" llvm pico)
llvm~SIGTSTP (43 "@src/defs.l" llvm pico)
llvm~SIGTTIN (43 "@src/defs.l" llvm pico)
llvm~SIGTTOU (43 "@src/defs.l" llvm pico)
llvm~SIGUSR1 (43 "@src/defs.l" llvm pico)
llvm~SIGUSR2 (43 "@src/defs.l" llvm pico)
llvm~SIGWINCH (43 "@src/defs.l" llvm pico)
llvm~STACK (8 "@src/defs.l" llvm pico)
llvm~TOP (8 "@src/defs.l" llvm pico)
llvm~TRANSIENT (20 "@src/defs.l" llvm pico)
llvm~YES (51 "@src/lib/llvm.l" llvm pico)
llvm~ZERO (52 "@src/lib/llvm.l" llvm pico)
llvm~_Abs (1370 "@src/big.l" llvm pico)
llvm~_Add (1124 "@src/big.l" llvm pico)
llvm~_Adr (1673 "@src/main.l" llvm pico)
llvm~_Alarm (514 "@src/main.l" llvm pico)
llvm~_All (609 "@src/sym.l" llvm pico)
llvm~_And (496 "@src/flow.l" llvm pico)
llvm~_Any (2751 "@src/io.l" llvm pico)
llvm~_Append (375 "@src/subr.l" llvm pico)
llvm~_Apply (6 "@src/apply.l" llvm pico)
llvm~_Arg (1653 "@src/main.l" llvm pico)
llvm~_Args (1643 "@src/main.l" llvm pico)
llvm~_Argv (1197 "@src/main.l" llvm pico)
llvm~_Arrow (1598 "@src/subr.l" llvm pico)
llvm~_As (62 "@src/flow.l" llvm pico)
llvm~_Asoq (1164 "@src/subr.l" llvm pico)
llvm~_Assoc (1138 "@src/subr.l" llvm pico)
llvm~_At (708 "@src/flow.l" llvm pico)
llvm~_Atom (822 "@src/subr.l" llvm pico)
llvm~_Bind (880 "@src/flow.l" llvm pico)
llvm~_BitAnd (1401 "@src/big.l" llvm pico)
llvm~_BitOr (1414 "@src/big.l" llvm pico)
llvm~_BitQ (1377 "@src/big.l" llvm pico)
llvm~_BitXor (1427 "@src/big.l" llvm pico)
llvm~_Blk (676 "@src/db.l" llvm pico)
llvm~_Bool (540 "@src/flow.l" llvm pico)
llvm~_Box (316 "@src/flow.l" llvm pico)
llvm~_BoxQ (713 "@src/sym.l" llvm pico)
llvm~_Break (1530 "@src/flow.l" llvm pico)
llvm~_Buf (1043 "@src/flow.l" llvm pico)
llvm~_By (658 "@src/apply.l" llvm pico)
llvm~_Bye (1736 "@src/flow.l" llvm pico)
llvm~_Byte (1680 "@src/main.l" llvm pico)
llvm~_Bytes (1134 "@src/subr.l" llvm pico)
llvm~_Caaaar (60 "@src/subr.l" llvm pico)
llvm~_Caaadr (63 "@src/subr.l" llvm pico)
llvm~_Caaar (36 "@src/subr.l" llvm pico)
llvm~_Caadar (66 "@src/subr.l" llvm pico)
llvm~_Caaddr (69 "@src/subr.l" llvm pico)
llvm~_Caadr (39 "@src/subr.l" llvm pico)
llvm~_Caar (24 "@src/subr.l" llvm pico)
llvm~_Cadaar (72 "@src/subr.l" llvm pico)
llvm~_Cadadr (75 "@src/subr.l" llvm pico)
llvm~_Cadar (42 "@src/subr.l" llvm pico)
llvm~_Caddar (78 "@src/subr.l" llvm pico)
llvm~_Cadddr (81 "@src/subr.l" llvm pico)
llvm~_Caddr (45 "@src/subr.l" llvm pico)
llvm~_Cadr (27 "@src/subr.l" llvm pico)
llvm~_Call (1639 "@src/flow.l" llvm pico)
llvm~_Car (17 "@src/subr.l" llvm pico)
llvm~_Case (654 "@src/flow.l" llvm pico)
llvm~_Casq (666 "@src/flow.l" llvm pico)
llvm~_Catch (1089 "@src/flow.l" llvm pico)
llvm~_Cb1 (1553 "@src/main.l" llvm pico)
llvm~_Cb10 (1580 "@src/main.l" llvm pico)
llvm~_Cb11 (1583 "@src/main.l" llvm pico)
llvm~_Cb12 (1586 "@src/main.l" llvm pico)
llvm~_Cb13 (1589 "@src/main.l" llvm pico)
llvm~_Cb14 (1592 "@src/main.l" llvm pico)
llvm~_Cb15 (1595 "@src/main.l" llvm pico)
llvm~_Cb16 (1598 "@src/main.l" llvm pico)
llvm~_Cb17 (1601 "@src/main.l" llvm pico)
llvm~_Cb18 (1604 "@src/main.l" llvm pico)
llvm~_Cb19 (1607 "@src/main.l" llvm pico)
llvm~_Cb2 (1556 "@src/main.l" llvm pico)
llvm~_Cb20 (1610 "@src/main.l" llvm pico)
llvm~_Cb21 (1613 "@src/main.l" llvm pico)
llvm~_Cb22 (1616 "@src/main.l" llvm pico)
llvm~_Cb23 (1619 "@src/main.l" llvm pico)
llvm~_Cb24 (1622 "@src/main.l" llvm pico)
llvm~_Cb3 (1559 "@src/main.l" llvm pico)
llvm~_Cb4 (1562 "@src/main.l" llvm pico)
llvm~_Cb5 (1565 "@src/main.l" llvm pico)
llvm~_Cb6 (1568 "@src/main.l" llvm pico)
llvm~_Cb7 (1571 "@src/main.l" llvm pico)
llvm~_Cb8 (1574 "@src/main.l" llvm pico)
llvm~_Cb9 (1577 "@src/main.l" llvm pico)
llvm~_Cd (1061 "@src/main.l" llvm pico)
llvm~_Cdaaar (84 "@src/subr.l" llvm pico)
llvm~_Cdaadr (87 "@src/subr.l" llvm pico)
llvm~_Cdaar (48 "@src/subr.l" llvm pico)
llvm~_Cdadar (90 "@src/subr.l" llvm pico)
llvm~_Cdaddr (93 "@src/subr.l" llvm pico)
llvm~_Cdadr (51 "@src/subr.l" llvm pico)
llvm~_Cdar (30 "@src/subr.l" llvm pico)
llvm~_Cddaar (96 "@src/subr.l" llvm pico)
llvm~_Cddadr (99 "@src/subr.l" llvm pico)
llvm~_Cddar (54 "@src/subr.l" llvm pico)
llvm~_Cdddar (102 "@src/subr.l" llvm pico)
llvm~_Cddddr (105 "@src/subr.l" llvm pico)
llvm~_Cdddr (57 "@src/subr.l" llvm pico)
llvm~_Cddr (33 "@src/subr.l" llvm pico)
llvm~_Cdr (21 "@src/subr.l" llvm pico)
llvm~_Chain (291 "@src/subr.l" llvm pico)
llvm~_Char (1758 "@src/io.l" llvm pico)
llvm~_Chop (743 "@src/sym.l" llvm pico)
llvm~_Circ (155 "@src/subr.l" llvm pico)
llvm~_CircQ (830 "@src/subr.l" llvm pico)
llvm~_Clip (614 "@src/subr.l" llvm pico)
llvm~_Close (2215 "@src/io.l" llvm pico)
llvm~_Cmd (1130 "@src/main.l" llvm pico)
llvm~_Cnt (481 "@src/apply.l" llvm pico)
llvm~_Co (1222 "@src/flow.l" llvm pico)
llvm~_Col (1710 "@src/sym.l" llvm pico)
llvm~_Commit (886 "@src/db.l" llvm pico)
llvm~_Con (121 "@src/subr.l" llvm pico)
llvm~_Conc (140 "@src/subr.l" llvm pico)
llvm~_Cond (634 "@src/flow.l" llvm pico)
llvm~_Cons (128 "@src/subr.l" llvm pico)
llvm~_Copy (334 "@src/subr.l" llvm pico)
llvm~_Ctl (1987 "@src/io.l" llvm pico)
llvm~_Ctty (1075 "@src/main.l" llvm pico)
llvm~_Cut (1018 "@src/sym.l" llvm pico)
llvm~_Date (636 "@src/main.l" llvm pico)
llvm~_Dbck (1198 "@src/db.l" llvm pico)
llvm~_De (154 "@src/flow.l" llvm pico)
llvm~_Dec (1175 "@src/big.l" llvm pico)
llvm~_Def (123 "@src/flow.l" llvm pico)
llvm~_Default (946 "@src/sym.l" llvm pico)
llvm~_Del (1037 "@src/sym.l" llvm pico)
llvm~_Delete (395 "@src/subr.l" llvm pico)
llvm~_Delq (416 "@src/subr.l" llvm pico)
llvm~_Detach (1718 "@src/flow.l" llvm pico)
llvm~_Diff (916 "@src/subr.l" llvm pico)
llvm~_Dir (1137 "@src/main.l" llvm pico)
llvm~_Div (1244 "@src/big.l" llvm pico)
llvm~_Dm (162 "@src/flow.l" llvm pico)
llvm~_Do (763 "@src/flow.l" llvm pico)
llvm~_E (1537 "@src/flow.l" llvm pico)
llvm~_Echo (2228 "@src/io.l" llvm pico)
llvm~_Enum (1144 "@src/sym.l" llvm pico)
llvm~_EnumQ (1241 "@src/sym.l" llvm pico)
llvm~_Env (1698 "@src/main.l" llvm pico)
llvm~_Eof (1790 "@src/io.l" llvm pico)
llvm~_Eol (1783 "@src/io.l" llvm pico)
llvm~_Eq (720 "@src/subr.l" llvm pico)
llvm~_Eq0 (748 "@src/subr.l" llvm pico)
llvm~_Eq1 (752 "@src/subr.l" llvm pico)
llvm~_EqT (756 "@src/subr.l" llvm pico)
llvm~_Equal (734 "@src/subr.l" llvm pico)
llvm~_Err (1979 "@src/io.l" llvm pico)
llvm~_Errno (1244 "@src/main.l" llvm pico)
llvm~_Eval (81 "@src/flow.l" llvm pico)
llvm~_Exec (1620 "@src/flow.l" llvm pico)
llvm~_Ext (2587 "@src/io.l" llvm pico)
llvm~_ExtQ (246 "@src/db.l" llvm pico)
llvm~_Extern (348 "@src/db.l" llvm pico)
llvm~_Extra (485 "@src/flow.l" llvm pico)
llvm~_Extract (325 "@src/apply.l" llvm pico)
llvm~_Fd (2035 "@src/io.l" llvm pico)
llvm~_Fifo (1080 "@src/sym.l" llvm pico)
llvm~_File (1183 "@src/main.l" llvm pico)
llvm~_Fill (1297 "@src/subr.l" llvm pico)
llvm~_Filter (287 "@src/apply.l" llvm pico)
llvm~_Fin (704 "@src/subr.l" llvm pico)
llvm~_Finally (1124 "@src/flow.l" llvm pico)
llvm~_Find (386 "@src/apply.l" llvm pico)
llvm~_Fish (636 "@src/apply.l" llvm pico)
llvm~_FlgQ (850 "@src/subr.l" llvm pico)
llvm~_Flip (571 "@src/subr.l" llvm pico)
llvm~_Flush (2571 "@src/io.l" llvm pico)
llvm~_Fold (1887 "@src/sym.l" llvm pico)
llvm~_For (784 "@src/flow.l" llvm pico)
llvm~_Fork (1712 "@src/flow.l" llvm pico)
llvm~_Format (1088 "@src/big.l" llvm pico)
llvm~_Free (1170 "@src/db.l" llvm pico)
llvm~_From (1801 "@src/io.l" llvm pico)
llvm~_Full (252 "@src/subr.l" llvm pico)
llvm~_Fully (450 "@src/apply.l" llvm pico)
llvm~_Fun (45 "@src/apply.l" llvm pico)
llvm~_FunQ (548 "@src/sym.l" llvm pico)
llvm~_Gc (272 "@src/gc.l" llvm pico)
llvm~_Ge (795 "@src/subr.l" llvm pico)
llvm~_Ge0 (1351 "@src/big.l" llvm pico)
llvm~_Get (1649 "@src/sym.l" llvm pico)
llvm~_Getd (554 "@src/sym.l" llvm pico)
llvm~_Getl (1761 "@src/sym.l" llvm pico)
llvm~_Glue (772 "@src/sym.l" llvm pico)
llvm~_Group (1631 "@src/subr.l" llvm pico)
llvm~_Gt (786 "@src/subr.l" llvm pico)
llvm~_Gt0 (1360 "@src/big.l" llvm pico)
llvm~_Hash (1521 "@src/big.l" llvm pico)
llvm~_Head (621 "@src/subr.l" llvm pico)
llvm~_Heap (548 "@src/main.l" llvm pico)
llvm~_Hear (995 "@src/io.l" llvm pico)
llvm~_Hide (709 "@src/sym.l" llvm pico)
llvm~_History (1790 "@src/main.l" llvm pico)
llvm~_Id (655 "@src/db.l" llvm pico)
llvm~_Idx (1376 "@src/sym.l" llvm pico)
llvm~_If (580 "@src/flow.l" llvm pico)
llvm~_If2 (596 "@src/flow.l" llvm pico)
llvm~_IfAt2 (610 "@src/flow.l" llvm pico)
llvm~_Ifn (588 "@src/flow.l" llvm pico)
llvm~_In (1963 "@src/io.l" llvm pico)
llvm~_Inc (1154 "@src/big.l" llvm pico)
llvm~_Index (934 "@src/subr.l" llvm pico)
llvm~_Info (1156 "@src/main.l" llvm pico)
llvm~_Input (2019 "@src/io.l" llvm pico)
llvm~_Insert (462 "@src/subr.l" llvm pico)
llvm~_Intern (688 "@src/sym.l" llvm pico)
llvm~_Ipid (1686 "@src/flow.l" llvm pico)
llvm~_Isa (389 "@src/flow.l" llvm pico)
llvm~_Job (914 "@src/flow.l" llvm pico)
llvm~_Journal (606 "@src/db.l" llvm pico)
llvm~_Key (1709 "@src/io.l" llvm pico)
llvm~_Kids (528 "@src/main.l" llvm pico)
llvm~_Kill (1700 "@src/flow.l" llvm pico)
llvm~_Last (711 "@src/subr.l" llvm pico)
llvm~_Le (777 "@src/subr.l" llvm pico)
llvm~_Le0 (1342 "@src/big.l" llvm pico)
llvm~_Length (974 "@src/subr.l" llvm pico)
llvm~_Let (952 "@src/flow.l" llvm pico)
llvm~_LetQ (1011 "@src/flow.l" llvm pico)
llvm~_Lieu (756 "@src/db.l" llvm pico)
llvm~_Line (1892 "@src/io.l" llvm pico)
llvm~_Link (305 "@src/subr.l" llvm pico)
llvm~_Lisp (1626 "@src/main.l" llvm pico)
llvm~_List (187 "@src/subr.l" llvm pico)
llvm~_Lit (69 "@src/flow.l" llvm pico)
llvm~_Load (2897 "@src/io.l" llvm pico)
llvm~_Lock (773 "@src/db.l" llvm pico)
llvm~_Loop (778 "@src/flow.l" llvm pico)
llvm~_LowQ (1840 "@src/sym.l" llvm pico)
llvm~_Lowc (1854 "@src/sym.l" llvm pico)
llvm~_LstQ (834 "@src/subr.l" llvm pico)
llvm~_Lt (768 "@src/subr.l" llvm pico)
llvm~_Lt0 (1336 "@src/big.l" llvm pico)
llvm~_Lup (1391 "@src/sym.l" llvm pico)
llvm~_Made (275 "@src/subr.l" llvm pico)
llvm~_Make (260 "@src/subr.l" llvm pico)
llvm~_Map (94 "@src/apply.l" llvm pico)
llvm~_Mapc (117 "@src/apply.l" llvm pico)
llvm~_Mapcan (246 "@src/apply.l" llvm pico)
llvm~_Mapcar (177 "@src/apply.l" llvm pico)
llvm~_Mapcon (214 "@src/apply.l" llvm pico)
llvm~_Maplist (149 "@src/apply.l" llvm pico)
llvm~_Maps (49 "@src/apply.l" llvm pico)
llvm~_Mark (1122 "@src/db.l" llvm pico)
llvm~_Match (1236 "@src/subr.l" llvm pico)
llvm~_Max (804 "@src/subr.l" llvm pico)
llvm~_Maxi (548 "@src/apply.l" llvm pico)
llvm~_Member (856 "@src/subr.l" llvm pico)
llvm~_Memq (869 "@src/subr.l" llvm pico)
llvm~_Meta (1825 "@src/sym.l" llvm pico)
llvm~_Method (407 "@src/flow.l" llvm pico)
llvm~_Min (813 "@src/subr.l" llvm pico)
llvm~_Mini (585 "@src/apply.l" llvm pico)
llvm~_Mix (349 "@src/subr.l" llvm pico)
llvm~_Mmeq (882 "@src/subr.l" llvm pico)
llvm~_Mul (1195 "@src/big.l" llvm pico)
llvm~_MulDiv (1216 "@src/big.l" llvm pico)
llvm~_Name (510 "@src/sym.l" llvm pico)
llvm~_Nand (514 "@src/flow.l" llvm pico)
llvm~_Nat (1474 "@src/main.l" llvm pico)
llvm~_Native (1487 "@src/main.l" llvm pico)
llvm~_Need (199 "@src/subr.l" llvm pico)
llvm~_Neq (727 "@src/subr.l" llvm pico)
llvm~_Neq0 (760 "@src/subr.l" llvm pico)
llvm~_NeqT (764 "@src/subr.l" llvm pico)
llvm~_Nequal (741 "@src/subr.l" llvm pico)
llvm~_New (320 "@src/flow.l" llvm pico)
llvm~_Next (1647 "@src/main.l" llvm pico)
llvm~_Nil (551 "@src/flow.l" llvm pico)
llvm~_Nond (644 "@src/flow.l" llvm pico)
llvm~_Nor (523 "@src/flow.l" llvm pico)
llvm~_Not (544 "@src/flow.l" llvm pico)
llvm~_Nsp (520 "@src/sym.l" llvm pico)
llvm~_Nth (109 "@src/subr.l" llvm pico)
llvm~_NumQ (840 "@src/subr.l" llvm pico)
llvm~_Off (915 "@src/sym.l" llvm pico)
llvm~_Offset (948 "@src/subr.l" llvm pico)
llvm~_On (908 "@src/sym.l" llvm pico)
llvm~_OnOff (922 "@src/sym.l" llvm pico)
llvm~_One (939 "@src/sym.l" llvm pico)
llvm~_Open (2199 "@src/io.l" llvm pico)
llvm~_Opid (1693 "@src/flow.l" llvm pico)
llvm~_Opt (1231 "@src/main.l" llvm pico)
llvm~_Or (505 "@src/flow.l" llvm pico)
llvm~_Out (1971 "@src/io.l" llvm pico)
llvm~_Output (2027 "@src/io.l" llvm pico)
llvm~_Pack (761 "@src/sym.l" llvm pico)
llvm~_Pair (826 "@src/subr.l" llvm pico)
llvm~_Pass (25 "@src/apply.l" llvm pico)
llvm~_PatQ (541 "@src/sym.l" llvm pico)
llvm~_Path (738 "@src/io.l" llvm pico)
llvm~_Peek (1750 "@src/io.l" llvm pico)
llvm~_Pick (419 "@src/apply.l" llvm pico)
llvm~_Pipe (2155 "@src/io.l" llvm pico)
llvm~_Place (496 "@src/subr.l" llvm pico)
llvm~_Plio (2609 "@src/io.l" llvm pico)
llvm~_Poll (1039 "@src/io.l" llvm pico)
llvm~_Pool (455 "@src/db.l" llvm pico)
llvm~_Pool2 (565 "@src/db.l" llvm pico)
llvm~_Pop (993 "@src/sym.l" llvm pico)
llvm~_Popq (1003 "@src/sym.l" llvm pico)
llvm~_Pr (2674 "@src/io.l" llvm pico)
llvm~_PreQ (836 "@src/sym.l" llvm pico)
llvm~_Prin (2531 "@src/io.l" llvm pico)
llvm~_Prinl (2539 "@src/io.l" llvm pico)
llvm~_Print (2554 "@src/io.l" llvm pico)
llvm~_Println (2567 "@src/io.l" llvm pico)
llvm~_Printsp (2563 "@src/io.l" llvm pico)
llvm~_Prior (961 "@src/subr.l" llvm pico)
llvm~_Prog (561 "@src/flow.l" llvm pico)
llvm~_Prog1 (565 "@src/flow.l" llvm pico)
llvm~_Prog2 (572 "@src/flow.l" llvm pico)
llvm~_Prompt (497 "@src/main.l" llvm pico)
llvm~_Prop (1660 "@src/sym.l" llvm pico)
llvm~_PropCol (1717 "@src/sym.l" llvm pico)
llvm~_Protect (540 "@src/main.l" llvm pico)
llvm~_Prove (1465 "@src/subr.l" llvm pico)
llvm~_Push (955 "@src/sym.l" llvm pico)
llvm~_Push1 (967 "@src/sym.l" llvm pico)
llvm~_Push1q (980 "@src/sym.l" llvm pico)
llvm~_Put (1624 "@src/sym.l" llvm pico)
llvm~_Putl (1731 "@src/sym.l" llvm pico)
llvm~_Pwd (1054 "@src/main.l" llvm pico)
llvm~_Queue (1062 "@src/sym.l" llvm pico)
llvm~_Quit (1025 "@src/main.l" llvm pico)
llvm~_Quote (58 "@src/flow.l" llvm pico)
llvm~_Rand (1531 "@src/big.l" llvm pico)
llvm~_Range (231 "@src/subr.l" llvm pico)
llvm~_Rank (1190 "@src/subr.l" llvm pico)
llvm~_Rasoq (1177 "@src/subr.l" llvm pico)
llvm~_Rassoc (1151 "@src/subr.l" llvm pico)
llvm~_Raw (505 "@src/main.l" llvm pico)
llvm~_Rd (2635 "@src/io.l" llvm pico)
llvm~_Read (1694 "@src/io.l" llvm pico)
llvm~_Rem (1266 "@src/big.l" llvm pico)
llvm~_Remove (477 "@src/subr.l" llvm pico)
llvm~_Replace (437 "@src/subr.l" llvm pico)
llvm~_Rest (1662 "@src/main.l" llvm pico)
llvm~_Rev (1322 "@src/big.l" llvm pico)
llvm~_Reverse (561 "@src/subr.l" llvm pico)
llvm~_Rewind (2575 "@src/io.l" llvm pico)
llvm~_Rid (1111 "@src/sym.l" llvm pico)
llvm~_Rollback (299 "@src/db.l" llvm pico)
llvm~_Rot (166 "@src/subr.l" llvm pico)
llvm~_Rt (725 "@src/main.l" llvm pico)
llvm~_Run (99 "@src/flow.l" llvm pico)
llvm~_Sect (898 "@src/subr.l" llvm pico)
llvm~_Seed (1515 "@src/big.l" llvm pico)
llvm~_Seek (363 "@src/apply.l" llvm pico)
llvm~_Semicol (1678 "@src/sym.l" llvm pico)
llvm~_Send (417 "@src/flow.l" llvm pico)
llvm~_Seq (725 "@src/db.l" llvm pico)
llvm~_Set (864 "@src/sym.l" llvm pico)
llvm~_SetCol (1689 "@src/sym.l" llvm pico)
llvm~_Setq (876 "@src/sym.l" llvm pico)
llvm~_Shift (1011 "@src/sym.l" llvm pico)
llvm~_Shr (1288 "@src/big.l" llvm pico)
llvm~_Sigio (521 "@src/main.l" llvm pico)
llvm~_Size (1077 "@src/subr.l" llvm pico)
llvm~_Skip (1777 "@src/io.l" llvm pico)
llvm~_Sort (1667 "@src/subr.l" llvm pico)
llvm~_SpQ (535 "@src/sym.l" llvm pico)
llvm~_Space (2543 "@src/io.l" llvm pico)
llvm~_Split (524 "@src/subr.l" llvm pico)
llvm~_Sqrt (1440 "@src/big.l" llvm pico)
llvm~_Stack (561 "@src/main.l" llvm pico)
llvm~_State (675 "@src/flow.l" llvm pico)
llvm~_Stem (684 "@src/subr.l" llvm pico)
llvm~_Str (2765 "@src/io.l" llvm pico)
llvm~_StrQ (724 "@src/sym.l" llvm pico)
llvm~_Strip (516 "@src/subr.l" llvm pico)
llvm~_Struct (1514 "@src/main.l" llvm pico)
llvm~_Sub (1137 "@src/big.l" llvm pico)
llvm~_SubQ (850 "@src/sym.l" llvm pico)
llvm~_Sum (514 "@src/apply.l" llvm pico)
llvm~_Super (447 "@src/flow.l" llvm pico)
llvm~_Swap (883 "@src/sym.l" llvm pico)
llvm~_Sym (2757 "@src/io.l" llvm pico)
llvm~_SymQ (844 "@src/subr.l" llvm pico)
llvm~_Symbols (643 "@src/sym.l" llvm pico)
llvm~_Sync (973 "@src/io.l" llvm pico)
llvm~_Sys (1038 "@src/main.l" llvm pico)
llvm~_T (556 "@src/flow.l" llvm pico)
llvm~_Tail (654 "@src/subr.l" llvm pico)
llvm~_Tc (1079 "@src/flow.l" llvm pico)
llvm~_Tco (1056 "@src/flow.l" llvm pico)
llvm~_Tell (1014 "@src/io.l" llvm pico)
llvm~_Text (785 "@src/sym.l" llvm pico)
llvm~_Throw (1108 "@src/flow.l" llvm pico)
llvm~_Till (1846 "@src/io.l" llvm pico)
llvm~_Time (688 "@src/main.l" llvm pico)
llvm~_Touch (869 "@src/db.l" llvm pico)
llvm~_Trace (1580 "@src/flow.l" llvm pico)
llvm~_Trail (1733 "@src/main.l" llvm pico)
llvm~_Trim (610 "@src/subr.l" llvm pico)
llvm~_Try (430 "@src/flow.l" llvm pico)
llvm~_Tty (485 "@src/main.l" llvm pico)
llvm~_Type (354 "@src/flow.l" llvm pico)
llvm~_Unify (1608 "@src/subr.l" llvm pico)
llvm~_Unless (626 "@src/flow.l" llvm pico)
llvm~_Until (700 "@src/flow.l" llvm pico)
llvm~_Up (1755 "@src/main.l" llvm pico)
llvm~_UppQ (1847 "@src/sym.l" llvm pico)
llvm~_Uppc (1869 "@src/sym.l" llvm pico)
llvm~_Use (1023 "@src/flow.l" llvm pico)
llvm~_Usec (718 "@src/main.l" llvm pico)
llvm~_Val (857 "@src/sym.l" llvm pico)
llvm~_Version (1813 "@src/main.l" llvm pico)
llvm~_Wait (955 "@src/io.l" llvm pico)
llvm~_When (618 "@src/flow.l" llvm pico)
llvm~_While (692 "@src/flow.l" llvm pico)
llvm~_Wipe (1797 "@src/sym.l" llvm pico)
llvm~_With (869 "@src/flow.l" llvm pico)
llvm~_Wr (2683 "@src/io.l" llvm pico)
llvm~_Xchg (894 "@src/sym.l" llvm pico)
llvm~_Xor (533 "@src/flow.l" llvm pico)
llvm~_Yield (1337 "@src/flow.l" llvm pico)
llvm~_Yoke (318 "@src/subr.l" llvm pico)
llvm~_Zap (735 "@src/sym.l" llvm pico)
llvm~_Zero (932 "@src/sym.l" llvm pico)
llvm~__Meth (306 "@src/flow.l" llvm pico)
llvm~_getStdin (1251 "@src/io.l" llvm pico)
llvm~_putStdout (2334 "@src/io.l" llvm pico)
llvm~add (932 "@src/lib/llvm.l" llvm pico)
llvm~adds (819 "@src/big.l" llvm pico)
llvm~addu (415 "@src/big.l" llvm pico)
llvm~alloc (148 "@src/main.l" llvm pico)
llvm~and (1252 "@src/lib/llvm.l" llvm pico)
llvm~andu (306 "@src/big.l" llvm pico)
llvm~anonymous (1407 "@src/io.l" llvm pico)
llvm~any (777 "@src/lib/llvm.l" llvm pico)
llvm~argErr (337 "@src/main.l" llvm pico)
llvm~array (371 "@src/lib/llvm.l" llvm pico)
llvm~asm (121 "@src/lib/llvm.l" llvm pico)
llvm~atom (820 "@src/lib/llvm.l" llvm pico)
llvm~atomErr (355 "@src/main.l" llvm pico)
llvm~b32 (1199 "@src/lib/llvm.l" llvm pico)
llvm~b64 (1199 "@src/lib/llvm.l" llvm pico)
llvm~b8 (1199 "@src/lib/llvm.l" llvm pico)
llvm~b8* (1199 "@src/lib/llvm.l" llvm pico)
llvm~b8+ (1199 "@src/lib/llvm.l" llvm pico)
llvm~badFd (29 "@src/io.l" llvm pico)
llvm~badInput (23 "@src/io.l" llvm pico)
llvm~begString (2732 "@src/io.l" llvm pico)
llvm~begin (57 "@src/lib/llvm.l" llvm pico)
llvm~big (802 "@src/lib/llvm.l" llvm pico)
llvm~big? (820 "@src/lib/llvm.l" llvm pico)
llvm~binPrint (382 "@src/io.l" llvm pico)
llvm~binRead (276 "@src/io.l" llvm pico)
llvm~binSize (1028 "@src/subr.l" llvm pico)
llvm~blkPeek (120 "@src/db.l" llvm pico)
llvm~blkPoke (137 "@src/db.l" llvm pico)
llvm~box (393 "@src/gc.l" llvm pico)
llvm~box64 (437 "@src/dec.l" llvm pico)
llvm~boxNum (372 "@src/gc.l" llvm pico)
llvm~br (158 "@src/lib/llvm.l" llvm pico)
llvm~brkLoad (1501 "@src/flow.l" llvm pico)
llvm~bufAo (2384 "@src/io.l" llvm pico)
llvm~bufSize (7 "@src/sym.l" llvm pico)
llvm~bufString (38 "@src/sym.l" llvm pico)
llvm~bye (131 "@src/main.l" llvm pico)
llvm~byteNum (58 "@src/big.l" llvm pico)
llvm~byteSym (97 "@src/big.l" llvm pico)
llvm~caFrame (57 "@src/dec.l" llvm pico)
llvm~caar (377 "@src/dec.l" llvm pico)
llvm~cadr (380 "@src/dec.l" llvm pico)
llvm~call (1433 "@src/lib/llvm.l" llvm pico)
llvm~car (1057 "@src/lib/llvm.l" llvm pico)
llvm~case (1345 "@src/lib/llvm.l" llvm pico)
llvm~cbFuns (611 "@src/glob.l" llvm pico)
llvm~cbl (1534 "@src/main.l" llvm pico)
llvm~cdar (383 "@src/dec.l" llvm pico)
llvm~cddr (386 "@src/dec.l" llvm pico)
llvm~cdr (1064 "@src/lib/llvm.l" llvm pico)
llvm~charErr (349 "@src/main.l" llvm pico)
llvm~charSym (122 "@src/big.l" llvm pico)
llvm~child (99 "@src/dec.l" llvm pico)
llvm~chkA (7 "@src/subr.l" llvm pico)
llvm~chkD (10 "@src/subr.l" llvm pico)
llvm~chkVar (508 "@src/dec.l" llvm pico)
llvm~chopExtNm (212 "@src/sym.l" llvm pico)
llvm~circ (424 "@src/main.l" llvm pico)
llvm~cleanUp (256 "@src/db.l" llvm pico)
llvm~closeErr (11 "@src/io.l" llvm pico)
llvm~closeInFile (105 "@src/io.l" llvm pico)
llvm~closeOnExec (40 "@src/io.l" llvm pico)
llvm~closeOutFile (114 "@src/io.l" llvm pico)
llvm~clsChild (202 "@src/io.l" llvm pico)
llvm~cmpLong (244 "@src/sym.l" llvm pico)
llvm~cmpNum (889 "@src/big.l" llvm pico)
llvm~cmpSort (1662 "@src/subr.l" llvm pico)
llvm~cmpu (843 "@src/big.l" llvm pico)
llvm~cnt (392 "@src/dec.l" llvm pico)
llvm~cnt? (820 "@src/lib/llvm.l" llvm pico)
llvm~cntErr (340 "@src/main.l" llvm pico)
llvm~coErr (1143 "@src/flow.l" llvm pico)
llvm~comment (1329 "@src/io.l" llvm pico)
llvm~compare (844 "@src/main.l" llvm pico)
llvm~cond (1314 "@src/lib/llvm.l" llvm pico)
llvm~cons (287 "@src/gc.l" llvm pico)
llvm~cons2 (298 "@src/gc.l" llvm pico)
llvm~cons3 (320 "@src/gc.l" llvm pico)
llvm~consExt (368 "@src/gc.l" llvm pico)
llvm~consNum (382 "@src/gc.l" llvm pico)
llvm~consStr (363 "@src/gc.l" llvm pico)
llvm~consSym (348 "@src/gc.l" llvm pico)
llvm~consTree (566 "@src/sym.l" llvm pico)
llvm~const (348 "@src/lib/llvm.l" llvm pico)
llvm~coroutine (73 "@src/dec.l" llvm pico)
llvm~ctFrame (38 "@src/dec.l" llvm pico)
llvm~ctOpen (1212 "@src/io.l" llvm pico)
llvm~currFd (561 "@src/io.l" llvm pico)
llvm~db (793 "@src/db.l" llvm pico)
llvm~dbFetch (844 "@src/db.l" llvm pico)
llvm~dbFile (42 "@src/dec.l" llvm pico)
llvm~dbRdErr (10 "@src/db.l" llvm pico)
llvm~dbSyncErr (19 "@src/db.l" llvm pico)
llvm~dbTouch (854 "@src/db.l" llvm pico)
llvm~dbWrErr (13 "@src/db.l" llvm pico)
llvm~dbZap (875 "@src/db.l" llvm pico)
llvm~dbfBuf (57 "@src/db.l" llvm pico)
llvm~dbfErr (7 "@src/db.l" llvm pico)
llvm~dbg (24 "@src/main.l" llvm pico)
llvm~de (680 "@src/lib/llvm.l" llvm pico)
llvm~dec (951 "@src/lib/llvm.l" llvm pico)
llvm~decs (813 "@src/big.l" llvm pico)
llvm~define (545 "@src/lib/llvm.l" llvm pico)
llvm~delNode (460 "@src/sym.l" llvm pico)
llvm~dig (802 "@src/lib/llvm.l" llvm pico)
llvm~dirString (768 "@src/main.l" llvm pico)
llvm~div (1001 "@src/lib/llvm.l" llvm pico)
llvm~div1 (668 "@src/big.l" llvm pico)
llvm~divErr (15 "@src/big.l" llvm pico)
llvm~divu (790 "@src/big.l" llvm pico)
llvm~drop (1489 "@src/lib/llvm.l" llvm pico)
llvm~end (90 "@src/lib/llvm.l" llvm pico)
llvm~endString (2742 "@src/io.l" llvm pico)
llvm~env (640 "@src/glob.l" llvm pico)
llvm~eofErr (20 "@src/io.l" llvm pico)
llvm~eol (1879 "@src/io.l" llvm pico)
llvm~equ (299 "@src/lib/llvm.l" llvm pico)
llvm~equal (786 "@src/main.l" llvm pico)
llvm~equalBig (775 "@src/main.l" llvm pico)
llvm~erOpen (1190 "@src/io.l" llvm pico)
llvm~err (257 "@src/main.l" llvm pico)
llvm~evBool (692 "@src/lib/llvm.l" llvm pico)
llvm~evCnt (389 "@src/main.l" llvm pico)
llvm~evExpr (922 "@src/main.l" llvm pico)
llvm~evList (993 "@src/main.l" llvm pico)
llvm~evLst (392 "@src/main.l" llvm pico)
llvm~evMethod (211 "@src/flow.l" llvm pico)
llvm~evSym (406 "@src/main.l" llvm pico)
llvm~eval (443 "@src/dec.l" llvm pico)
llvm~exec (450 "@src/dec.l" llvm pico)
llvm~execAt (10 "@src/main.l" llvm pico)
llvm~execErr (141 "@src/main.l" llvm pico)
llvm~extErr (352 "@src/main.l" llvm pico)
llvm~extNm (146 "@src/sym.l" llvm pico)
llvm~extern (385 "@src/sym.l" llvm pico)
llvm~extra (466 "@src/flow.l" llvm pico)
llvm~fetchChar (1250 "@src/main.l" llvm pico)
llvm~ffi (1413 "@src/main.l" llvm pico)
llvm~fill2 (1247 "@src/subr.l" llvm pico)
llvm~fill3 (1283 "@src/subr.l" llvm pico)
llvm~findSym (286 "@src/sym.l" llvm pico)
llvm~firstByte (118 "@src/sym.l" llvm pico)
llvm~firstChar (126 "@src/sym.l" llvm pico)
llvm~fish (623 "@src/apply.l" llvm pico)
llvm~flush (235 "@src/io.l" llvm pico)
llvm~flushAll (244 "@src/io.l" llvm pico)
llvm~fmtNum (975 "@src/big.l" llvm pico)
llvm~fmtScl (952 "@src/big.l" llvm pico)
llvm~forkErr (376 "@src/main.l" llvm pico)
llvm~forkLisp (2043 "@src/io.l" llvm pico)
llvm~fsyncDB (406 "@src/db.l" llvm pico)
llvm~fun (793 "@src/lib/llvm.l" llvm pico)
llvm~func (231 "@src/lib/llvm.l" llvm pico)
llvm~funq (444 "@src/main.l" llvm pico)
llvm~gc (37 "@src/gc.l" llvm pico)
llvm~gcData (556 "@src/glob.l" llvm pico)
llvm~ge0 (891 "@src/lib/llvm.l" llvm pico)
llvm~get (1537 "@src/sym.l" llvm pico)
llvm~getAdr (26 "@src/db.l" llvm pico)
llvm~getBinary (266 "@src/io.l" llvm pico)
llvm~getBlk (784 "@src/io.l" llvm pico)
llvm~getBlock (271 "@src/db.l" llvm pico)
llvm~getCaEnv (534 "@src/dec.l" llvm pico)
llvm~getChar (1298 "@src/io.l" llvm pico)
llvm~getCrtEnv (552 "@src/dec.l" llvm pico)
llvm~getIn (578 "@src/io.l" llvm pico)
llvm~getParse (2692 "@src/io.l" llvm pico)
llvm~getPlio (2596 "@src/io.l" llvm pico)
llvm~getn (1568 "@src/sym.l" llvm pico)
llvm~giveup (126 "@src/main.l" llvm pico)
llvm~global (303 "@src/lib/llvm.l" llvm pico)
llvm~goto (1460 "@src/lib/llvm.l" llvm pico)
llvm~gt0 (891 "@src/lib/llvm.l" llvm pico)
llvm~half (186 "@src/big.l" llvm pico)
llvm~hasData (759 "@src/io.l" llvm pico)
llvm~heapAlloc (153 "@src/main.l" llvm pico)
llvm~i1* (751 "@src/lib/llvm.l" llvm pico)
llvm~i16 (713 "@src/lib/llvm.l" llvm pico)
llvm~i16* (751 "@src/lib/llvm.l" llvm pico)
llvm~i32 (725 "@src/lib/llvm.l" llvm pico)
llvm~i32* (751 "@src/lib/llvm.l" llvm pico)
llvm~i64 (737 "@src/lib/llvm.l" llvm pico)
llvm~i64* (751 "@src/lib/llvm.l" llvm pico)
llvm~i8 (702 "@src/lib/llvm.l" llvm pico)
llvm~i8* (751 "@src/lib/llvm.l" llvm pico)
llvm~i8** (751 "@src/lib/llvm.l" llvm pico)
llvm~idxDel (1343 "@src/sym.l" llvm pico)
llvm~idxGet (1324 "@src/sym.l" llvm pico)
llvm~idxPut (1260 "@src/sym.l" llvm pico)
llvm~if (1284 "@src/lib/llvm.l" llvm pico)
llvm~ifn (1284 "@src/lib/llvm.l" llvm pico)
llvm~ignLog (384 "@src/db.l" llvm pico)
llvm~inFile (8 "@src/dec.l" llvm pico)
llvm~inReady (768 "@src/io.l" llvm pico)
llvm~inc (951 "@src/lib/llvm.l" llvm pico)
llvm~incs (807 "@src/big.l" llvm pico)
llvm~initInFile (56 "@src/io.l" llvm pico)
llvm~initOutFile (82 "@src/io.l" llvm pico)
llvm~initSeed (1496 "@src/big.l" llvm pico)
llvm~inline (518 "@src/lib/llvm.l" llvm pico)
llvm~int (389 "@src/dec.l" llvm pico)
llvm~intern (329 "@src/sym.l" llvm pico)
llvm~intern1 (294 "@src/sym.l" llvm pico)
llvm~intern2 (302 "@src/sym.l" llvm pico)
llvm~internLeft (318 "@src/sym.l" llvm pico)
llvm~internRight (310 "@src/sym.l" llvm pico)
llvm~ioFrame (25 "@src/dec.l" llvm pico)
llvm~ioxFrame (31 "@src/dec.l" llvm pico)
llvm~isBlank (132 "@src/sym.l" llvm pico)
llvm~isIntern (258 "@src/sym.l" llvm pico)
llvm~isLife (216 "@src/db.l" llvm pico)
llvm~isLstIntern (280 "@src/sym.l" llvm pico)
llvm~isa (374 "@src/flow.l" llvm pico)
llvm~itemErr (367 "@src/main.l" llvm pico)
llvm~jnlErr (16 "@src/db.l" llvm pico)
llvm~label (164 "@src/lib/llvm.l" llvm pico)
llvm~le0 (891 "@src/lib/llvm.l" llvm pico)
llvm~length (429 "@src/dec.l" llvm pico)
llvm~let (1166 "@src/lib/llvm.l" llvm pico)
llvm~link (1479 "@src/lib/llvm.l" llvm pico)
llvm~loadAll (2882 "@src/io.l" llvm pico)
llvm~loadCoEnv (1172 "@src/flow.l" llvm pico)
llvm~lockErr (373 "@src/main.l" llvm pico)
llvm~lockJnl (110 "@src/db.l" llvm pico)
llvm~log (112 "@src/lib/llvm.l" llvm pico)
llvm~logBlock (163 "@src/db.l" llvm pico)
llvm~lookup (1389 "@src/subr.l" llvm pico)
llvm~loop (1416 "@src/lib/llvm.l" llvm pico)
llvm~loop1 (724 "@src/flow.l" llvm pico)
llvm~loop2 (744 "@src/flow.l" llvm pico)
llvm~lstErr (361 "@src/main.l" llvm pico)
llvm~lt0 (891 "@src/lib/llvm.l" llvm pico)
llvm~lup (1362 "@src/subr.l" llvm pico)
llvm~main (1828 "@src/main.l" llvm pico)
llvm~makeErr (13 "@src/subr.l" llvm pico)
llvm~mark (7 "@src/gc.l" llvm pico)
llvm~match (1207 "@src/subr.l" llvm pico)
llvm~member (413 "@src/dec.l" llvm pico)
llvm~memcpy (1144 "@src/lib/llvm.l" llvm pico)
llvm~memq (406 "@src/dec.l" llvm pico)
llvm~memset (1155 "@src/lib/llvm.l" llvm pico)
llvm~meta (1810 "@src/sym.l" llvm pico)
llvm~method (289 "@src/flow.l" llvm pico)
llvm~mkChar (68 "@src/sym.l" llvm pico)
llvm~mkStr (98 "@src/sym.l" llvm pico)
llvm~mkStrE (108 "@src/sym.l" llvm pico)
llvm~mul (987 "@src/lib/llvm.l" llvm pico)
llvm~mulAddHiLo (575 "@src/big.l" llvm pico)
llvm~mulu (583 "@src/big.l" llvm pico)
llvm~n0 (881 "@src/lib/llvm.l" llvm pico)
llvm~name (401 "@src/dec.l" llvm pico)
llvm~natBuf (1281 "@src/main.l" llvm pico)
llvm~natErr (1322 "@src/main.l" llvm pico)
llvm~natRetBuf (1343 "@src/main.l" llvm pico)
llvm~natRetDouble (1334 "@src/main.l" llvm pico)
llvm~natRetFloat (1325 "@src/main.l" llvm pico)
llvm~need3 (266 "@src/gc.l" llvm pico)
llvm~needChkVar (513 "@src/dec.l" llvm pico)
llvm~needCnt (478 "@src/dec.l" llvm pico)
llvm~needLst (498 "@src/dec.l" llvm pico)
llvm~needNsp (519 "@src/dec.l" llvm pico)
llvm~needNum (483 "@src/dec.l" llvm pico)
llvm~needPair (493 "@src/dec.l" llvm pico)
llvm~needSymb (488 "@src/dec.l" llvm pico)
llvm~needVar (503 "@src/dec.l" llvm pico)
llvm~neg (10 "@src/big.l" llvm pico)
llvm~newBlock (179 "@src/db.l" llvm pico)
llvm~newId (198 "@src/db.l" llvm pico)
llvm~newline (2349 "@src/io.l" llvm pico)
llvm~nil? (849 "@src/lib/llvm.l" llvm pico)
llvm~noToken (1624 "@src/io.l" llvm pico)
llvm~nond (1314 "@src/lib/llvm.l" llvm pico)
llvm~not (843 "@src/lib/llvm.l" llvm pico)
llvm~nth (420 "@src/dec.l" llvm pico)
llvm~null (48 "@src/lib/llvm.l" llvm pico)
llvm~num? (820 "@src/lib/llvm.l" llvm pico)
llvm~numErr (343 "@src/main.l" llvm pico)
llvm~objFile (163 "@src/sym.l" llvm pico)
llvm~objId (169 "@src/sym.l" llvm pico)
llvm~ofs (1036 "@src/lib/llvm.l" llvm pico)
llvm~openErr (8 "@src/io.l" llvm pico)
llvm~or (1252 "@src/lib/llvm.l" llvm pico)
llvm~oru (335 "@src/big.l" llvm pico)
llvm~outAo (2377 "@src/io.l" llvm pico)
llvm~outFile (19 "@src/dec.l" llvm pico)
llvm~outNum (2364 "@src/io.l" llvm pico)
llvm~outOct (2370 "@src/io.l" llvm pico)
llvm~outScl (964 "@src/big.l" llvm pico)
llvm~outString (2401 "@src/io.l" llvm pico)
llvm~outWord (2358 "@src/io.l" llvm pico)
llvm~pack (193 "@src/sym.l" llvm pico)
llvm~packAO (177 "@src/sym.l" llvm pico)
llvm~packExtNm (187 "@src/sym.l" llvm pico)
llvm~packOct (182 "@src/sym.l" llvm pico)
llvm~pair (820 "@src/lib/llvm.l" llvm pico)
llvm~pairErr (358 "@src/main.l" llvm pico)
llvm~parse (2701 "@src/io.l" llvm pico)
llvm~pathSize (18 "@src/sym.l" llvm pico)
llvm~pathString (44 "@src/sym.l" llvm pico)
llvm~phi (137 "@src/lib/llvm.l" llvm pico)
llvm~pipeErr (14 "@src/io.l" llvm pico)
llvm~pointee (245 "@src/lib/llvm.l" llvm pico)
llvm~pollfd (744 "@src/io.l" llvm pico)
llvm~pop (1501 "@src/lib/llvm.l" llvm pico)
llvm~popCtlFiles (730 "@src/io.l" llvm pico)
llvm~popErrFiles (724 "@src/io.l" llvm pico)
llvm~popInFiles (687 "@src/io.l" llvm pico)
llvm~popOutFiles (705 "@src/io.l" llvm pico)
llvm~pos (7 "@src/big.l" llvm pico)
llvm~pr (493 "@src/io.l" llvm pico)
llvm~prCnt (372 "@src/io.l" llvm pico)
llvm~prExt (2393 "@src/io.l" llvm pico)
llvm~prName (2406 "@src/io.l" llvm pico)
llvm~prSym (2411 "@src/io.l" llvm pico)
llvm~prTell (503 "@src/io.l" llvm pico)
llvm~preStr (817 "@src/sym.l" llvm pico)
llvm~prin (2512 "@src/io.l" llvm pico)
llvm~print (2440 "@src/io.l" llvm pico)
llvm~printName (2414 "@src/io.l" llvm pico)
llvm~printSym (2435 "@src/io.l" llvm pico)
llvm~prog1 (1269 "@src/lib/llvm.l" llvm pico)
llvm~prog2 (1276 "@src/lib/llvm.l" llvm pico)
llvm~prop (1587 "@src/sym.l" llvm pico)
llvm~protErr (370 "@src/main.l" llvm pico)
llvm~ptr (238 "@src/lib/llvm.l" llvm pico)
llvm~push (1212 "@src/lib/llvm.l" llvm pico)
llvm~pushCtlFile (681 "@src/io.l" llvm pico)
llvm~pushErrFile (677 "@src/io.l" llvm pico)
llvm~pushInFile (658 "@src/io.l" llvm pico)
llvm~pushInput (1996 "@src/io.l" llvm pico)
llvm~pushOutFile (669 "@src/io.l" llvm pico)
llvm~pushOutput (2009 "@src/io.l" llvm pico)
llvm~put (1458 "@src/sym.l" llvm pico)
llvm~put1 (610 "@src/io.l" llvm pico)
llvm~putBlock (280 "@src/db.l" llvm pico)
llvm~putCaEnv (525 "@src/dec.l" llvm pico)
llvm~putCrtEnv (543 "@src/dec.l" llvm pico)
llvm~putOut (629 "@src/io.l" llvm pico)
llvm~putPlio (2601 "@src/io.l" llvm pico)
llvm~putSrc (20 "@src/flow.l" llvm pico)
llvm~putString (2729 "@src/io.l" llvm pico)
llvm~putTell (497 "@src/io.l" llvm pico)
llvm~putn (1518 "@src/sym.l" llvm pico)
llvm~rdAtom (1421 "@src/io.l" llvm pico)
llvm~rdBlock (125 "@src/db.l" llvm pico)
llvm~rdBytes (152 "@src/io.l" llvm pico)
llvm~rdBytesNb (163 "@src/io.l" llvm pico)
llvm~rdList (1500 "@src/io.l" llvm pico)
llvm~rdLockDb (70 "@src/db.l" llvm pico)
llvm~rdLockWait (44 "@src/io.l" llvm pico)
llvm~rdOpen (1060 "@src/io.l" llvm pico)
llvm~rdl (1461 "@src/io.l" llvm pico)
llvm~read0 (1524 "@src/io.l" llvm pico)
llvm~read1 (1617 "@src/io.l" llvm pico)
llvm~redefMsg (7 "@src/flow.l" llvm pico)
llvm~redefine (49 "@src/flow.l" llvm pico)
llvm~reentErr (1146 "@src/flow.l" llvm pico)
llvm~remu (797 "@src/big.l" llvm pico)
llvm~repl (2839 "@src/io.l" llvm pico)
llvm~requestSym (375 "@src/sym.l" llvm pico)
llvm~restore (415 "@src/db.l" llvm pico)
llvm~ret (1464 "@src/lib/llvm.l" llvm pico)
llvm~rlAvail (1248 "@src/io.l" llvm pico)
llvm~rlGetc (1243 "@src/io.l" llvm pico)
llvm~run (457 "@src/dec.l" llvm pico)
llvm~runAt (15 "@src/main.l" llvm pico)
llvm~runCo (1181 "@src/flow.l" llvm pico)
llvm~safe (1538 "@src/lib/llvm.l" llvm pico)
llvm~save (1508 "@src/lib/llvm.l" llvm pico)
llvm~save2 (1523 "@src/lib/llvm.l" llvm pico)
llvm~saveCoEnv (1165 "@src/flow.l" llvm pico)
llvm~saveCoIO (1157 "@src/flow.l" llvm pico)
llvm~selectErr (35 "@src/io.l" llvm pico)
llvm~set (1122 "@src/lib/llvm.l" llvm pico)
llvm~setAdr (48 "@src/db.l" llvm pico)
llvm~setDestruct (937 "@src/flow.l" llvm pico)
llvm~sharedLib (737 "@src/main.l" llvm pico)
llvm~shift (1083 "@src/lib/llvm.l" llvm pico)
llvm~shl (1018 "@src/lib/llvm.l" llvm pico)
llvm~shlu (240 "@src/big.l" llvm pico)
llvm~short (296 "@src/lib/llvm.l" llvm pico)
llvm~shr (1018 "@src/lib/llvm.l" llvm pico)
llvm~shru (263 "@src/big.l" llvm pico)
llvm~sig (167 "@src/main.l" llvm pico)
llvm~sigChk (471 "@src/dec.l" llvm pico)
llvm~sigTerm (174 "@src/main.l" llvm pico)
llvm~sighandler (181 "@src/main.l" llvm pico)
llvm~sign (395 "@src/dec.l" llvm pico)
llvm~sign? (820 "@src/lib/llvm.l" llvm pico)
llvm~size (1006 "@src/subr.l" llvm pico)
llvm~sizeErr (17 "@src/io.l" llvm pico)
llvm~skip (1350 "@src/io.l" llvm pico)
llvm~skipc (1316 "@src/io.l" llvm pico)
llvm~slow (122 "@src/io.l" llvm pico)
llvm~slowNb (134 "@src/io.l" llvm pico)
llvm~space (2352 "@src/io.l" llvm pico)
llvm~ssa (131 "@src/lib/llvm.l" llvm pico)
llvm~stack (1189 "@src/lib/llvm.l" llvm pico)
llvm~stdEval (2818 "@src/io.l" llvm pico)
llvm~stdRead (2786 "@src/io.l" llvm pico)
llvm~stdinByte (252 "@src/io.l" llvm pico)
llvm~stkChk (467 "@src/dec.l" llvm pico)
llvm~stkErr (328 "@src/main.l" llvm pico)
llvm~stkOverErr (1152 "@src/flow.l" llvm pico)
llvm~stop (51 "@src/main.l" llvm pico)
llvm~store (250 "@src/lib/llvm.l" llvm pico)
llvm~str (337 "@src/lib/llvm.l" llvm pico)
llvm~struct (631 "@src/lib/llvm.l" llvm pico)
llvm~sub (932 "@src/lib/llvm.l" llvm pico)
llvm~sub1 (480 "@src/big.l" llvm pico)
llvm~subStr (824 "@src/sym.l" llvm pico)
llvm~subr (1244 "@src/lib/llvm.l" llvm pico)
llvm~subs (830 "@src/big.l" llvm pico)
llvm~subu (508 "@src/big.l" llvm pico)
llvm~sym (398 "@src/dec.l" llvm pico)
llvm~sym? (820 "@src/lib/llvm.l" llvm pico)
llvm~symByte (21 "@src/big.l" llvm pico)
llvm~symChar (36 "@src/big.l" llvm pico)
llvm~symErr (346 "@src/main.l" llvm pico)
llvm~symNspErr (379 "@src/main.l" llvm pico)
llvm~symTab (448 "@src/lib/llvm.l" llvm pico)
llvm~symToNum (902 "@src/big.l" llvm pico)
llvm~symb? (834 "@src/lib/llvm.l" llvm pico)
llvm~t? (849 "@src/lib/llvm.l" llvm pico)
llvm~tabComplete (704 "@src/apply.l" llvm pico)
llvm~table (397 "@src/lib/llvm.l" llvm pico)
llvm~tagErr (1149 "@src/flow.l" llvm pico)
llvm~tail (802 "@src/lib/llvm.l" llvm pico)
llvm~tailcall (541 "@src/lib/llvm.l" llvm pico)
llvm~tellBeg (509 "@src/io.l" llvm pico)
llvm~tellEnd (516 "@src/io.l" llvm pico)
llvm~tenfold (221 "@src/big.l" llvm pico)
llvm~testEsc (1377 "@src/io.l" llvm pico)
llvm~tglString (2739 "@src/io.l" llvm pico)
llvm~tmDate (593 "@src/main.l" llvm pico)
llvm~tmTime (621 "@src/main.l" llvm pico)
llvm~token (1632 "@src/io.l" llvm pico)
llvm~trace (1566 "@src/flow.l" llvm pico)
llvm~transaction (388 "@src/db.l" llvm pico)
llvm~trim (600 "@src/subr.l" llvm pico)
llvm~truncLog (449 "@src/db.l" llvm pico)
llvm~tryLock (90 "@src/db.l" llvm pico)
llvm~twice (177 "@src/big.l" llvm pico)
llvm~twiceBig (164 "@src/big.l" llvm pico)
llvm~type (224 "@src/lib/llvm.l" llvm pico)
llvm~unLockDb (78 "@src/db.l" llvm pico)
llvm~unLockJnl (113 "@src/db.l" llvm pico)
llvm~undefined (918 "@src/main.l" llvm pico)
llvm~uniChr (1364 "@src/io.l" llvm pico)
llvm~uniFill (1397 "@src/subr.l" llvm pico)
llvm~uniRun (1407 "@src/subr.l" llvm pico)
llvm~unify (1314 "@src/subr.l" llvm pico)
llvm~unintern (481 "@src/sym.l" llvm pico)
llvm~unless (1302 "@src/lib/llvm.l" llvm pico)
llvm~unsync (542 "@src/io.l" llvm pico)
llvm~until (1401 "@src/lib/llvm.l" llvm pico)
llvm~unwind (60 "@src/main.l" llvm pico)
llvm~val (1091 "@src/lib/llvm.l" llvm pico)
llvm~var (331 "@src/lib/llvm.l" llvm pico)
llvm~varErr (364 "@src/main.l" llvm pico)
llvm~void (47 "@src/lib/llvm.l" llvm pico)
llvm~volatile (1115 "@src/lib/llvm.l" llvm pico)
llvm~waitFd (789 "@src/io.l" llvm pico)
llvm~waitFile (553 "@src/io.l" llvm pico)
llvm~when (1302 "@src/lib/llvm.l" llvm pico)
llvm~while (1401 "@src/lib/llvm.l" llvm pico)
llvm~wipe (1780 "@src/sym.l" llvm pico)
llvm~wrBlock (156 "@src/db.l" llvm pico)
llvm~wrBytes (185 "@src/io.l" llvm pico)
llvm~wrChild (211 "@src/io.l" llvm pico)
llvm~wrLockDb (74 "@src/db.l" llvm pico)
llvm~wrLockWait (49 "@src/io.l" llvm pico)
llvm~wrOpen (1124 "@src/io.l" llvm pico)
llvm~writeErr (32 "@src/io.l" llvm pico)
llvm~wrnl (21 "@src/main.l" llvm pico)
llvm~xCnt (385 "@src/main.l" llvm pico)
llvm~xName (411 "@src/main.l" llvm pico)
llvm~xSym (398 "@src/main.l" llvm pico)
llvm~xchg (1131 "@src/lib/llvm.l" llvm pico)
llvm~xoru (374 "@src/big.l" llvm pico)
llvm~x| (973 "@src/lib/llvm.l" llvm pico)
llvm~zapZero (143 "@src/big.l" llvm pico)
llvm~| (973 "@src/lib/llvm.l" llvm pico)
llvm~TgOS (5 "@src/lib.c" llvm pico)
llvm~TgCPU (6 "@src/lib.c" llvm pico)
llvm~PipeBufSize (9 "@src/lib.c" llvm pico)
llvm~stderrMsg (11 "@src/lib.c" llvm pico)
llvm~gPrintf (16 "@src/lib.c" llvm pico)
llvm~strErrno (21 "@src/lib.c" llvm pico)
llvm~openRd (25 "@src/lib.c" llvm pico)
llvm~openWr (29 "@src/lib.c" llvm pico)
llvm~openRdWr (33 "@src/lib.c" llvm pico)
llvm~openRdWrExcl (37 "@src/lib.c" llvm pico)
llvm~openRdWrCreate (41 "@src/lib.c" llvm pico)
llvm~openRdWrAppend (45 "@src/lib.c" llvm pico)
llvm~openWrAppend (49 "@src/lib.c" llvm pico)
llvm~fseekOfs (53 "@src/lib.c" llvm pico)
llvm~fseek0 (57 "@src/lib.c" llvm pico)
llvm~seek0 (61 "@src/lib.c" llvm pico)
llvm~truncate0 (65 "@src/lib.c" llvm pico)
llvm~socketPair (69 "@src/lib.c" llvm pico)
llvm~fcntlCloExec (73 "@src/lib.c" llvm pico)
llvm~fcntlSetFl (77 "@src/lib.c" llvm pico)
llvm~nonBlocking (81 "@src/lib.c" llvm pico)
llvm~fcntlSetOwn (88 "@src/lib.c" llvm pico)
llvm~getDir (93 "@src/lib.c" llvm pico)
llvm~initReadline (116 "@src/lib.c" llvm pico)
llvm~gReadline (128 "@src/lib.c" llvm pico)
llvm~rlHide (136 "@src/lib.c" llvm pico)
llvm~rlShow (143 "@src/lib.c" llvm pico)
llvm~rlSigBeg (148 "@src/lib.c" llvm pico)
llvm~rlSigEnd (156 "@src/lib.c" llvm pico)
llvm~currentLine (163 "@src/lib.c" llvm pico)
llvm~Sig (170 "@src/lib.c" llvm pico)
llvm~SigDfl (175 "@src/lib.c" llvm pico)
llvm~SigIgn (176 "@src/lib.c" llvm pico)
llvm~gSignal (179 "@src/lib.c" llvm pico)
llvm~iSignal (200 "@src/lib.c" llvm pico)
llvm~sigUnblock (209 "@src/lib.c" llvm pico)
llvm~sigChld (221 "@src/lib.c" llvm pico)
llvm~waitWuntraced (232 "@src/lib.c" llvm pico)
llvm~wifStopped (236 "@src/lib.c" llvm pico)
llvm~nErrno (240 "@src/lib.c" llvm pico)
llvm~gErrno (245 "@src/lib.c" llvm pico)
llvm~OrgTermio (260 "@src/lib.c" llvm pico)
llvm~Termio (261 "@src/lib.c" llvm pico)
llvm~stopTerm (267 "@src/lib.c" llvm pico)
llvm~setRaw (280 "@src/lib.c" llvm pico)
llvm~setCooked (292 "@src/lib.c" llvm pico)
llvm~reopenTty (299 "@src/lib.c" llvm pico)
llvm~getUsec (310 "@src/lib.c" llvm pico)
llvm~getMsec (321 "@src/lib.c" llvm pico)
llvm~getDate (329 "@src/lib.c" llvm pico)
llvm~getGmDate (336 "@src/lib.c" llvm pico)
llvm~getTime (343 "@src/lib.c" llvm pico)
llvm~getGmTime (352 "@src/lib.c" llvm pico)
llvm~ulimStk (356 "@src/lib.c" llvm pico)
llvm~fileInfo (366 "@src/lib.c" llvm pico)
llvm~pollIn (385 "@src/lib.c" llvm pico)
llvm~pollOut (390 "@src/lib.c" llvm pico)
llvm~pollIgn (395 "@src/lib.c" llvm pico)
llvm~gPoll (399 "@src/lib.c" llvm pico)
llvm~readyIn (435 "@src/lib.c" llvm pico)
llvm~readyOut (442 "@src/lib.c" llvm pico)
llvm~rdLock (450 "@src/lib.c" llvm pico)
llvm~wrLock (460 "@src/lib.c" llvm pico)
llvm~unLock (470 "@src/lib.c" llvm pico)
llvm~getLock (480 "@src/lib.c" llvm pico)
llvm~JmpBufSize (493 "@src/lib.c" llvm pico)
llvm~QuitRst (494 "@src/lib.c" llvm pico)
llvm~Fdigit (525 "@src/lib.c" llvm pico)
llvm~boxFloat (532 "@src/lib.c" llvm pico)
llvm~boxFlt (550 "@src/lib.c" llvm pico)
llvm~boxDouble (558 "@src/lib.c" llvm pico)
llvm~boxDbl (576 "@src/lib.c" llvm pico)
llvm~bufFloat (584 "@src/lib.c" llvm pico)
llvm~bufDouble (600 "@src/lib.c" llvm pico)
llvm~dlOpen (628 "@src/lib.c" llvm pico)
llvm~ffiPrep (632 "@src/lib.c" llvm pico)
llvm~ffiCall (677 "@src/lib.c" llvm pico)
llvm~arg (738 "@src/lib.c" llvm pico)
llvm~chance (743 "@src/lib.c" llvm pico)
llvm~isLowc (1277 "@src/lib.c" llvm pico)
llvm~isUppc (1283 "@src/lib.c" llvm pico)
llvm~isLetterOrDigit (1289 "@src/lib.c" llvm pico)
llvm~toUpperCase (1295 "@src/lib.c" llvm pico)
llvm~toLowerCase (1301 "@src/lib.c" llvm pico)
pico~! (1530 "@src/flow.l" llvm pico)
pico~$ (1580 "@src/flow.l" llvm pico)
pico~% (1266 "@src/big.l" llvm pico)
pico~%@ (1474 "@src/main.l" llvm pico)
pico~& (1401 "@src/big.l" llvm pico)
pico~* (1195 "@src/big.l" llvm pico)
pico~*/ (1216 "@src/big.l" llvm pico)
pico~+ (1124 "@src/big.l" llvm pico)
pico~++ (1003 "@src/sym.l" llvm pico)
pico~- (1137 "@src/big.l" llvm pico)
pico~-> (1598 "@src/subr.l" llvm pico)
pico~/ (1244 "@src/big.l" llvm pico)
pico~: (1710 "@src/sym.l" llvm pico)
pico~:: (1717 "@src/sym.l" llvm pico)
pico~; (1678 "@src/sym.l" llvm pico)
pico~< (768 "@src/subr.l" llvm pico)
pico~<= (777 "@src/subr.l" llvm pico)
pico~<> (741 "@src/subr.l" llvm pico)
pico~= (734 "@src/subr.l" llvm pico)
pico~=0 (748 "@src/subr.l" llvm pico)
pico~=1 (752 "@src/subr.l" llvm pico)
pico~=: (1689 "@src/sym.l" llvm pico)
pico~== (720 "@src/subr.l" llvm pico)
pico~==== (709 "@src/sym.l" llvm pico)
pico~=T (756 "@src/subr.l" llvm pico)
pico~> (786 "@src/subr.l" llvm pico)
pico~>= (795 "@src/subr.l" llvm pico)
pico~>> (1288 "@src/big.l" llvm pico)
pico~abs (1370 "@src/big.l" llvm pico)
pico~adr (1673 "@src/main.l" llvm pico)
pico~alarm (514 "@src/main.l" llvm pico)
pico~all (609 "@src/sym.l" llvm pico)
pico~and (496 "@src/flow.l" llvm pico)
pico~any (2751 "@src/io.l" llvm pico)
pico~append (375 "@src/subr.l" llvm pico)
pico~apply (6 "@src/apply.l" llvm pico)
pico~arg (1653 "@src/main.l" llvm pico)
pico~args (1643 "@src/main.l" llvm pico)
pico~argv (1197 "@src/main.l" llvm pico)
pico~as (62 "@src/flow.l" llvm pico)
pico~asoq (1164 "@src/subr.l" llvm pico)
pico~assoc (1138 "@src/subr.l" llvm pico)
pico~at (708 "@src/flow.l" llvm pico)
pico~atom (822 "@src/subr.l" llvm pico)
pico~bind (880 "@src/flow.l" llvm pico)
pico~bit? (1377 "@src/big.l" llvm pico)
pico~blk (676 "@src/db.l" llvm pico)
pico~bool (540 "@src/flow.l" llvm pico)
pico~box (316 "@src/flow.l" llvm pico)
pico~box? (713 "@src/sym.l" llvm pico)
pico~buf (1043 "@src/flow.l" llvm pico)
pico~by (658 "@src/apply.l" llvm pico)
pico~bye (1736 "@src/flow.l" llvm pico)
pico~byte (1680 "@src/main.l" llvm pico)
pico~bytes (1134 "@src/subr.l" llvm pico)
pico~caaaar (60 "@src/subr.l" llvm pico)
pico~caaadr (63 "@src/subr.l" llvm pico)
pico~caaar (36 "@src/subr.l" llvm pico)
pico~caadar (66 "@src/subr.l" llvm pico)
pico~caaddr (69 "@src/subr.l" llvm pico)
pico~caadr (39 "@src/subr.l" llvm pico)
pico~caar (24 "@src/subr.l" llvm pico)
pico~cadaar (72 "@src/subr.l" llvm pico)
pico~cadadr (75 "@src/subr.l" llvm pico)
pico~cadar (42 "@src/subr.l" llvm pico)
pico~caddar (78 "@src/subr.l" llvm pico)
pico~cadddr (81 "@src/subr.l" llvm pico)
pico~caddr (45 "@src/subr.l" llvm pico)
pico~cadr (27 "@src/subr.l" llvm pico)
pico~call (1639 "@src/flow.l" llvm pico)
pico~car (17 "@src/subr.l" llvm pico)
pico~case (654 "@src/flow.l" llvm pico)
pico~casq (666 "@src/flow.l" llvm pico)
pico~catch (1089 "@src/flow.l" llvm pico)
pico~cd (1061 "@src/main.l" llvm pico)
pico~cdaaar (84 "@src/subr.l" llvm pico)
pico~cdaadr (87 "@src/subr.l" llvm pico)
pico~cdaar (48 "@src/subr.l" llvm pico)
pico~cdadar (90 "@src/subr.l" llvm pico)
pico~cdaddr (93 "@src/subr.l" llvm pico)
pico~cdadr (51 "@src/subr.l" llvm pico)
pico~cdar (30 "@src/subr.l" llvm pico)
pico~cddaar (96 "@src/subr.l" llvm pico)
pico~cddadr (99 "@src/subr.l" llvm pico)
pico~cddar (54 "@src/subr.l" llvm pico)
pico~cdddar (102 "@src/subr.l" llvm pico)
pico~cddddr (105 "@src/subr.l" llvm pico)
pico~cdddr (57 "@src/subr.l" llvm pico)
pico~cddr (33 "@src/subr.l" llvm pico)
pico~cdr (21 "@src/subr.l" llvm pico)
pico~chain (291 "@src/subr.l" llvm pico)
pico~char (1758 "@src/io.l" llvm pico)
pico~chop (743 "@src/sym.l" llvm pico)
pico~circ (155 "@src/subr.l" llvm pico)
pico~circ? (830 "@src/subr.l" llvm pico)
pico~clip (614 "@src/subr.l" llvm pico)
pico~close (2215 "@src/io.l" llvm pico)
pico~cmd (1130 "@src/main.l" llvm pico)
pico~cnt (481 "@src/apply.l" llvm pico)
pico~co (1222 "@src/flow.l" llvm pico)
pico~commit (886 "@src/db.l" llvm pico)
pico~con (121 "@src/subr.l" llvm pico)
pico~conc (140 "@src/subr.l" llvm pico)
pico~cond (634 "@src/flow.l" llvm pico)
pico~cons (128 "@src/subr.l" llvm pico)
pico~copy (334 "@src/subr.l" llvm pico)
pico~ctl (1987 "@src/io.l" llvm pico)
pico~ctty (1075 "@src/main.l" llvm pico)
pico~cut (1018 "@src/sym.l" llvm pico)
pico~date (636 "@src/main.l" llvm pico)
pico~dbck (1198 "@src/db.l" llvm pico)
pico~de (154 "@src/flow.l" llvm pico)
pico~dec (1175 "@src/big.l" llvm pico)
pico~def (123 "@src/flow.l" llvm pico)
pico~default (946 "@src/sym.l" llvm pico)
pico~del (1037 "@src/sym.l" llvm pico)
pico~delete (395 "@src/subr.l" llvm pico)
pico~delq (416 "@src/subr.l" llvm pico)
pico~detach (1718 "@src/flow.l" llvm pico)
pico~diff (916 "@src/subr.l" llvm pico)
pico~dir (1137 "@src/main.l" llvm pico)
pico~dm (162 "@src/flow.l" llvm pico)
pico~do (763 "@src/flow.l" llvm pico)
pico~e (1537 "@src/flow.l" llvm pico)
pico~echo (2228 "@src/io.l" llvm pico)
pico~enum (1144 "@src/sym.l" llvm pico)
pico~enum? (1241 "@src/sym.l" llvm pico)
pico~env (1698 "@src/main.l" llvm pico)
pico~eof (1790 "@src/io.l" llvm pico)
pico~eol (1783 "@src/io.l" llvm pico)
pico~err (1979 "@src/io.l" llvm pico)
pico~errno (1244 "@src/main.l" llvm pico)
pico~eval (81 "@src/flow.l" llvm pico)
pico~exec (1620 "@src/flow.l" llvm pico)
pico~ext (2587 "@src/io.l" llvm pico)
pico~ext? (246 "@src/db.l" llvm pico)
pico~extern (348 "@src/db.l" llvm pico)
pico~extra (485 "@src/flow.l" llvm pico)
pico~extract (325 "@src/apply.l" llvm pico)
pico~fd (2035 "@src/io.l" llvm pico)
pico~fifo (1080 "@src/sym.l" llvm pico)
pico~file (1183 "@src/main.l" llvm pico)
pico~fill (1297 "@src/subr.l" llvm pico)
pico~filter (287 "@src/apply.l" llvm pico)
pico~fin (704 "@src/subr.l" llvm pico)
pico~finally (1124 "@src/flow.l" llvm pico)
pico~find (386 "@src/apply.l" llvm pico)
pico~fish (636 "@src/apply.l" llvm pico)
pico~flg? (850 "@src/subr.l" llvm pico)
pico~flip (571 "@src/subr.l" llvm pico)
pico~flush (2571 "@src/io.l" llvm pico)
pico~fold (1887 "@src/sym.l" llvm pico)
pico~for (784 "@src/flow.l" llvm pico)
pico~fork (1712 "@src/flow.l" llvm pico)
pico~format (1088 "@src/big.l" llvm pico)
pico~free (1170 "@src/db.l" llvm pico)
pico~from (1801 "@src/io.l" llvm pico)
pico~full (252 "@src/subr.l" llvm pico)
pico~fully (450 "@src/apply.l" llvm pico)
pico~fun (45 "@src/apply.l" llvm pico)
pico~fun? (548 "@src/sym.l" llvm pico)
pico~gc (272 "@src/gc.l" llvm pico)
pico~ge0 (1351 "@src/big.l" llvm pico)
pico~get (1649 "@src/sym.l" llvm pico)
pico~getd (554 "@src/sym.l" llvm pico)
pico~getl (1761 "@src/sym.l" llvm pico)
pico~glue (772 "@src/sym.l" llvm pico)
pico~group (1631 "@src/subr.l" llvm pico)
pico~gt0 (1360 "@src/big.l" llvm pico)
pico~hash (1521 "@src/big.l" llvm pico)
pico~head (621 "@src/subr.l" llvm pico)
pico~heap (548 "@src/main.l" llvm pico)
pico~hear (995 "@src/io.l" llvm pico)
pico~history (1790 "@src/main.l" llvm pico)
pico~id (655 "@src/db.l" llvm pico)
pico~idx (1376 "@src/sym.l" llvm pico)
pico~if (580 "@src/flow.l" llvm pico)
pico~if2 (596 "@src/flow.l" llvm pico)
pico~if@@ (610 "@src/flow.l" llvm pico)
pico~ifn (588 "@src/flow.l" llvm pico)
pico~in (1963 "@src/io.l" llvm pico)
pico~inc (1154 "@src/big.l" llvm pico)
pico~index (934 "@src/subr.l" llvm pico)
pico~info (1156 "@src/main.l" llvm pico)
pico~input (2019 "@src/io.l" llvm pico)
pico~insert (462 "@src/subr.l" llvm pico)
pico~intern (688 "@src/sym.l" llvm pico)
pico~ipid (1686 "@src/flow.l" llvm pico)
pico~isa (389 "@src/flow.l" llvm pico)
pico~job (914 "@src/flow.l" llvm pico)
pico~journal (606 "@src/db.l" llvm pico)
pico~key (1709 "@src/io.l" llvm pico)
pico~kids (528 "@src/main.l" llvm pico)
pico~kill (1700 "@src/flow.l" llvm pico)
pico~last (711 "@src/subr.l" llvm pico)
pico~le0 (1342 "@src/big.l" llvm pico)
pico~length (974 "@src/subr.l" llvm pico)
pico~let (952 "@src/flow.l" llvm pico)
pico~let? (1011 "@src/flow.l" llvm pico)
pico~lieu (756 "@src/db.l" llvm pico)
pico~line (1892 "@src/io.l" llvm pico)
pico~link (305 "@src/subr.l" llvm pico)
pico~lisp (1626 "@src/main.l" llvm pico)
pico~list (187 "@src/subr.l" llvm pico)
pico~lit (69 "@src/flow.l" llvm pico)
pico~load (2897 "@src/io.l" llvm pico)
pico~lock (773 "@src/db.l" llvm pico)
pico~loop (778 "@src/flow.l" llvm pico)
pico~low? (1840 "@src/sym.l" llvm pico)
pico~lowc (1854 "@src/sym.l" llvm pico)
pico~lst? (834 "@src/subr.l" llvm pico)
pico~lt0 (1336 "@src/big.l" llvm pico)
pico~lup (1391 "@src/sym.l" llvm pico)
pico~made (275 "@src/subr.l" llvm pico)
pico~make (260 "@src/subr.l" llvm pico)
pico~map (94 "@src/apply.l" llvm pico)
pico~mapc (117 "@src/apply.l" llvm pico)
pico~mapcan (246 "@src/apply.l" llvm pico)
pico~mapcar (177 "@src/apply.l" llvm pico)
pico~mapcon (214 "@src/apply.l" llvm pico)
pico~maplist (149 "@src/apply.l" llvm pico)
pico~maps (49 "@src/apply.l" llvm pico)
pico~mark (1122 "@src/db.l" llvm pico)
pico~match (1236 "@src/subr.l" llvm pico)
pico~max (804 "@src/subr.l" llvm pico)
pico~maxi (548 "@src/apply.l" llvm pico)
pico~member (856 "@src/subr.l" llvm pico)
pico~memq (869 "@src/subr.l" llvm pico)
pico~meta (1825 "@src/sym.l" llvm pico)
pico~meth (306 "@src/flow.l" llvm pico)
pico~method (407 "@src/flow.l" llvm pico)
pico~min (813 "@src/subr.l" llvm pico)
pico~mini (585 "@src/apply.l" llvm pico)
pico~mix (349 "@src/subr.l" llvm pico)
pico~mmeq (882 "@src/subr.l" llvm pico)
pico~n0 (760 "@src/subr.l" llvm pico)
pico~n== (727 "@src/subr.l" llvm pico)
pico~nT (764 "@src/subr.l" llvm pico)
pico~name (510 "@src/sym.l" llvm pico)
pico~nand (514 "@src/flow.l" llvm pico)
pico~native (1487 "@src/main.l" llvm pico)
pico~need (199 "@src/subr.l" llvm pico)
pico~new (320 "@src/flow.l" llvm pico)
pico~next (1647 "@src/main.l" llvm pico)
pico~nil (551 "@src/flow.l" llvm pico)
pico~nond (644 "@src/flow.l" llvm pico)
pico~nor (523 "@src/flow.l" llvm pico)
pico~not (544 "@src/flow.l" llvm pico)
pico~nsp (520 "@src/sym.l" llvm pico)
pico~nth (109 "@src/subr.l" llvm pico)
pico~num? (840 "@src/subr.l" llvm pico)
pico~off (915 "@src/sym.l" llvm pico)
pico~offset (948 "@src/subr.l" llvm pico)
pico~on (908 "@src/sym.l" llvm pico)
pico~onOff (922 "@src/sym.l" llvm pico)
pico~one (939 "@src/sym.l" llvm pico)
pico~open (2199 "@src/io.l" llvm pico)
pico~opid (1693 "@src/flow.l" llvm pico)
pico~opt (1231 "@src/main.l" llvm pico)
pico~or (505 "@src/flow.l" llvm pico)
pico~out (1971 "@src/io.l" llvm pico)
pico~output (2027 "@src/io.l" llvm pico)
pico~pack (761 "@src/sym.l" llvm pico)
pico~pair (826 "@src/subr.l" llvm pico)
pico~pass (25 "@src/apply.l" llvm pico)
pico~pat? (541 "@src/sym.l" llvm pico)
pico~path (738 "@src/io.l" llvm pico)
pico~peek (1750 "@src/io.l" llvm pico)
pico~pick (419 "@src/apply.l" llvm pico)
pico~pipe (2155 "@src/io.l" llvm pico)
pico~place (496 "@src/subr.l" llvm pico)
pico~plio (2609 "@src/io.l" llvm pico)
pico~poll (1039 "@src/io.l" llvm pico)
pico~pool (455 "@src/db.l" llvm pico)
pico~pool2 (565 "@src/db.l" llvm pico)
pico~pop (993 "@src/sym.l" llvm pico)
pico~pr (2674 "@src/io.l" llvm pico)
pico~pre? (836 "@src/sym.l" llvm pico)
pico~prin (2531 "@src/io.l" llvm pico)
pico~prinl (2539 "@src/io.l" llvm pico)
pico~print (2554 "@src/io.l" llvm pico)
pico~println (2567 "@src/io.l" llvm pico)
pico~printsp (2563 "@src/io.l" llvm pico)
pico~prior (961 "@src/subr.l" llvm pico)
pico~prog (561 "@src/flow.l" llvm pico)
pico~prog1 (565 "@src/flow.l" llvm pico)
pico~prog2 (572 "@src/flow.l" llvm pico)
pico~prompt (497 "@src/main.l" llvm pico)
pico~prop (1660 "@src/sym.l" llvm pico)
pico~protect (540 "@src/main.l" llvm pico)
pico~prove (1465 "@src/subr.l" llvm pico)
pico~push (955 "@src/sym.l" llvm pico)
pico~push1 (967 "@src/sym.l" llvm pico)
pico~push1q (980 "@src/sym.l" llvm pico)
pico~put (1624 "@src/sym.l" llvm pico)
pico~putl (1731 "@src/sym.l" llvm pico)
pico~pwd (1054 "@src/main.l" llvm pico)
pico~queue (1062 "@src/sym.l" llvm pico)
pico~quit (1025 "@src/main.l" llvm pico)
pico~quote (58 "@src/flow.l" llvm pico)
pico~rand (1531 "@src/big.l" llvm pico)
pico~range (231 "@src/subr.l" llvm pico)
pico~rank (1190 "@src/subr.l" llvm pico)
pico~rasoq (1177 "@src/subr.l" llvm pico)
pico~rassoc (1151 "@src/subr.l" llvm pico)
pico~raw (505 "@src/main.l" llvm pico)
pico~rd (2635 "@src/io.l" llvm pico)
pico~read (1694 "@src/io.l" llvm pico)
pico~remove (477 "@src/subr.l" llvm pico)
pico~replace (437 "@src/subr.l" llvm pico)
pico~rest (1662 "@src/main.l" llvm pico)
pico~rev (1322 "@src/big.l" llvm pico)
pico~reverse (561 "@src/subr.l" llvm pico)
pico~rewind (2575 "@src/io.l" llvm pico)
pico~rid (1111 "@src/sym.l" llvm pico)
pico~rollback (299 "@src/db.l" llvm pico)
pico~rot (166 "@src/subr.l" llvm pico)
pico~rt (725 "@src/main.l" llvm pico)
pico~run (99 "@src/flow.l" llvm pico)
pico~sect (898 "@src/subr.l" llvm pico)
pico~seed (1515 "@src/big.l" llvm pico)
pico~seek (363 "@src/apply.l" llvm pico)
pico~send (417 "@src/flow.l" llvm pico)
pico~seq (725 "@src/db.l" llvm pico)
pico~set (864 "@src/sym.l" llvm pico)
pico~setq (876 "@src/sym.l" llvm pico)
pico~shift (1011 "@src/sym.l" llvm pico)
pico~sigio (521 "@src/main.l" llvm pico)
pico~size (1077 "@src/subr.l" llvm pico)
pico~skip (1777 "@src/io.l" llvm pico)
pico~sort (1667 "@src/subr.l" llvm pico)
pico~sp? (535 "@src/sym.l" llvm pico)
pico~space (2543 "@src/io.l" llvm pico)
pico~split (524 "@src/subr.l" llvm pico)
pico~sqrt (1440 "@src/big.l" llvm pico)
pico~stack (561 "@src/main.l" llvm pico)
pico~state (675 "@src/flow.l" llvm pico)
pico~stem (684 "@src/subr.l" llvm pico)
pico~str (2765 "@src/io.l" llvm pico)
pico~str? (724 "@src/sym.l" llvm pico)
pico~strip (516 "@src/subr.l" llvm pico)
pico~struct (1514 "@src/main.l" llvm pico)
pico~sub? (850 "@src/sym.l" llvm pico)
pico~sum (514 "@src/apply.l" llvm pico)
pico~super (447 "@src/flow.l" llvm pico)
pico~swap (883 "@src/sym.l" llvm pico)
pico~sym (2757 "@src/io.l" llvm pico)
pico~sym? (844 "@src/subr.l" llvm pico)
pico~symbols (643 "@src/sym.l" llvm pico)
pico~sync (973 "@src/io.l" llvm pico)
pico~sys (1038 "@src/main.l" llvm pico)
pico~t (556 "@src/flow.l" llvm pico)
pico~tail (654 "@src/subr.l" llvm pico)
pico~tc (1079 "@src/flow.l" llvm pico)
pico~tco (1056 "@src/flow.l" llvm pico)
pico~tell (1014 "@src/io.l" llvm pico)
pico~text (785 "@src/sym.l" llvm pico)
pico~throw (1108 "@src/flow.l" llvm pico)
pico~till (1846 "@src/io.l" llvm pico)
pico~time (688 "@src/main.l" llvm pico)
pico~touch (869 "@src/db.l" llvm pico)
pico~trail (1733 "@src/main.l" llvm pico)
pico~trim (610 "@src/subr.l" llvm pico)
pico~try (430 "@src/flow.l" llvm pico)
pico~tty (485 "@src/main.l" llvm pico)
pico~type (354 "@src/flow.l" llvm pico)
pico~unify (1608 "@src/subr.l" llvm pico)
pico~unless (626 "@src/flow.l" llvm pico)
pico~until (700 "@src/flow.l" llvm pico)
pico~up (1755 "@src/main.l" llvm pico)
pico~upp? (1847 "@src/sym.l" llvm pico)
pico~uppc (1869 "@src/sym.l" llvm pico)
pico~use (1023 "@src/flow.l" llvm pico)
pico~usec (718 "@src/main.l" llvm pico)
pico~val (857 "@src/sym.l" llvm pico)
pico~version (1813 "@src/main.l" llvm pico)
pico~wait (955 "@src/io.l" llvm pico)
pico~when (618 "@src/flow.l" llvm pico)
pico~while (692 "@src/flow.l" llvm pico)
pico~wipe (1797 "@src/sym.l" llvm pico)
pico~with (869 "@src/flow.l" llvm pico)
pico~wr (2683 "@src/io.l" llvm pico)
pico~xchg (894 "@src/sym.l" llvm pico)
pico~xor (533 "@src/flow.l" llvm pico)
pico~x| (1427 "@src/big.l" llvm pico)
pico~yield (1337 "@src/flow.l" llvm pico)
pico~yoke (318 "@src/subr.l" llvm pico)
pico~zap (735 "@src/sym.l" llvm pico)
pico~zero (932 "@src/sym.l" llvm pico)
pico~| (1414 "@src/big.l" llvm pico)
pil21/lib/net.l0000644000000000000000000001523214632471674010425 0ustar  # 13jun24 Software Lab. Alexander Burger

(sysdefs "errno")
(sysdefs "networking")

(private) (ipErr Var)

(de ipErr (Msg)
   (quit Msg (%@ "strErrno" 'S)) )

# (port ['T] 'cnt|(cnt . cnt) ['var]) -> cnt
(de port (A . @)
   (let
      (Type (ifn (=T A) SOCK_STREAM (setq A (next)) SOCK_DGRAM)
         Sd (%@ "socket" 'I AF_INET6 Type 0) )
      (when (lt0 Sd)
         (ipErr "IP socket") )
      (%@ "closeOnExec" NIL (cons T (up)) Sd)
      ~(as (<> *OS "OpenBSD")
         (when
            (lt0
               (%@ "setsockopt" 'I Sd IPPROTO_IPV6 IPV6_V6ONLY
                  '(NIL (4 . I) (0 . 4))
                  4 ) )
            (ipErr "IPV6_V6ONLY") ) )
      (buf Addr sockaddr_in6
         (%@ "memset" NIL Addr 0 sockaddr_in6)
         (struct (+ Addr sin6_family) NIL (`AF_INET6 . 2))
         (struct (+ Addr sin6_addr) NIL (0 . 8) (0 . 8))  # "::" (16 null-bytes)
         (let Port A
            (cond
               ((num? A)
                  (or
                     (=0 Port)
                     (ge0
                        (%@ "setsockopt" 'I Sd SOL_SOCKET SO_REUSEADDR
                           '(NIL (4 . I) (1 . 4))
                           4 ) )
                     (ipErr "SO_REUSEADDR") ) )
               ((pair A) (setq Port (car A)))
               (T (quit "Bad argument" A)) )
            (loop
               (byte (+ Addr sin6_port) (>> 8 Port))  # Put big-endian (network byte order)
               (byte (+ Addr sin6_port 1) Port)
               (T (ge0 (%@ "bind" 'I Sd Addr sockaddr_in6)))
               (when (or (atom A) (> (inc 'Port) (cdr A)))
                  (close Sd)
                  (ipErr "IP bind") ) )
            (when
               (and
                  (== Type SOCK_STREAM)
                  (lt0 (%@ "listen" 'I Sd 5)) )
               (close Sd)
               (ipErr "IP listen") )
            (let? Var (next)
               (when
                  (lt0
                     (%@ "getsockname" 'I Sd Addr
                        '(NIL (4 . I) (`sockaddr_in6 . 4)) ) )
                  (close Sd)
                  (ipErr "IP getsockname") )
               (set Var
                  (+  # Get big-endian (network byte order)
                     (>> -8 (byte (+ Addr sin6_port)))
                     (byte (+ Addr sin6_port 1)) ) ) ) ) )
      Sd ) )

# (accept 'cnt) -> cnt | NIL
(de accept (Sd)
   (let (Flg (%@ "nonBlocking" 'I Sd)  N 200)
      (buf Addr sockaddr_in6
         (loop
            (T
               (ge0
                  (%@ "accept" 'I Sd Addr
                     '(NIL (4 . I) (`sockaddr_in6 . 4)) ) )
               (let Sd2 @
                  (%@ "fcntlSetFl" 'I Sd Flg)
                  ~(as (member *OS '("OpenBSD" "FreeBSD"))
                     (%@ "fcntlSetFl" 'I Sd2 0) )
                  (buf Str INET6_ADDRSTRLEN
                     (setq *Adr
                        (%@ "inet_ntop" 'S AF_INET6 (+ Addr sin6_addr) Str INET6_ADDRSTRLEN) ) )
                  (setq *SPort
                     (+  # Get big-endian (network byte order)
                        (>> -8 (byte (+ Addr sin6_port)))
                        (byte (+ Addr sin6_port 1)) ) )
                  (%@ "initInFile" NIL Sd2 0)
                  (%@ "initOutFile" NIL Sd2)
                  Sd2 ) )
            (NIL (and (== (errno) EAGAIN) (gt0 (dec 'N)))
               (%@ "fcntlSetFl" NIL Sd Flg) )
            (%@ "usleep" NIL 99999) ) ) ) )

# (listen 'cnt1 ['cnt2]) -> cnt | NIL
(de listen (Sd Ms)
   (loop
      (NIL (wait Ms T Sd))
      (T (accept Sd) @) ) )

# (host 'any) -> sym
(de host (Node)
   (use Lst
      (when (=0 (%@ "getaddrinfo" 'I Node 0 0 '(Lst (8 . P))))
         (buf Host NI_MAXHOST
            (prog1
               (let P Lst
                  (loop
                     (T
                        (=0
                           (%@ "getnameinfo" 'I
                              (struct (+ P ai_addr) 'P)
                              (struct (+ P ai_addrlen) 'I)
                              Host
                              NI_MAXHOST
                              0 0
                              NI_NAMEREQD ) )
                        (struct Host 'S) )
                     (T
                        (=0 (setq P (struct (+ P ai_next) 'P))) ) ) )
               (%@ "freeaddrinfo" 'I Lst) ) ) ) ) )

(private) server

(de server (Type Node Service)
   (use Lst
      (and
         (=0
            (%@ "getaddrinfo" 'I Node (pack Service)
               (cons NIL (`addrinfo)  # hints:
                  (0 . 4)  # ai_flags
                  (`AF_UNSPEC . 4)  # ai_family
                  (cons Type 4)  # ai_socktype
                  0 )  # Clear rest
               '(Lst (8 . P)) ) )
         Lst ) ) )

# (connect 'any1 'any2) -> cnt | NIL
(de connect (Node Port)
   (let? Lst (server SOCK_STREAM Node Port)
      (prog1
         (let (P Lst  Sd)
            (loop
               (T
                  (and
                     (ge0
                        (setq Sd
                           (%@ "socket" 'I
                              (struct (+ P ai_family) 'I)
                              (struct (+ P ai_socktype) 'I)
                              0 ) ) )
                     (or
                        (=0
                           (%@ "connect" 'I Sd
                              (struct (+ P ai_addr) 'P)
                              (struct (+ P ai_addrlen) 'I) ) )
                        (nil (close Sd)) ) )
                  (%@ "closeOnExec" NIL (cons T (up)) Sd)
                  (%@ "initInFile" NIL Sd 0)
                  (%@ "initOutFile" NIL Sd)
                  Sd )
               (T
                  (=0 (setq P (struct (+ P ai_next) 'P))) ) ) )
         (%@ "freeaddrinfo" 'I Lst) ) ) )

(private) UDPMAX

(de UDPMAX . 4096)

# (udp 'cnt) -> any
# (udp 'sym 'any2 'any3) -> any
(de udp (X Port Val)
   (buf Buf UDPMAX
      (cond
         (Port
            (let? Lst (server SOCK_DGRAM X Port)
               (let (P Lst  N (plio Buf UDPMAX Val))
                  (loop
                     (T (=0 P)
                        (%@ "freeaddrinfo" 'I Lst)
                        NIL )
                     (T
                        (ge0
                           (%@ "socket" 'I
                              (struct (+ P ai_family) 'I)
                              (struct (+ P ai_socktype) 'I)
                              0 ) )
                        (%@ "sendto" 'I @ Buf N 0
                           (struct (+ P ai_addr) 'P)
                           (struct (+ P ai_addrlen) 'I) )
                        (close @)
                        (%@ "freeaddrinfo" 'I Lst)
                        Val )
                     (setq P (struct (+ P ai_next) 'P)) ) ) ) )
         ((ge0 (%@ "recv" 'N X Buf UDPMAX 0))
            (plio Buf) ) ) ) )
pil21/lib/misc.l0000644000000000000000000003552214627054317010571 0ustar  # 02jun24 Software Lab. Alexander Burger

# *Allow

(de *Day . (Mon Tue Wed Thu Fri Sat Sun .))
(de *Mon . (Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec .))

### Locale ###
(de *Ctry)
(de *Lang)
(de *Sep0 . ".")
(de *Sep3 . ",")
(de *CtryCode)
(de *NatTrunkPrf)
(de *DateFmt @Y "-" @M "-" @D)
(de *DayFmt "Monday" "Tuesday" "Wednesday" "Thursday" "Friday" "Saturday" "Sunday")
(de *MonFmt "January" "February" "March" "April" "May" "June" "July" "August" "September" "October" "November" "December")

(de locale (Ctry Lang . @)  # "DE" "de" ["app/loc/" ..]
   (load (if (setq *Ctry Ctry) (pack "@loc/" @ ".l") "@loc/NIL.l"))
   (ifn (setq *Lang Lang)
      (for S (idx '*Uni)
         (set S S) )
      (====)
      (let L
         (sort
            (make
               ("loc" (pack "@loc/" Lang))
               (while (args)
                  ("loc" (pack (next) Lang)) ) ) )
         (balance '*Uni L T)
         (for S L
            (set (car (idx '*Uni S)) (val S)) ) )
      (====) ) )

(de "loc" (F)
   (when (info F)
      (in F
         (use X
            (while (setq X (read))
               (if (=T X)
                  ("loc" (read))
                  (set (link @) (name (read))) ) ) ) ) ) )

### String ###
(de wrap (Max X)
   (let R
      (make
         (for (Lst (split (chop X) " " "\n")  Lst)
            (let L (++ Lst)
               (while
                  (and Lst
                     (> Max
                        (+ (length (car Lst)) (sum length L)) ) )
                  (setq L (conc L (list " ") (++ Lst))) )
               (link L) ) ) )
      (if (atom X)
         (mapcar pack R)
         (glue "\n" R) ) ) )

### Number ###
(de money (N Cur)
   (if Cur
      (pack (format N 2 *Sep0 *Sep3) " " Cur)
      (format N 2 *Sep0 *Sep3) ) )

(de round (N D)
   (if (> *Scl (default D 3))
      (format (*/ N (** 10 (- *Scl D))) D *Sep0 *Sep3)
      (format N *Scl *Sep0 *Sep3) ) )

# Binary notation
(de bin (X I)
   (cond
      ((num? X)
         (let (S (and (lt0 X) '-)  L (& 1 X)  A (cons 0 I))
            (until (=0 (setq X (>> 1 X)))
               (at A (push 'L " "))
               (push 'L (& 1 X)) )
            (pack S L) ) )
      ((setq X
            (filter
               '((C) (not (sp? C)))
               (chop X) ) )
         (let (S (and (= '- (car X)) (++ X))  N 0  C)
            (loop
               (NIL (setq C (format (++ X))))
               (NIL (or (=0 C) (=1 C)))
               (setq N (| C (>> -1 N)))
               (NIL X (if S (- N) N)) ) ) ) ) )

# Octal notation
(de oct (X I)
   (cond
      ((num? X)
         (let (S (and (lt0 X) '-)  L (& 7 X)  A (cons 0 I))
            (until (=0 (setq X (>> 3 X)))
               (at A (push 'L " "))
               (push 'L (& 7 X)) )
            (pack S L) ) )
      ((setq X
            (filter
               '((C) (not (sp? C)))
               (chop X) ) )
         (let (S (and (= '- (car X)) (++ X))  N 0  C)
            (loop
               (NIL (setq C (format (++ X))))
               (NIL (>= 7 C 0))
               (setq N (| C (>> -3 N)))
               (NIL X (if S (- N) N)) ) ) ) ) )

# Hexadecimal notation
(de hex (X I)
   (cond
      ((num? X)
         (let (S (and (lt0 X) '-)  L (hex1 X)  A (cons 0 I))
            (until (=0 (setq X (>> 4 X)))
               (at A (push 'L " "))
               (push 'L (hex1 X)) )
            (pack S L) ) )
      ((setq X
            (filter
               '((C) (not (sp? C)))
               (chop X) ) )
         (let (S (and (= '- (car X)) (++ X))  N 0  C)
            (loop
               (NIL
                  (cdr
                     (rank
                        (setq C (char (++ X)))
                        '((48 . 48) (58) (65 . 55) (71) (97 . 87) (103)) ) ) )
               (setq N (| (- C @) (>> -4 N)))
               (NIL X (if S (- N) N)) ) ) ) ) )

(de hex1 (N)
   (let C (& 15 N)
      (and (> C 9) (inc 'C 7))
      (char (+ C `(char "0"))) ) )

# Hexadecimal/Alpha notation
(de hax (X)
   (if (num? X)
      (pack
         (mapcar
            '((C)
               (when (> (setq C (- (char C) `(char "0"))) 9)
                  (dec 'C 7) )
               (char (+ `(char "@") C)) )
            (chop (hex X)) ) )
      (hex
         (mapcar
            '((C)
               (when (> (setq C (- (char C) `(char "@"))) 9)
                  (inc 'C 7) )
               (char (+ `(char "0") C)) )
            (chop X) ) ) ) )

### Tree ###
(de balance ("Var" "Lst" "Flg")
   (unless "Flg" (set "Var"))
   (let "Len" (length "Lst")
      (recur ("Lst" "Len")
         (unless (=0 "Len")
            (let ("N" (>> 1 (inc "Len"))  "L" (nth "Lst" "N"))
               (idx "Var" (car "L") T)
               (recurse "Lst" (dec "N"))
               (recurse (cdr "L") (- "Len" "N")) ) ) ) ) )

(de depth (Idx)  #> (max . average)
   (let (C 0  D 0  N 0)
      (cons
         (recur (Idx N)
            (ifn Idx
               0
               (inc 'C)
               (inc 'D (inc 'N))
               (inc
                  (max
                     (recurse (cadr Idx) N)
                     (recurse (cddr Idx) N) ) ) ) )
         (or (=0 (setq @@ C)) (*/ D C)) ) ) )

### Allow ###
(de allowed Lst
   (setq *Allow (cons NIL (car Lst)))
   (balance *Allow (sort (cdr Lst))) )

(de allow (X Flg)
   (nond
      (*Allow)
      (Flg (idx *Allow X T))
      ((member X (cdr *Allow)) (queue '*Allow X)) )
   X )

### Telephone ###
(de telStr (S)
   (cond
      ((not S))
      ((and *CtryCode (pre? (pack *CtryCode " ") S))
         (pack *NatTrunkPrf (cdr (member " " (chop S)))) )
      (T (pack "+" S)) ) )

(de expTel (S)
   (setq S
      (make
         (for (L (chop S) L)
            (ifn (sub? (car L) " -")
               (link (++ L))
               (let F NIL
                  (loop
                     (and (= '- (++ L)) (on F))
                     (NIL L)
                     (NIL (sub? (car L) " -")
                        (link (if F '- " ")) ) ) ) ) ) ) )
   (cond
      ((= "+" (car S)) (pack (cdr S)))
      ((head '("0" "0") S) (pack (cddr S)))
      (*CtryCode
         (let L *NatTrunkPrf
            (loop
               (NIL L (pack *CtryCode " " S))
               (NIL (= (++ L) (++ S))) ) ) ) ) )

### Date ###
# ISO date
(de $dat (S C)
   (if C
      (and
         (= 3
            (length (setq S (split (chop S) C))) )
         (date
            (format (car S))               # Year
            (or (format (cadr S)) 0)       # Month
            (or (format (caddr S)) 0) ) )  # Day
      (and
         (format S)
         (date
            (/ @ 10000)       # Year
            (% (/ @ 100) 100) # Month
            (% @ 100) ) ) ) )

# Localized
(de datStr (D F)
   (when (setq D (date D))
      (let
         (@Y (if F (pad 2 (% (car D) 100)) (pad 4 (car D)))
            @M (pad 2 (cadr D))
            @D (pad 2 (caddr D)) )
         (pack (fill *DateFmt)) ) ) )

(de strDat (S)
   (use (@Y @M @D)
      (and
         (match *DateFmt (chop S))
         (date
            (format @Y)
            (or (format @M) 0)
            (or (format @D) 0) ) ) ) )

(de expDat (S)
   (cond
      ((= "." S) (date))
      ((or (pre? "+" S) (pre? "-" S)) (+ (date) (format S)))
      (T
         (use (@Y @M @D X)
            (unless (match *DateFmt (setq S (chop S)))
               (if
                  (or
                     (cdr (setq S (split S ".")))
                     (>= 2 (length (car S))) )
                  (setq
                     @D (car S)
                     @M (cadr S)
                     @Y (caddr S) )
                  (setq
                     @D (head 2 (car S))
                     @M (head 2 (nth (car S) 3))
                     @Y (nth (car S) 5) ) ) )
            (and
               (setq @D (format @D))
               (date
                  (nond
                     (@Y (car (date (date))))
                     ((setq X (format @Y)))
                     ((>= X 100)
                        (+ X
                           (* 100 (/ (car (date (date))) 100)) ) )
                     (NIL X) )
                  (nond
                     (@M (cadr (date (date))))
                     ((setq X (format @M)) 0)
                     ((n0 X) (cadr (date (date))))
                     (NIL X) )
                  @D ) ) ) ) ) )

# Day of the week
(de day (Dat Lst)
   (when Dat
      (get
         (or Lst *DayFmt)
         (inc (% (inc Dat) 7)) ) ) )

# Week of the year
(de week (Dat)
   (let W
      (-
         (_week Dat)
         (_week (date (car (date Dat)) 1 4))
         -1 )
      (if (=0 W) 53 W) ) )

(de _week (Dat)
   (/ (- Dat (% (inc Dat) 7)) 7) )

# Last day of month
(de ultimo (Y M)
   (dec
      (if (= 12 M)
         (date (inc Y) 1 1)
         (date Y (inc M) 1) ) ) )

### Time ###
(de $tim (S)
   (setq S (split (chop S) ":"))
   (unless (or (cdr S) (>= 2 (length (car S))))
      (setq S
         (list
            (head 2 (car S))
            (head 2 (nth (car S) 3))
            (nth (car S) 5) ) ) )
   (when (format (car S))
      (time @
         (or (format (cadr S)) 0)
         (or (format (caddr S)) 0) ) ) )

(de stamp (Dat Tim)
   (and (=T Dat) (setq Dat (date T)))
   (default Dat (date)  Tim (time T))
   (pack (dat$ Dat "-") " " (tim$ Tim T)) )

### I/O ###
(de chdir ("Dir" . "Prg")
   (let? "Old" (cd "Dir")
      (finally (cd "Old")
         (run "Prg") ) ) )

(de dirname (F)
   (glue "/"
      (prog1
         (trim (split (chop F) "/"))
         (set (tail 1 @)) ) ) )

(de basename (F)
   (pack (last (trim (split (chop F) "/")))) )

(de ssl ("Host" "Path" . "Prg")
   (in (list "@bin/ssl" "Host" 443 "Path")
      (and
         (tail '`(chop "200 OK") (line))
         (from "\r\n\r\n")
         (run "Prg") ) ) )

(de download (Host Src Dst)
   (let (F (tmp 'download)  Size)
      (in (list "@bin/ssl" Host 443 Src)
         (and
            (tail '`(chop "200 OK") (line))
            (from "Content-Length:")
            (setq Size (format (till "\r\n")))
            (from "\r\n\r\n")
            (out F (echo))
            (= Size (car (info F)))
            (=0 (%@ "rename" 'I F Dst)) ) ) ) )

# Echo here-documents
(de here (S)
   (skip)
   (echo S) )

# Print or eval
(de prEval ("Prg" "Ofs")
   (default "Ofs" 1)
   (for "X" "Prg"
      (if (atom "X")
         (prinl (eval "X" "Ofs"))
         (eval "X" "Ofs") ) ) )

# Replace single LF with CR/LF
(de nlCrnl "Prg"
   (output
      (cond
         ((= "\n" @@)
            (prin "\r\n") )
         ((nand (= "\n" @@@) (= "\r" @@))
            (prin @@) ) )
      (run "Prg") ) )

# Multiline Base64
(de prBase64 (N C)
   (while
      (do N
         (NIL (ext:Base64 (rd 1) (rd 1) (rd 1)))
         T )
      (prinl C) ) )

# Send mail
(de mail (Host Port From To Sub Att . Prg)
   (let? S
      (if (pair Port)
         (pipe (exec "@bin/ssl" Host (fin Port)))
         (connect Host Port) )
      (let B (pack "==" (date) "-" (time T) "-" (usec) "==")
         (prog1
            (and
               (pre? "220 " (in S (line T)))
               (out S (prinl "HELO " (cdr (member "@" (chop (fin From)))) "\r"))
               (pre? "250 " (in S (line T)))
               (or
                  (atom Port)
                  (and
                     (out S
                        (prin "AUTH PLAIN ")
                        (pipe
                           (prog
                              (prin (car Port))
                              (wr 0)
                              (prin (car Port))
                              (wr 0)
                              (prin (cadr Port)) )
                           (prBase64 T "\r") )
                        (prinl "\r") )
                     (pre? "235 " (in S (line T))) ) )
               (out S (prinl "MAIL FROM:<" (fin From) ">\r"))
               (pre? "250 " (in S (line T)))
               (if (atom To)
                  (_rcpt To)
                  (find bool (mapcar _rcpt To)) )
               (out S (prinl "DATA\r"))
               (pre? "354 " (in S (line T)))
               (out S
                  (prinl "From: " (fin From) "\r")
                  (prinl "To: " (or (fin To) (glue "," To)) "\r")
                  (prin "Subject: ")
                  (ifn (find > (chop Sub) '("~" .))
                     (prinl Sub "\r")
                     (prin "=?utf-8?B?")
                     (pipe (prin Sub) (prBase64 T "\r"))
                     (prinl "?=\r") )
                  (when (pair From)
                     (prinl "Reply-To: " (car From) "\r") )
                  (prinl "User-Agent: PicoLisp\r")
                  (prinl "MIME-Version: 1.0\r")
                  (when Att
                     (prinl "Content-Type: multipart/mixed; boundary=\"" B "\"\r")
                     (prinl "\r")
                     (prinl "--" B "\r")
                     (unless (cadr Att)
                        (prinl "Content-Type: multipart/alternative; boundary=\"==" B "==\"\r")
                        (prinl "\r")
                        (prinl "--==" B "==\r") ) )
                  (prinl "Content-Type: text/plain; charset=utf-8\r")
                  (prinl "Content-Transfer-Encoding: 8bit\r")
                  (prinl "\r")
                  (nlCrnl (prEval Prg 2))
                  (prinl "\r")
                  (when Att
                     (loop
                        (if (cadr Att)
                           (prinl "--" B "\r")
                           (prinl "--==" B "==\r") )
                        (prin "Content-Type: " (or (caddr Att) "application/octet-stream"))
                        (and (cadr Att) (prin "; name=\"" @ "\""))
                        (prinl "\r")
                        (prinl
                           "Content-Transfer-Encoding: "
                           (if (cadr Att) "base64" "8bit")
                           "\r" )
                        (prinl "\r")
                        (in (car Att)
                           (ifn (cadr Att)
                              (nlCrnl (echo))
                              (prBase64 18 "\r")
                              (prinl "\r") ) )
                        (prinl "\r")
                        (unless (cadr Att)
                           (prinl "--==" B "==--\r")
                           (prinl "\r") )
                        (NIL (setq Att (cdddr Att))) )
                     (prinl "--" B "--\r") )
                  (prinl ".\r") )
               (pre? "250 " (in S (line T)))
               (out S (prinl "QUIT\r"))
               (pre? "221 " (in S (line T)))
               T )
            (close S) ) ) ) )

(de _rcpt (To)
   (out S (prinl "RCPT TO:<" To ">\r"))
   (pre? "250 " (in S (line T))) )

### Debug ###
`*Dbg

# Hex Dump
(de hd (File Cnt)
   (in File
      (let Pos 0
         (while
            (and
               (nand Cnt (lt0 (dec 'Cnt)))
               (make (do 16 (and (rd 1) (link @)))) )
            (let L @
               (prin (pad 8 (hex Pos)) "  ")
               (inc 'Pos 16)
               (for N L
                  (prin (pad 2 (hex N)) " ") )
               (space (inc (* 3 (- 16 (length L)))))
               (for N L
                  (prin (if (>= 126 N 32) (char N) ".")) )
               (prinl) ) ) ) ) )
pil21/lib/btree.l0000644000000000000000000003731713741547532010745 0ustar  # 14oct20 Software Lab. Alexander Burger

# *Prune

(private) (_store _put _splitBt _del)

(de root (Tree)
   (cond
      ((not Tree) (val *DB))
      ((atom Tree) (val Tree))
      ((ext? (cdr Tree)) (get @ (car Tree)))
      ((atom (cdr Tree))
         (get *DB (cdr Tree) (car Tree)) )
      (T (get (cddr Tree) (cadr Tree) (car Tree))) ) )

# Fetch
(de fetch (Tree Key)
   (let? Node (cdr (root Tree))
      (and *Prune (idx '*Prune Node T))
      (use R
         (loop
            (and *Prune (set (prop Node NIL) 0))
            (T
               (and
                  (setq R (rank Key (cdr (val Node))))
                  (= Key (car R)) )
               (or (cddr R) (fin (car R))) )
            (NIL
               (setq Node (if R (cadr R) (car (val Node)))) ) ) ) ) )

# Store
(de store (Tree Key Val Dbf)
   (default Dbf (1 . 256))
   (if (atom Tree)
      (let Base (or Tree *DB)
         (_store (or (val Base) (set Base (cons 0)))) )
      (let Base
         (if (atom (cdr Tree))
            (or
               (ext? (cdr Tree))
               (get *DB (cdr Tree))
               (put *DB (cdr Tree) (new T 0)) )
            (or
               (get (cddr Tree) (cadr Tree))
               (put (cddr Tree) (cadr Tree) (new T)) ) )
         (_store
            (or
               (get Base (car Tree))
               (put Base (car Tree) (cons 0)) ) ) ) ) )

(de _store (Root)
   (and *Prune (cdr Root) (idx '*Prune @ T))
   (ifn Val
      (when (and (cdr Root) (_del @))
         (touch Base)
         (cond
            (*Solo (zap (cdr Root)))
            (*Zap (push @ (cdr Root))) )
         (con Root) )
      (and (= Val (fin Key)) (off Val))
      (if (cdr Root)
         (when (_put @)
            (touch Base)
            (con Root (def (new (car Dbf)) (list (car @) (cdr @)))) )
         (touch Base)
         (con Root
            (def (new (car Dbf))
               (list NIL (cons Key NIL Val)) ) )
         (and *Prune (set (prop (cdr Root) NIL) 0))
         (inc Root) ) ) )

(de _put (Top)
   (and *Prune (set (prop Top NIL) 0))
   (let (V (val Top)  R (rank Key (cdr V)))
      (cond
         (R
            (if (= Key (car R))
               (nil (touch Top) (con (cdr R) Val))
               (let X (memq R V)
                  (if (cadr R)
                     (when (_put @)
                        (touch Top)
                        (set (cdr R) (car @))
                        (con X (cons (cdr @) (cdr X)))
                        (_splitBt) )
                     (touch Top)
                     (con X
                        (cons (cons Key (cons NIL Val)) (cdr X)) )
                     (touch Base)
                     (inc Root)
                     (_splitBt) ) ) ) )
         ((car V)
            (when (_put @)
               (touch Top)
               (set V (car @))
               (con V (cons (cdr @) (cdr V)))
               (_splitBt) ) )
         (T
            (touch Top)
            (con V
               (cons (cons Key (cons NIL Val)) (cdr V)) )
            (touch Base)
            (inc Root)
            (_splitBt) ) ) ) )

(de _splitBt ()
   (when (and (cddddr V) (> (size Top) (cdr Dbf)))
      (let (N (>> 1 (length V))  X (get V (inc N)))
         (set (cdr X)
            (def (new (car Dbf))
               (cons (cadr X) (nth V (+ 2 N))) ) )
         (cons
            (if *Solo
               (prog (set Top (head N V)) Top)
               (and *Zap (push @ Top))
               (def (new (car Dbf)) (head N V)) )
            X ) ) ) )

# Del
(de _del (Top)
   (and *Prune (set (prop Top NIL) 0))
   (let (V (val Top)  R (rank Key (cdr V)))
      (cond
         ((not R)
            (when (and (car V) (_del @))
               (touch Top)
               (cond
                  (*Solo (zap (car V)))
                  (*Zap (push @ (car V))) )
               (set V)
               (not (cdr V)) ) )
         ((= Key (car R))
            (if (cadr R)
               (let X (val @)
                  (while (car X) (setq X (val @)))
                  (touch Top)
                  (xchg R (cadr X))
                  (con (cdr R) (cddr (cadr X)))
                  (when (_del (cadr R))
                     (cond
                        (*Solo (zap (cadr R)))
                        (*Zap (push @ (cadr R))) )
                     (set (cdr R)) ) )
               (touch Base)
               (dec Root)
               (nand
                  (or
                     (con V (delq R (cdr V)))
                     (car V) )
                  (touch Top) ) ) )
         ((cadr R)
            (when (_del @)
               (touch Top)
               (cond
                  (*Solo (zap (cadr R)))
                  (*Zap (push @ (cadr R))) )
               (set (cdr R)) ) ) ) ) )


# Delayed deletion
(de zap_ ()
   (let (F (cdr *Zap)  Z (pack F "_"))
      (cond
         ((info Z)
            (in Z (while (rd) (zap @)))
            (if (info F)
               (call "mv" F Z)
               (%@ "unlink" NIL Z) ) )
         ((info F) (call "mv" F Z)) ) ) )

# Tree node count
(de count (Tree)
   (or (car (root Tree)) 0) )

# Return first leaf
(de leaf (Tree)
   (let (Node (cdr (root Tree))  X)
      (while (val Node)
         (setq X (cadr @)  Node (car @)) )
      (cddr X) ) )

(private) revNode

# Reverse node
(de revNode (Node)
   (let? Lst (val Node)
      (let (L (car Lst)  R)
         (for X (cdr Lst)
            (push 'R (cons (car X) L (cddr X)))
            (setq L (cadr X)) )
         (cons L R) ) ) )

# Key management
(de minKey (Tree Min Max)
   (default Max T)
   (let (Node (cdr (root Tree))  K)
      (use (V R X)
         (loop
            (NIL (setq V (val Node)) K)
            (T
               (and
                  (setq R (rank Min (cdr V)))
                  (= Min (car R)) )
               Min )
            (if R
               (prog
                  (and
                     (setq X (cdr (memq R V)))
                     (>= Max (caar X))
                     (setq K (caar X)) )
                  (setq Node (cadr R)) )
               (when (>= Max (caadr V))
                  (setq K (caadr V)) )
               (setq Node (car V)) ) ) ) ) )

(de maxKey (Tree Min Max)
   (default Max T)
   (let (Node (cdr (root Tree))  K)
      (use (V R X)
         (loop
            (NIL (setq V (revNode Node)) K)
            (T
               (and
                  (setq R (rank Max (cdr V) T))
                  (= Max (car R)) )
               Max )
            (if R
               (prog
                  (and
                     (setq X (cdr (memq R V)))
                     (>= (caar X) Min)
                     (setq K (caar X)) )
                  (setq Node (cadr R)) )
               (when (>= (caadr V) Min)
                  (setq K (caadr V)) )
               (setq Node (car V)) ) ) ) ) )

# Step
(de init (Tree Beg End)
   (or Beg End (on End))
   (let (Node (cdr (root Tree))  Q)
      (use (V R X)
         (if (>= End Beg)
            (loop
               (NIL (setq V (val Node)))
               (T
                  (and
                     (setq R (rank Beg (cdr V)))
                     (= Beg (car R)) )
                  (push 'Q (memq R V)) )
               (if R
                  (prog
                     (and
                        (setq X (cdr (memq R V)))
                        (>= End (caar X))
                        (push 'Q X) )
                     (setq Node (cadr R)) )
                  (and
                     (cdr V)
                     (>= End (caadr V))
                     (push 'Q (cdr V)) )
                  (setq Node (car V)) ) )
            (loop
               (NIL (setq V (revNode Node)))
               (T
                  (and
                     (setq R (rank Beg (cdr V) T))
                     (= Beg (car R)) )
                  (push 'Q (memq R V)) )
               (if R
                  (prog
                     (and
                        (setq X (cdr (memq R V)))
                        (>= (caar X) End)
                        (push 'Q X) )
                     (setq Node (cadr R)) )
                  (and
                     (cdr V)
                     (>= (caadr V) End)
                     (push 'Q (cdr V)) )
                  (setq Node (car V)) ) ) ) )
      (cons (cons (cons Beg End) Q)) ) )

(de step (Q Flg)
   (use (L F X)
      (catch NIL
         (loop
            (until (cdar Q)
               (or (cdr Q) (throw))
               (set Q (cadr Q))
               (con Q (cddr Q)) )
            (setq
               L (car Q)
               F (>= (cdar L) (caar L))
               X (pop (cdr L)) )
            (or (cadr L) (con L (cddr L)))
            (if ((if F > <) (car X) (cdar L))
               (con (car Q))
               (for (V (cadr X) ((if F val revNode) V) (car @))
                  (con L (cons (cdr @) (cdr L))) )
               (unless (and Flg (flg? (fin (car X))))
                  (when (cddr X)
                     (setq @@ (car X))
                     (throw NIL @) )
                  (setq @@ (caar X))
                  (throw NIL (fin (car X))) ) ) ) ) ) )

(private) (_scan _nacs _iter _reti)
(private) (Tree Fun Beg End Flg Node R X V)

# Scan tree nodes
(de scan (Tree Fun Beg End Flg)
   (default Fun println)
   (or Beg End (on End))
   (let Node (cdr (root Tree))
      ((if (>= End Beg) _scan _nacs) Node) ) )

(de _scan (Node)
   (let? V (val Node)
      (for X
         (if (rank Beg (cdr V))
            (let R @
               (if (= Beg (car R))
                  (memq R (cdr V))
                  (_scan (cadr R))
                  (cdr (memq R (cdr V))) ) )
            (_scan (car V))
            (cdr V) )
         (T (> (car X) End))
         (unless (and Flg (flg? (fin (car X))))
            (Fun
               (car X)
               (or (cddr X) (fin (car X))) ) )
         (_scan (cadr X)) ) ) )

(de _nacs (Node)
   (let? V (revNode Node)
      (for X
         (if (rank Beg (cdr V) T)
            (let R @
               (if (= Beg (car R))
                  (memq R (cdr V))
                  (_nacs (cadr R))
                  (cdr (memq R (cdr V))) ) )
            (_nacs (car V))
            (cdr V) )
         (T (> End (car X)))
         (unless (and Flg (flg? (fin (car X))))
            (Fun
               (car X)
               (or (cddr X) (fin (car X))) ) )
         (_nacs (cadr X)) ) ) )

# Iterate tree values
(de iter (Tree Fun Beg End Flg)
   (default Fun println)
   (or Beg End (on End))
   (let Node (cdr (root Tree))
      ((if (>= End Beg) _iter _reti) Node) ) )

(de _iter (Node)
   (let? V (val Node)
      (for X
         (if (rank Beg (cdr V))
            (let R @
               (if (= Beg (car R))
                  (memq R (cdr V))
                  (_iter (cadr R))
                  (cdr (memq R (cdr V))) ) )
            (_iter (car V))
            (cdr V) )
         (T (> (car X) End))
         (unless (and Flg (flg? (fin (car X))))
            (Fun (or (cddr X) (fin (car X)))) )
         (_iter (cadr X)) ) ) )

(de _reti (Node)
   (let? V (revNode Node)
      (for X
         (if (rank Beg (cdr V) T)
            (let R @
               (if (= Beg (car R))
                  (memq R (cdr V))
                  (_reti (cadr R))
                  (cdr (memq R (cdr V))) ) )
            (_reti (car V))
            (cdr V) )
         (T (> End (car X)))
         (unless (and Flg (flg? (fin (car X))))
            (Fun (or (cddr X) (fin (car X)))) )
         (_reti (cadr X)) ) ) )

# UB-Trees
(de ub>= (Dim End Val Beg)
   (let (D (>> (- 1 Dim) 1)  Pat D)
      (while (> End Pat)
         (setq Pat (| D (>> (- Dim) Pat))) )
      (do Dim
         (NIL
            (>=
               (& Pat End)
               (& Pat Val)
               (& Pat Beg) ) )
         (setq Pat (>> 1 Pat)) ) ) )

(private) (Tree Dim Fun X1 X2 Node Lst Left Beg End B E X Msb Pat N Min Max Lo Hi)

(de ubIter (Tree Dim Fun X1 X2)
   (let
      (Node (cdr (root Tree))
         Lst (val Node)
         Left (++ Lst)
         Beg (ubZval (copy X1))
         End (ubZval (copy X2) T)
         B (car Beg)
         E (car End) )
      (recur (Left Lst Beg End  X)
         (while (setq X (++ Lst))
            (cond
               ((> (car X) End)
                  (setq Lst (; Left 0 -1)  Left (; Left 0 1)) )
               ((> Beg (car X))
                  (if Lst
                     (setq Left (cadr X))
                     (setq Left (; X 2 0 1)  Lst (; X 2 0 -1)) ) )
               ((ub>= Dim E (caar X) B)
                  (Fun (cdar X))
                  (recurse (; Left 0 1) (; Left 0 -1) Beg (car X))
                  (setq Beg (car X))
                  (if Lst
                     (setq Left (cadr X))
                     (setq Left (; X 2 0 1)  Lst (; X 2 0 -1)) ) )
               (T
                  (let (Msb 1  Pat 0  N 0  Min B  Max E  Lo (caar X)  Hi Lo)
                     (while (>= Max Msb)
                        (setq Msb (>> -1 Msb)  Pat (>> -1 Pat))  # Msb 100000000
                        (when (= Dim (inc 'N))                           # Pat 000100100
                           (inc 'Pat)
                           (zero N) ) )
                     (catch "ub"                                    # Clr 111..111011011
                        (let (Top Msb   Clr (| Top (x| Pat (dec Msb))))
                           (loop
                              (T (=0 (setq Msb (>> 1 Msb))))
                              (setq
                                 Pat (>> 1 Pat)
                                 Clr (| Top (>> 1 Clr)) )
                              (ifn (bit? Msb (caar X))
                                 (when (bit? Msb Max)
                                    (ifn (bit? Msb Min)  # 001
                                       (setq
                                          Max (- (| Pat Max) Msb)  # 0111(Max)
                                          Lo (| Msb (& Min Clr)) )   # 1000(Min)
                                       (setq Lo Min)     # 011
                                       (throw "ub") ) )
                                 (unless (bit? Msb Min)
                                    (if (bit? Msb Max)   # 101
                                       (setq
                                          Hi (- (| Pat Max) Msb)   # 0111(Max)
                                          Min (| Msb (& Min Clr)) )  # 1000(Min)
                                       (setq Hi Max)     # 100
                                       (throw "ub") ) ) ) ) ) )
                     (recurse (; Left 0 1) (; Left 0 -1) Beg (cons Hi T))
                     (setq Beg (cons Lo))
                     (if Lst
                        (setq Left (cadr X))
                        (setq Left (; X 2 0 1)  Lst (; X 2 0 -1)) ) ) ) ) ) ) ) )

(de prune (N)
   (for Node (idx '*Prune)
      (recur (Node)
         (let? V (val (lieu Node))
            (if (>= (inc (prop Node NIL)) N)
               (wipe Node)
               (recurse (car V))
               (for X (cdr V)
                  (recurse (cadr X)) ) ) ) ) )
   (or (gt0 N) (setq *Prune N)) )

# Delete Tree
(de zapTree (Node)
   (let? V (val Node)
      (zapTree (car V))
      (for L (cdr V)
         (zapTree (cadr L)) )
      (zap Node) ) )

(private) (Node Fun N L V X Y)

# Check tree structure
(de chkTree (Node Fun)
   (let (N 0  X)
      (when Node
         (recur (Node)
            (let V (val Node)
               (let L (car V)
                  (for Y (cdr V)
                     (when L
                        (unless (ext? L)
                           (quit "Bad node link" Node) )
                        (recurse L) )
                     (when (>= X (car Y))
                        (quit "Bad sequence" Node) )
                     (setq X (car Y))
                     (inc 'N)
                     (and
                        Fun
                        (not (Fun (car Y) (cddr Y)))
                        (quit "Check fail" Node) )
                     (setq L (cadr Y)) )
                  (and L (recurse L)) ) )
            (wipe Node) ) )
      N ) )
pil21/lib/db.l0000644000000000000000000013770714770302213010221 0ustar  # 24mar25 Software Lab. Alexander Burger

# *Jnl *Blob

### Tree Access ###
(de tree (Var Cls Hook)
   (cons Var
      (if Hook
         (cons Cls Hook)
         Cls ) ) )

(de genKey (Var Cls Hook Min Max)
   (if (lt0 Max)
      (let K (minKey (tree Var Cls Hook) Min Max)
         (if (lt0 K) (dec K) (or Max -1)) )
      (let K (maxKey (tree Var Cls Hook) Min Max)
         (if (gt0 K) (inc K) (or Min 1)) ) ) )

(de useKey (Var Cls Hook)
   (let (Tree (tree Var Cls Hook)  Max (* 2 (inc (count Tree)))  N)
      (while (fetch Tree (setq N (rand 1 Max))))
      N ) )

(de genStrKey (Str Var Cls Hook)
   (while (fetch (tree Var Cls Hook) Str)
      (setq Str (pack "# " Str)) )
   Str )

(de ubZval (Lst X)
   (let (Res 0  P 1  Q 1)
      (while (find '((N) (>= N Q)) Lst)
         (for N Lst
            (and
               N
               (bit? Q N)
               (setq Res (| Res P)) )
            (setq P (>> -1 P)) )
         (setq Q (>> -1 Q)) )
      (cons Res X) ) )


### Relations ###
(class +relation)

(dm T (Var)
   (=: cls *Class)
   (=: var Var) )

# Type check
(dm mis> (Val Obj))  #> lst
(dm ele> (Val))

# Value present?
(dm has> (Val X)  #> flg
   (= Val X) )

# Set value
(dm put> (Obj Old New)
   New )

# Delete value
(dm del> (Obj Old Val)
   (and (<> Old Val) Val) )

# Maintain relations
(dm rel> (Obj Old New))

(dm rel?> (Obj Val)
   T )

(dm lose> (Obj Val))

(dm keep> (Obj Val))

# Search
(dm iter> (X Lst)
   (cons
      (list (: cls Dbf 1))
      (let @Cls (: cls)
         (curry (@Cls) (P)
            (loop
               (NIL (and (car P) (set P (seq (car P)))))
               (T (and (isa '@Cls @) (not (; @ T)))
                  (car P) ) ) ) ) ) )

(dm match> (X Val Obj)
   (cond
      ((not X) Val)
      ((str? X) (pre? X Val))
      ((atom X) (and (= X Val) Val))
      ((>= (cdr X) (car X))
         (and (>= (cdr X) Val (car X)) Val) )
      ((>= (car X) Val (cdr X)) Val) ) )

# Finalizer
(dm zap> (Obj Val))


(class +Any +relation)

# (+Bag) (cls ..) (..) (..)
(class +Bag +relation)

(dm T (Var Lst)
   (=: bag
      (mapcar
         '((L)
            (prog1
               (new (car L) Var (cdr L))
               (and (get @ 'hook) (=: hook T)) ) )
         Lst ) )
   (super Var) )

(dm mis> (Val Obj)
   (ifn (lst? Val)
      "Not a Bag"
      (pick
         '((This V)
            (mis> This V Obj
               (when (: hook)
                  (get (if (sym? @) Obj Val) (: hook)) ) ) )
         (: bag)
         Val ) ) )

(dm ele> (Val)
   (and Val
      (or
         (atom Val)
         (find 'ele> (: bag) Val) ) ) )

(dm has> (Val X)
   (when Val
      (if (atom Val)
         (find 'has> (: bag) Val X)
         (fully 'has> (: bag) Val X) ) ) )

(dm put> (Obj Old New)
   (trim
      (mapcar
         '((X O N) (put> X Obj O N))
         (: bag)
         Old
         New ) ) )

(dm rel> (Obj Old New)
   (when Old
      (mapc
         '((This O)
            (rel> This Obj O NIL
               (when (: hook)
                  (get (if (sym? @) Obj Old) (: hook)) ) ) )
         (: bag)
         Old ) )
   (when New
      (mapc
         '((This N)
            (rel> This Obj NIL N
               (when (: hook)
                  (get (if (sym? @) Obj New) (: hook)) ) ) )
         (: bag)
         New ) ) )

(dm rel?> (Obj Val)
   (fully
      '((This V)
         (or
            (not V)
            (rel?> This Obj V
               (when (: hook)
                  (get (if (sym? @) Obj Val) (: hook)) ) ) ) )
      (: bag)
      Val ) )

(dm lose> (Obj Val)
   (mapc
      '((This V)
         (lose> This Obj V
            (when (: hook)
               (get (if (sym? @) Obj Val) (: hook)) ) ) )
      (: bag)
      Val ) )

(dm keep> (Obj Val)
   (mapc
      '((This V)
         (keep> This Obj V
            (when (: hook)
               (get (if (sym? @) Obj Val) (: hook)) ) ) )
      (: bag)
      Val ) )

(dm iter> (X Lst)
   (if
      (find
         '((B) (isa '+index B))
         (: bag) )
      (iter> @ X Lst)
      (super X Lst) ) )

(dm match> (X Val Obj)
   (pick 'match> (: bag)
      (circ X)
      Val
      (circ Obj) ) )


(class +Bool +relation)

(dm mis> (Val Obj)
   (and Val (nT Val) ,"Boolean input expected") )


# (+Number) [num]
(class +Number +relation)

(dm T (Var Lst)
   (=: scl (car Lst))
   (super Var) )

(dm mis> (Val Obj)
   (and Val (not (num? Val)) ,"Numeric input expected") )


# (+Date)
(class +Date +Number)

(dm T (Var Lst)
   (super Var (cons NIL Lst)) )


# (+Time)
(class +Time +Number)

(dm T (Var Lst)
   (super Var (cons NIL Lst)) )


# (+Symbol)
(class +Symbol +relation)

(dm mis> (Val Obj)
   (unless (sym? Val)
      ,"Symbolic type expected" ) )


# (+String)
(class +String +Symbol)

(dm mis> (Val Obj)
   (and Val (not (str? Val)) ,"String type expected") )


(private) canQuery

# (+Link) typ
(class +Link +relation)

(dm T (Var Lst)
   (unless (=: type (car Lst))
      (quit "No Link" Var) )
   (super Var) )

(de canQuery (Val)
   (and
      (pair Val)
      (pair (car Val))
      (fully
         '((L)
            (find
               '((Cls)
                  (get Cls
                     ((if (lst? (car L)) cadr car) L) ) )
               (: type) ) )
         Val ) ) )

(dm mis> (Val Obj)
   (and
      Val
      (nor
         (isa (: type) Val)
         (canQuery Val) )
      ,"Type error" ) )


# (+Joint) var typ [put get]
(class +Joint +Link)

(dm T (Var Lst)
   (=: slot (car Lst))
   (=: put (caddr Lst))
   (=: get (cadddr Lst))
   (super Var (cdr Lst)) )

(dm mis> (Val Obj)
   (and
      Val
      (nor
         (canQuery Val)
         (and
            (isa (: type) Val)
            (with (meta Val (: slot))
               (or
                  (isa '+Link This)
                  (find
                     '((B) (isa '+Link B))
                     (: bag) ) ) ) ) )
      ,"Type error" ) )

(dm rel> (Obj Old New)
   (and Old
      (del> Old (: slot)
         (if (: get)
            (@ Obj (get Old (: slot)))
            Obj ) ) )
   (and New
      (not (get Obj T))
      (not (has> New (: slot) Obj))
      (put> New (: slot)
         (if (: put) (@ Obj) Obj) ) ) )

(dm rel?> (Obj Val)
   (let X (get Val (: slot))
      (cond
         ((atom X) (== Obj X))
         ((: get) (@ Obj X))
         (T (memq Obj X)) ) ) )

(dm lose> (Obj Val)
   (when Val
      (put Val (: slot)
         (del> (meta Val (: slot))
            Obj
            (get Val (: slot))
            (if (: put) (@ Obj) Obj) ) ) ) )

(dm keep> (Obj Val)
   (when Val
      (put Val (: slot)
         (put> (meta Val (: slot))
            Obj
            (get Val (: slot))
            (if (: put) (@ Obj) Obj) ) ) ) )


# +Link or +Joint prefix
(class +Hook)

(dm rel> (Obj Old New Hook)
   (let L
      (extract
         '((X)
            (and (atom X) (setq X (cons T X)))
            (and
               (or
                  (== (: var) (meta Obj (cdr X) 'hook))
                  (find
                     '((B) (== (: var) (get B 'hook)))
                     (meta Obj (cdr X) 'bag) ) )
               X ) )
         (getl Obj) )
      (for X L
         (rel> (meta Obj (cdr X)) Obj (car X) NIL (or Old *DB))
         (rel> (meta Obj (cdr X)) Obj NIL (car X) (or New *DB)) ) )
   (extra Obj Old New Hook) )


# +Index prefix
(class +Hook2)

(dm rel> (Obj Old New Hook)
   (extra Obj Old New *DB)
   (when (or (and Hook (n== Hook *DB)) (and (: hook) (get Obj @)))
      (extra Obj Old New Hook) ) )

(dm lose> (Obj Val Hook)
   (extra Obj Val *DB)
   (when (or (and Hook (n== Hook *DB)) (and (: hook) (get Obj @)))
      (extra Obj Val Hook) ) )

(dm keep> (Obj Val Hook)
   (extra Obj Val *DB)
   (when (or (and Hook (n== Hook *DB)) (and (: hook) (get Obj @)))
      (extra Obj Val Hook) ) )


# (+Blob)
(class +Blob +relation)

(de blob (Obj Var)
   (pack *Blob (glue "/" (chop Obj)) "." Var) )

(dm put> (Obj Old New)
   (and
      New
      (dirname (blob Obj))
      (call "mkdir" "-p" @) )
   (if (flg? New)
      New
      (in New (out (blob Obj (: var)) (echo)))
      T ) )

(dm zap> (Obj Val)
   (and Val (%@ "unlink" NIL (blob Obj (: var)))) )


### Index classes ###
(private) (idxRel? relAux)

(class +index)

(dm T (Var Lst)
   (=: hook (car Lst))
   (extra Var (cdr Lst)) )

(dm rel?> (Obj Val Hook))


# (+Key +relation) [hook]
(class +Key +index)

(dm mis> (Val Obj Hook)
   (or
      (extra Val Obj Hook)
      (and
         Val
         (not (has> Obj (: var) Val))
         (fetch
            (tree (: var) (: cls) (or Hook (and (: hook) (get Obj @))))
            Val )
         ,"Not unique" ) ) )

(dm rel> (Obj Old New Hook)
   (let Tree (tree (: var) (: cls) (or Hook (and (: hook) (get Obj @))))
      (and Old
         (= Obj (fetch Tree Old))
         (store Tree Old NIL (: dbf)) )
      (and New
         (not (get Obj T))
         (not (fetch Tree New))
         (store Tree New Obj (: dbf)) ) )
   (extra Obj Old New Hook) )

(dm rel?> (Obj Val Hook)
   (== Obj
      (fetch
         (tree (: var) (: cls) (or Hook (and (: hook) (get Obj @))))
         Val ) ) )

(dm lose> (Obj Val Hook)
   (store
      (tree (: var) (: cls) (or Hook (and (: hook) (get Obj @))))
      Val NIL (: dbf) )
   (extra Obj Val Hook) )

(dm keep> (Obj Val Hook)
   (store
      (tree (: var) (: cls) (or Hook (and (: hook) (get Obj @))))
      Val Obj (: dbf) )
   (extra Obj Val Hook) )

(dm iter> (X Lst)
   (let Tree (tree (: var) (: cls) (caddr Lst))
      (cons
         (nond
            ((atom X)
               (nond
                  ((str? (car X))
                     (init Tree (car X) (cdr X)) )
                  ((>= (cdr X) (car X))
                     (init Tree (pack (car X) `(char T)) (cdr X)) )
                  (NIL
                     (init Tree (car X) (pack (cdr X) `(char T))) ) ) )
            ((str? X) (init Tree X X))
            (NIL (init Tree X (pack X `(char T)))) )
         (let @Cls (cadr Lst)
            (curry (@Cls) (Q)
               (loop
                  (NIL (step Q))
                  (T (isa '@Cls @) @) ) ) ) ) ) )


# (+Ref +relation) [hook]
(class +Ref +index)

(dm rel> (Obj Old New Hook)
   (let
      (Tree (tree (: var) (: cls) (or Hook (and (: hook) (get Obj @))))
         Aux (mapcar '((S) (get Obj S)) (: aux)) )
      (when Old
         (let Key (cons Old Aux)
            (store Tree
               (if (: ub)
                  (ubZval Key Obj)
                  (append Key Obj) )
               NIL
               (: dbf) ) ) )
      (and New
         (not (get Obj T))
         (let Key (cons New Aux)
            (store Tree
               (if (: ub)
                  (ubZval Key Obj)
                  (conc Key Obj) )
               Obj
               (: dbf) ) ) ) )
   (extra Obj Old New Hook) )

(dm rel?> (Obj Val Hook)
   (let Key (cons Val (mapcar '((S) (get Obj S)) (: aux)))
      (== Obj
         (fetch
            (tree (: var) (: cls) (or Hook (and (: hook) (get Obj @))))
            (if (: ub)
               (ubZval Key Obj)
               (append Key Obj) ) ) ) ) )

(dm lose> (Obj Val Hook)
   (let Key (cons Val (mapcar '((S) (get Obj S)) (: aux)))
      (store
         (tree (: var) (: cls) (or Hook (and (: hook) (get Obj @))))
         (if (: ub)
            (ubZval Key Obj)
            (conc Key Obj) )
         NIL
         (: dbf) ) )
   (extra Obj Val Hook) )

(dm keep> (Obj Val Hook)
   (let Key (cons Val (mapcar '((S) (get Obj S)) (: aux)))
      (store
         (tree (: var) (: cls) (or Hook (and (: hook) (get Obj @))))
         (if (: ub)
            (ubZval Key Obj)
            (conc Key Obj) )
         Obj
         (: dbf) ) )
   (extra Obj Val Hook) )

(dm iter> (X Lst @Flg)
   (let Tree (tree (: var) (: cls) (caddr Lst))
      (cons
         (nond
            (X (init Tree NIL T))
            ((atom X)
               (nond
                  ((str? (car X))
                     (if (>= (cdr X) (car X))
                        (init Tree
                           (cons (car X))
                           (cons (cdr X) T) )
                        (init Tree
                           (cons (car X) T)
                           (cons (cdr X)) ) ) )
                  ((>= (cdr X) (car X))
                     (init Tree
                        (cons (pack (car X) `(char T)) T)
                        (cons (cdr X)) ) )
                  (NIL
                     (init Tree
                        (cons (car X))
                        (cons (pack (cdr X) `(char T)) T) ) ) ) )
            ((str? X)
               (init Tree (cons X) (cons X T)) )
            (NIL
               (init Tree (cons X) (cons (pack X `(char T)) T)) ) )
         (let @Cls (cadr Lst)
            (curry (@Flg @Cls) (Q)
               (loop
                  (NIL (step Q @Flg))
                  (T (isa '@Cls @) @) ) ) ) ) ) )


# Backing index prefix
(class +Ref2)

(dm T (Var Lst)
   (unless (meta *Class Var)
      (quit "No Ref2" Var) )
   (extra Var Lst) )

(dm rel> (Obj Old New Hook)
   (with (meta (: cls) (: var))
      (let Tree (tree (: var) (: cls))
         (when Old
            (store Tree (cons Old Obj) NIL (: dbf)) )
         (and New
            (not (get Obj T))
            (store Tree (cons New Obj) Obj (: dbf)) ) ) )
   (extra Obj Old New Hook) )

(dm rel?> (Obj Val Hook)
   (and
      (with (meta (: cls) (: var))
         (== Obj
            (fetch
               (tree (: var) (: cls))
               (cons Val Obj) ) ) )
      (extra Obj Val Hook) ) )

(dm lose> (Obj Val Hook)
   (with (meta (: cls) (: var))
      (store (tree (: var) (: cls)) (cons Val Obj) NIL (: dbf)) )
   (extra Obj Val Hook) )

(dm keep> (Obj Val Hook)
   (with (meta (: cls) (: var))
      (store (tree (: var) (: cls)) (cons Val Obj) Obj (: dbf)) )
   (extra Obj Val Hook) )


# (+Idx +relation) [cnt [hook]]
(class +Idx +Ref)

(dm T (Var Lst)
   (=: min (or (car Lst) 3))
   (super Var (cdr Lst)) )

(de idxRel (Obj Old Old2 Olds New New2 News Hook)
   (let
      (Tree (tree (: var) (: cls) (or Hook (and (: hook) (get Obj @))))
         Aux (mapcar '((S) (get Obj S)) (: aux))
         Aux2 (append Aux (cons Obj)) )
      (setq Aux (conc Aux Obj))
      (and Old (store Tree (cons @ Aux) NIL (: dbf)))
      (and Old2 (store Tree (cons @ Aux2) NIL (: dbf)))
      (for S Olds
         (while (nth S (: min))
            (store Tree (cons (pack S) Aux2) NIL (: dbf))
            (++ S) ) )
      (unless (get Obj T)
         (and New (store Tree (cons @ Aux) Obj (: dbf)))
         (and New2 (store Tree (cons @ Aux2) Obj (: dbf)))
         (for S News
            (while (nth S (: min))
               (store Tree (cons (pack S) Aux2) Obj (: dbf))
               (++ S) ) ) ) ) )

(de idxRel? (Obj Val Val2 Vals Hook)
   (let
      (Tree (tree (: var) (: cls) (or Hook (and (: hook) (get Obj @))))
         Aux (mapcar '((S) (get Obj S)) (: aux))
         Aux2 (append Aux (cons Obj)) )
      (setq Aux (conc Aux Obj))
      (and
         (== Obj (fetch Tree (cons Val Aux)))
         (or (not Val2) (== Obj (fetch Tree (cons Val2 Aux2))))
         (fully
            '((S)
               (loop
                  (NIL (nth S (: min)) T)
                  (NIL (== Obj (fetch Tree (cons (pack S) Aux2))))
                  (++ S) ) )
            Vals ) ) ) )

(dm rel> (Obj Old New Hook)
   (idxRel Obj
      Old NIL (split (cdr (chop Old)) " " "\n")
      New NIL (split (cdr (chop New)) " " "\n")
      Hook )
   (extra Obj Old New Hook) )

(dm rel?> (Obj Val Hook)
   (and
      (idxRel? Obj
         Val NIL (split (cdr (chop Val)) " " "\n")
         Hook )
      (extra Obj Val Hook) ) )

(dm lose> (Obj Val Hook)
   (idxRel Obj
      Val NIL (split (cdr (chop Val)) " " "\n")
      NIL NIL NIL
      Hook )
   (extra Obj Val Hook) )

(dm keep> (Obj Val Hook)
   (idxRel Obj
      NIL NIL NIL
      Val NIL (split (cdr (chop Val)) " " "\n")
      Hook )
   (extra Obj Val Hook) )

(dm iter> (X Lst)
   (super X Lst (not X)) )

(dm match> (X Val Obj)
   (sub? X Val) )


# (+Sn +index) [hook]
(class +Sn)

(dm rel> (Obj Old New Hook)
   (let Tree (tree (: var) (: cls) (or Hook (and (: hook) (get Obj @))))
      (and Old
         (ext:Snx Old)
         (store Tree (cons @ Obj T) NIL (: dbf)) )
      (and New
         (not (get Obj T))
         (ext:Snx New)
         (store Tree (cons @ Obj T) Obj (: dbf)) ) )
   (extra Obj Old New Hook) )

(dm rel?> (Obj Val Hook)
   (and
      (let S (ext:Snx Val)
         (or
            (not S)
            (== Obj
               (fetch
                  (tree (: var) (: cls) (or Hook (and (: hook) (get Obj @))))
                  (cons S Obj T) ) ) ) )
      (extra Obj Val Hook) ) )

(dm lose> (Obj Val Hook)
   (let? S (ext:Snx Val)
      (store
         (tree (: var) (: cls) (or Hook (and (: hook) (get Obj @))))
         (cons S Obj T)
         NIL (: dbf) ) )
   (extra Obj Val Hook) )

(dm keep> (Obj Val Hook)
   (let? S (ext:Snx Val)
      (store
         (tree (: var) (: cls) (or Hook (and (: hook) (get Obj @))))
         (cons S Obj T)
         Obj (: dbf) ) )
   (extra Obj Val Hook) )

(dm iter> (X Lst)
   (cons
      (list
         (list
            (car (extra X Lst))
            (init (tree (: var) (: cls) (caddr Lst))
               (cons (setq X (ext:Snx X)))
               (cons (pack X `(char T)) T) ) ) )
      (let @Cls (cadr Lst)
         (curry (@Cls) (Q)
            (loop
               (NIL
                  (or
                     (step (caar Q))
                     (and (cdar Q) (shift Q) (step (caar Q))) ) )
               (T (isa '@Cls @) @) ) ) ) ) )

(dm match> (X Val Obj)
   (or
      (extra X Val Obj)
      (and (pre? (ext:Snx X) (ext:Snx Val)) Val) ) )


# (+Fold +index) [hook]
(class +Fold)

(dm has> (Val X)
   (extra Val
      (if (= Val (fold Val)) (fold X) X) ) )

(dm rel> (Obj Old New Hook)
   (extra Obj (fold Old) (fold New) Hook) )

(dm rel?> (Obj Val Hook)
   (let V (fold Val)
      (or (not V) (extra Obj V Hook)) ) )

(dm lose> (Obj Val Hook)
   (extra Obj (fold Val) Hook) )

(dm keep> (Obj Val Hook)
   (extra Obj (fold Val) Hook) )

(dm iter> (X Lst)
   (extra
      (if (pair X)
         (cons (fold (car X)) (fold (cdr X)))
         (fold X) )
      Lst ) )

(dm match> (X Val Obj)
   (when
      (extra
         (if (pair X)
            (cons (fold (car X)) (fold (cdr X)))
            (fold X) )
         (fold Val)
         Obj )
      Val ) )


# (+IdxFold +relation) [cnt [hook]]
(class +IdxFold +Ref)

(dm T (Var Lst)
   (=: min (or (car Lst) 3))
   (super Var (cdr Lst)) )

(dm rel> (Obj Old New Hook)
   (idxRel Obj
      Old (fold Old)
      (extract '((L) (extract fold L))
         (split (cdr (chop Old)) " " "\n") )
      New (fold New)
      (extract '((L) (extract fold L))
         (split (cdr (chop New)) " " "\n") )
      Hook )
   (extra Obj Old New Hook) )

(dm rel?> (Obj Val Hook)
   (and
      (let V (fold Val)
         (or (not V)
            (idxRel? Obj
               Val V
               (extract '((L) (extract fold L))
                  (split (cdr (chop Val)) " " "\n") )
               Hook ) ) )
      (extra Obj Val Hook) ) )

(dm lose> (Obj Val Hook)
   (idxRel Obj
      Val (fold Val)
      (extract '((L) (extract fold L))
         (split (cdr (chop Val)) " " "\n") )
      NIL NIL NIL
      Hook )
   (extra Obj Val Hook) )

(dm keep> (Obj Val Hook)
   (idxRel Obj
      NIL NIL NIL
      Val (fold Val)
      (extract '((L) (extract fold L))
         (split (cdr (chop Val)) " " "\n") )
      Hook )
   (extra Obj Val Hook) )

(dm iter> (X Lst)
   (super (fold X) Lst (not X)) )

(dm match> (X Val Obj)
   (and (sub? (fold X) (fold Val)) Val) )


# (+Aux) lst
(class +Aux)

(dm T (Var Lst)
   (=: aux (car Lst))
   (with *Class
      (for A (car Lst)
         (if (asoq A (: Aux))
            (queue '@ Var)
            (queue (:: Aux) (list A Var)) ) ) )
   (extra Var (cdr Lst)) )

(de relAux (Obj Var Old Lst)
   (let New (get Obj Var)
      (put Obj Var Old)
      (for A Lst
         (rel> (meta Obj A) Obj (get Obj A) NIL) )
      (put Obj Var New)
      (for A Lst
         (rel> (meta Obj A) Obj NIL (get Obj A)) ) ) )

(dm iter> (X Lst)
   (if (or (atom X) (atom (car X)))
      (extra X Lst)
      (let Tree (tree (: var) (: cls) (caddr Lst))
         (cons
            (if (>= (cdr X) (car X))
               (init Tree
                  (car X)
                  (append (cdr X) T) )
               (init Tree
                  (append (car X) T)
                  (cdr X) ) )
            (let @Cls (cadr Lst)
               (curry (@Cls) (Q)
                  (loop
                     (NIL (step Q))
                     (T (isa '@Cls @) @) ) ) ) ) ) ) )

(dm match> (X Val Obj)
   (if (or (atom X) (atom (car X)))
      (extra X Val Obj)
      (setq Val
         (cons Val
            (mapcar '((S) (get Obj S)) (: aux)) ) )
      (when
         (if (>= (cdr X) (car X))
            (>= (append (cdr X) T) Val (car X))
            (>= (append (car X) T) Val (cdr X)) )
         Val ) ) )


# UB-Tree (+Aux prefix)
(class +UB)

(dm T (Var Lst)
   (=: ub T)
   (extra Var Lst) )

(dm has> (Val X)
   (and Val
      (or
         (extra Val X)
         (extra
            (let (N (inc (length (: aux)))  M 1  V 0)
               (while (gt0 Val)
                  (and (bit? 1 Val) (inc 'V M))
                  (setq M (>> -1 M)  Val (>> N Val)) )
               V )
            X ) ) ) )

(dm iter> (X Lst)
   (cons
      (init (tree (: var) (: cls) (caddr Lst))
         (ubZval (car X))
         (ubZval (cdr X) T) )
      (let @Cls (cadr Lst)
         (curry (@Cls) (Q)
            (loop
               (NIL (step Q))
               (T (isa '@Cls @) @) ) ) ) ) )


### Relation prefix classes ###
(class +Dep)

(dm T (Var Lst)
   (=: dep (car Lst))
   (extra Var (cdr Lst)) )

(dm rel> (Obj Old New Hook)
   (unless New
      (for Var (: dep)
         (let? V (get Obj Var)
            (rel> (meta Obj Var) Obj V
               (put Obj Var (put> (meta Obj Var) Obj V NIL)) )
            (when (asoq Var (meta Obj 'Aux))
               (relAux Obj Var V (cdr @)) )
            (upd> Obj Var V) ) ) )
   (extra Obj Old New Hook) )


(class +List)

(dm mis> (Val Obj)
   (ifn (lst? Val)
      "Not a List"
      (pick '((V) (extra V Obj)) Val) ) )

(dm ele> (Val)
   (and Val (or (atom Val) (find extra Val))) )

(dm has> (Val X)
   (when Val
      (or
         (= Val X)
         (find '((X) (extra Val X)) X)
         (loop
            (NIL
               (let (V (++ Val)  Y (++ X))
                  (or (= V Y) (extra V Y)) ) )
            (NIL (or Val X) T)
            (T (xor Val X)) ) ) ) )

(dm put> (Obj Old New)
   (if (ele> This New)
      (cons (extra Obj Old New) Old)
      (mapcar
         '((N O) (extra Obj O N))
         New
         Old ) ) )

(dm del> (Obj Old Val)
   (and
      (<> Old Val)
      (delete Val Old T) ) )

(dm rel> (Obj Old New Hook)
   (if (or (ele> This Old) (ele> This New))
      (extra Obj Old New Hook)
      (for O Old
         (if (: bag)
            (for (I . This) @
               (let V (get O I)
                  (unless (find '((L) (= V (get L I))) New)
                     (rel> This Obj V NIL
                        (when (: hook)
                           (get (if (sym? @) Obj O) (: hook)) ) ) ) ) )
            (unless (member O New)
               (extra Obj O NIL Hook) ) ) )
      (for N New
         (if (: bag)
            (for (I . This) @
               (let V (get N I)
                  (unless (find '((L) (= V (get L I))) Old)
                     (rel> This Obj NIL V
                        (when (: hook)
                           (get (if (sym? @) Obj N) (: hook)) ) ) ) ) )
            (unless (member N Old)
               (extra Obj NIL N Hook) ) ) ) ) )

(dm rel?> (Obj Val Hook)
   (for V Val
      (NIL (or (not V) (extra Obj V Hook)))
      T ) )

(dm lose> (Obj Val Hook)
   (if (ele> This Val)
      (extra Obj Val Hook)
      (for V Val
         (extra Obj V Hook) ) ) )

(dm keep> (Obj Val Hook)
   (if (ele> This Val)
      (extra Obj Val Hook)
      (for V Val
         (extra Obj V Hook) ) ) )

(dm match> (X Val Obj)
   (pick '((Y) (extra X Y Obj)) Val) )


(class +Need)

(dm mis> (Val Obj)
   (ifn Val
      ,"Input required"
      (extra Val Obj) ) )


(class +Mis)

(dm T (Var Lst)
   (=: mis (car Lst))
   (extra Var (cdr Lst)) )

(dm mis> (Val Obj)
   (or ((: mis) Val Obj) (extra Val Obj)) )


(class +Alt)

(dm T (Var Lst)
   (extra Var (cdr Lst))
   (=: cls (car Lst)) )


(class +Swap)

(dm mis> (Val Obj)
   (extra (if (ext? Val) (val Val) Val) Obj) )

(dm has> (Val X)
   (if (ext? Val)
      (== Val X)
      (extra Val (val X)) ) )

(dm put> (Obj Old New)
   (setq New
      (extra
         Obj
         (val Old)
         (if (ext? New) (val @) New) ) )
   (cond
      ((ext? Old) (set @ New) @)
      (New
         (prog1
            (new (or (: dbf 1) 1))
            (set @ New) ) ) ) )

(dm del> (Obj Old Val)
   (ifn (ext? Old)
      (extra Obj Old Val)
      (set @ (extra Obj (val Old) Val))
      @ ) )

(dm rel> (Obj Old New Hook)
   (extra
      Obj
      (if (ext? Old) (val @) Old)
      (if (ext? New) (val @) New)
      Hook ) )

(dm rel?> (Obj Val Hook)
   (if (ext? Val)
      (if (val @)
         (extra Obj @ Hook)
         T )
      (extra Obj Val Hook) ) )

(dm lose> (Obj Val Hook)
   (extra Obj (if (ext? Val) (val @) Val) Hook) )

(dm keep> (Obj Val Hook)
   (extra Obj (if (ext? Val) (val @) Val) Hook) )


### Entities ###
(de dbSync (Obj)
   (let *Run NIL
      (while (lock (or Obj *DB))
         (wait 40) )
      (sync) ) )

(class +Entity)

(var Dbf)
(var Aux)

(de incECnt (Obj)
   (let M NIL
      (for Cls (type Obj)
         (recur (Cls)
            (or
               (== '+Entity Cls)
               (memq Cls M)
               (when (isa '+Entity (push 'M Cls))
                  (for C (type @)
                     (recurse C) )
                  (if (get *DB Cls)
                     (inc @)
                     (put *DB Cls (new T 1)) ) ) ) ) ) ) )

(de decECnt (Obj)
  (let M NIL
     (for Cls (type Obj)
        (recur (Cls)
           (or
              (== '+Entity Cls)
              (memq Cls M)
              (when (isa '+Entity (push 'M Cls))
                 (for C (type @)
                    (recurse C) )
                 (and (get *DB Cls) (dec @)) ) ) ) ) ) )

(private) (cloneKey cloneAny)

(dm T @
   (incECnt This)
   (while (args)
      (let A (next)
         (cond
            ((=T A) (put This T T))
            ((atom A) (put> This A (next)))
            (T (put> This (car A) (eval (cdr A)))) ) ) )
   (upd> This (val This)) )

(dm zap> ()
   (for X (getl This)
      (let V (or (atom X) (++ X))
         (and (meta This X) (zap> @ This V)) ) )
   (unless (: T) (decECnt This)) )

(dm url> (Tab Fld))

(dm url1> (Tab Fld) (url> This 1 Fld))
(dm url2> (Tab Fld) (url> This 2 Fld))
(dm url3> (Tab Fld) (url> This 3 Fld))
(dm url4> (Tab Fld) (url> This 4 Fld))
(dm url5> (Tab Fld) (url> This 5 Fld))
(dm url6> (Tab Fld) (url> This 6 Fld))
(dm url7> (Tab Fld) (url> This 7 Fld))
(dm url8> (Tab Fld) (url> This 8 Fld))
(dm url9> (Tab Fld) (url> This 9 Fld))

(dm gui> ())

(dm upd> (X Old))

(dm has> (Var Val)
   (or
      (nor
         Val
         (if2 (get This Var) (ext? @) (val @) @) )
      (has> (meta This Var) Val (get This Var)) ) )

(dm rel?> (Var Val)
   (nond
      (Val T)
      ((meta This Var) T)
      (NIL (rel?> @ This Val)) ) )

(dm put> (Var Val)
   (unless (has> This Var Val)
      (let Old (get This Var)
         (rel> (meta This Var) This Old
            (put This Var (put> (meta This Var) This Old Val)) )
         (when (asoq Var (meta This 'Aux))
            (relAux This Var Old (cdr @)) )
         (upd> This Var Old) ) )
   Val )

(dm put!> (Var Val)
   (unless (has> This Var Val)
      (dbSync)
      (let Old (get This Var)
         (rel> (meta This Var) This Old
            (put This Var (put> (meta This Var) This Old Val)) )
         (when (asoq Var (meta This 'Aux))
            (relAux This Var Old (cdr @)) )
         (upd> This Var Old)
         (commit 'upd) ) )
   Val )

(dm del> (Var Val)
   (when (and Val (has> (meta This Var) Val (get This Var)))
      (let Old (get This Var)
         (rel> (meta This Var) This Old
            (put This Var (del> (meta This Var) This Old Val)) )
         (when (asoq Var (meta This 'Aux))
            (relAux This Var Old (cdr @)) )
         (upd> This Var Old) ) ) )

(dm del!> (Var Val)
   (when (and Val (has> (meta This Var) Val (get This Var)))
      (dbSync)
      (let Old (get This Var)
         (rel> (meta This Var) This Old
            (put This Var (del> (meta This Var) This Old Val)) )
         (when (asoq Var (meta This 'Aux))
            (relAux This Var Old (cdr @)) )
         (upd> This Var Old)
         (commit 'upd) ) ) )

(dm inc> (Var Val)
   (let P (prop This Var)
      (when (num? (car P))
         (let Old @
            (rel> (meta This Var) This Old
               (inc P (or Val 1)) )
            (when (asoq Var (meta This 'Aux))
               (relAux This Var Old (cdr @)) )
            (upd> This Var Old) )
         (car P) ) ) )

(dm inc!> (Var Val)
   (when (num? (get This Var))
      (dbSync)
      (let (P (prop This Var)  Old (car P))
         (rel> (meta This Var) This Old
            (inc P (or Val 1)) )
         (when (asoq Var (meta This 'Aux))
            (relAux This Var Old (cdr @)) )
         (upd> This Var Old)
         (commit 'upd)
         (car P) ) ) )

(dm dec> (Var Val)
   (let P (prop This Var)
      (when (num? (car P))
         (let Old @
            (rel> (meta This Var) This Old
               (dec P (or Val 1)) )
            (when (asoq Var (meta This 'Aux))
               (relAux This Var Old (cdr @)) )
            (upd> This Var Old) )
         (car P) ) ) )

(dm dec!> (Var Val)
   (when (num? (get This Var))
      (dbSync)
      (let (P (prop This Var)  Old (car P))
         (rel> (meta This Var) This Old
            (dec P (or Val 1)) )
         (when (asoq Var (meta This 'Aux))
            (relAux This Var Old (cdr @)) )
         (upd> This Var Old)
         (commit 'upd)
         (car P) ) ) )

(dm mis> (Var Val)
   (mis> (meta This Var) Val This) )

(dm lose1> (Var)
   (when (meta This Var)
      (lose> @ This (get This Var)) ) )

(dm lose> (Lst)
   (unless (: T)
      (for X (getl This)
         (let V (or (atom X) (++ X))
            (and
               (not (memq X Lst))
               (meta This X)
               (lose> @ This V) ) ) )
      (decECnt This)
      (=: T T)
      (upd> This) ) )

(dm lose!> (Lst)
   (dbSync)
   (lose> This Lst)
   (commit 'upd) )

(de lose "Prg"
   (let "Flg" (: T)
      (=: T T)
      (run "Prg")
      (=: T "Flg") ) )

(dm keep1> (Var)
   (when (meta This Var)
      (keep> @ This (get This Var)) ) )

(dm keep> (Lst)
   (when (: T)
      (=: T)
      (incECnt This)
      (for X (getl This)
         (let V (or (atom X) (++ X))
            (and
               (not (memq X Lst))
               (meta This X)
               (keep> @ This V) ) ) )
      (upd> This T) ) )

(dm keep?> (Lst)
   (extract
      '((X)
         (with (and (pair X) (meta This (cdr X)))
            (and
               (isa '+Key This)
               (fetch (tree (: var) (: cls) (and (: hook) (get (up This) @))) (car X))
               (cons (car X) ,"Not unique") ) ) )
      (getl This) ) )

(dm keep!> (Lst)
   (dbSync)
   (keep> This Lst)
   (commit 'upd) )

(de keep "Prg"
   (let "Flg" (: T)
      (=: T)
      (run "Prg")
      (=: T "Flg") ) )

(dm set> (Val)
   (unless (= Val (val This))
      (decECnt This)
      (let Lst (make (maps '((X) (link (fin X))) This))
         (for Var Lst
            (let? Rel (meta This Var)
               (unless (== Rel (meta Val Var))
                  (let V (get This Var)
                     (and (isa '+Swap Rel) (setq V (val V)))
                     (rel> Rel This V (put> Rel This V NIL)) ) ) ) )
         (xchg This 'Val)
         (for Var Lst
            (let? Rel (meta This Var)
               (unless (== Rel (meta Val Var))
                  (let V (get This Var)
                     (rel> Rel This NIL
                        (put> Rel This NIL
                           (if (isa '+Swap Rel) (val V) V) ) ) ) ) ) ) )
      (incECnt This)
      (upd> This (val This) Val) )
   (val This) )

(dm set!> (Val)
   (unless (= Val (val This))
      (dbSync)
      (decECnt This)
      (let Lst (make (maps '((X) (link (fin X))) This))
         (for Var Lst
            (let? Rel (meta This Var)
               (unless (== Rel (meta Val Var))
                  (let V (get This Var)
                     (and (isa '+Swap Rel) (setq V (val V)))
                     (rel> Rel This V (put> Rel This V NIL)) ) ) ) )
         (xchg This 'Val)
         (for Var Lst
            (let? Rel (meta This Var)
               (unless (== Rel (meta Val Var))
                  (let V (get This Var)
                     (rel> Rel This NIL
                        (put> Rel This NIL
                           (if (isa '+Swap Rel) (val V) V) ) ) ) ) ) ) )
      (incECnt This)
      (upd> This (val This) Val)
      (commit 'upd) )
   (val This) )

(dm clone> (Lst)
   (let Obj (new (or (var: Dbf 1) 1) (val This))
      (for X
         (by
            '((X)
               (nand
                  (pair X)
                  (isa '+Hook (meta This (cdr X))) ) )
            sort
            (getl This) )
         (unless (memq (fin X) Lst)
            (if (atom X)
               (ifn (meta This X)
                  (put Obj X T)
                  (let Rel @
                     (put> Obj X T)
                     (when (isa '+Blob Rel)
                        (in (blob This X)
                           (out (blob Obj X) (echo)) )
                        (blob+ Obj X) ) ) )
               (ifn (meta This (cdr X))
                  (put Obj (cdr X) (car X))
                  (let Rel @
                     (cond
                        ((find '((B) (isa '+Key B)) (get Rel 'bag))
                           (let (K @  H (get K 'hook))
                              (put> Obj (cdr X)
                                 (mapcar
                                    '((Lst)
                                       (mapcar
                                          '((B Val)
                                             (if (== B K)
                                                (cloneKey B (cdr X) Val
                                                   (and H (get (if (sym? H) This Lst) H)) )
                                                Val ) )
                                          (get Rel 'bag)
                                          Lst ) )
                                    (car X) ) ) ) )
                        ((isa '+Key Rel)
                           (put> Obj (cdr X)
                              (cloneKey Rel (cdr X) (car X)
                                 (and (get Rel 'hook) (get This @)) ) ) )
                        ((or (not (isa '+Joint Rel)) (isa '+List (meta Obj (cdr X))))
                           (put> Obj (cdr X) (cloneAny (car X) Rel)) ) ) ) ) ) ) )
      Obj ) )

(de cloneKey (Rel Var Val Hook)
   (cond
      ((isa '+Number Rel)
         (genKey Var (get Rel 'cls) Hook) )
      ((isa '+String Rel)
         (genStrKey (pack "# " Val) Var (get Rel 'cls) Hook) ) ) )

(de cloneAny (Val Rel)
   (cond
      ((isa '+Swap Rel) (val Val))
      ((isa '+Bag Rel)
         (if (isa '+List Rel)
            (mapcar
               '((B) (mapcar cloneAny B (; Rel bag)))
               Val )
            (mapcar cloneAny Val (; Rel bag)) ) )
      (T Val) ) )

(dm clone!> ()
   (prog2
      (dbSync)
      (clone> This)
      (commit 'upd) ) )

(de new! ("Typ" . @)
   (prog2
      (dbSync)
      (pass new (or (meta "Typ" 'Dbf 1) 1) "Typ")
      (commit 'upd) ) )

(de set! (Obj Val)
   (unless (= Val (val Obj))
      (dbSync)
      (set Obj Val)
      (commit 'upd) )
   Val )

(de put! (Obj Var Val)
   (unless (= Val (get Obj Var))
      (dbSync)
      (put Obj Var Val)
      (commit 'upd) )
   Val )

(de inc! (Obj Var Val)
   (when (num? (get Obj Var))
      (prog2
         (dbSync)
         (inc (prop Obj Var) (or Val 1))
         (commit 'upd) ) ) )

(de blob! (Obj Var File)
   (put!> Obj Var File)
   (blob+ Obj Var)
   File )

(de blob+ (Obj Var)
   (when *Jnl
      (chdir *Blob
         (%@ "symlink" 'I
            (pack (glue "/" (chop Obj)) "." Var)
            (pack "=" (name Obj) "." Var) ) ) ) )


# Remote entities
(class +Remote)

(dm zap> ())
(dm has> ~(method 'has> '+Entity))
(dm url> (Tab Fld))
(dm url1> ~(method 'url1> '+Entity))
(dm url2> ~(method 'url2> '+Entity))
(dm url3> ~(method 'url3> '+Entity))
(dm url4> ~(method 'url4> '+Entity))
(dm url5> ~(method 'url5> '+Entity))
(dm url6> ~(method 'url6> '+Entity))
(dm url7> ~(method 'url7> '+Entity))
(dm url8> ~(method 'url8> '+Entity))
(dm url9> ~(method 'url9> '+Entity))
(dm put> (Var Val))
(dm put!> (Var Val))
(dm del> (Var Val))
(dm del!> (Var Val))
(dm inc> (Var Val))
(dm inc!> (Var Val))
(dm dec> (Var Val))
(dm dec!> (Var Val))
(dm mis> (Var Val))
(dm lose1> (Var))
(dm lose> (Lst))
(dm lose!> (Lst))
(dm keep1> (Var))
(dm keep> (Lst))
(dm keep?> (Lst))
(dm keep!> (Lst))
(dm set> (Val))
(dm set!> (Val))


# Default syncronization function
(de upd Lst
   (wipe Lst) )

### DB Sizes ###
(de dbs Lst
   (setq *Dbs
      (make
         (for (N . L) Lst
            (let Dbf (cons N (>> (- (link (car L))) 64))
               (for Cls (cdr L)
                  (if (atom Cls)
                     (put Cls 'Dbf Dbf)
                     (for Var (cdr Cls)
                        (let Rel (get Cls 1 Var)
                           (unless Rel
                              (quit "Bad relation" (cons Var (car Cls))) )
                           (when (or (isa '+index Rel) (isa '+Swap Rel))
                              (put @ 'dbf Dbf) )
                           (for B (; Rel bag)
                              (when (or (isa '+index B) (isa '+Swap B))
                                 (put @ 'dbf Dbf)) ) ) ) ) ) ) ) ) ) )

(de db: Typ
   (or (meta Typ 'Dbf 1) 1) )

### Utilities ###
(private) _db

(de treeRel (Var Cls)
   (with (or (get Cls Var) (meta Cls Var))
      (or
         (find '((B) (isa '+index B)) (: bag))
         This ) ) )

# (db 'var 'cls ['hook] 'any ['var 'any ..]) -> sym
(de db (Var Cls . @)
   (with (treeRel Var Cls)
      (let (Tree (tree (: var) (: cls) (and (: hook) (next)))  Val (next))
         (if (isa '+Key This)
            (if (args)
               (and (fetch Tree Val) (pass _db @))
               (fetch Tree Val) )
            (let Key (cons (if (isa '+Fold This) (fold Val) Val))
               (let? A (: aux)
                  (while (and (args) (== (++ A) (arg 1)))
                     (next)
                     (queue 'Key (next)) )
                  (and (: ub) (setq Key (ubZval Key))) )
               (let Q (init Tree Key (append Key T))
                  (loop
                     (NIL (step Q T))
                     (T (pass _db @ Var Val) @) ) ) ) ) ) ) )

(de _db (Obj . @)
   (when (isa Cls Obj)
      (loop
         (NIL (next) Obj)
         (NIL (has> Obj @ (next))) ) ) )

# (aux 'var 'cls ['hook] 'any ..) -> sym
(de aux (Var Cls . @)
   (with (treeRel Var Cls)
      (let Key (if (: ub) (ubZval (rest)) (rest))
         (step
            (init (tree (: var) (: cls) (and (: hook) (next)))
               Key
               (append Key T) ) ) ) ) )

# (collect 'var 'cls ['hook] ['any|beg ['end [var ..]]]) -> lst
(de collect (Var Cls . @)
   (with (treeRel Var Cls)
      (let
         (Tree (tree (: var) (: cls) (and (: hook) (next)))
            X1 (next)
            X2 (if (args) (next) (or X1 T)) )
         (make
            (cond
               ((isa '+Key This)
                  (iter Tree
                     '((X) (and (isa Cls X) (link (pass get X))))
                     X1 X2 ) )
               ((: ub)
                  (if X1
                     (ubIter Tree (inc (length (: aux)))
                        '((X) (and (isa Cls X) (link (pass get X))))
                        X1 X2 )
                     (iter Tree
                        '((X) (and (isa Cls X) (link (pass get X)))) ) ) )
               (T
                  (when (isa '+Fold This)
                     (setq X1 (fold X1)  X2 (or (=T X2) (fold X2))) )
                  (if (>= X2 X1)
                     (if (pair X1)
                        (setq X2 (append X2 T))
                        (setq X1 (cons X1)  X2 (cons X2 T)) )
                     (if (pair X1)
                        (setq X1 (append X1 T))
                        (setq X1 (cons X1 T)  X2 (cons X2)) ) )
                  (iter Tree
                     '((X)
                        (and (isa Cls X) (link (pass get X))) )
                     X1 X2
                     (or (isa '+Idx This) (isa '+IdxFold This)) ) ) ) ) ) ) )

# Combined 'search' function
(de relQ (X Lst)
   (iter> (meta (cdr Lst) (car Lst)) X Lst) )

(private) search1

(de search1 (Val Lst)  # ((Q . stepFun) . lst)
   (let X (++ Lst)
      (cons
         (cond
            ((pair (cdr X)) (relQ Val X))
            ((pair (setq X (get Val (cdr X))))
               (cons (list X) pop) )
            (T (cons (list (list X)) pop)) )
         Lst ) ) )

(de search (X Y . @)
   (ifn Y
      (for (P (cddr X)  P  (or (cdr P) (cddr X)))  # Next search result
         (NIL (setq Y ((cadar P) (caaar P))))
         (T
            (unless (idx X Y T)
               (and
                  (fully
                     '((L) ((cddr L) Y (cdar L)))
                     (cddr X) )
                  ((cadr X) Y) ) )
            (setq P
               (rot (cddr X) (offset P (cddr X))) )
            @ ) )
      # Init search
      (make
         (link NIL prog)  # idx and extract
         (loop
            (when (or X (nor (args) (cddr (made))))
               (link  # ((Q . V) genFun . filterFun)
                  (cons
                     (cons
                        (list
                           (if (pair (caar Y))
                              (cons ((car Y) X) (cddr Y))  # (init . step)
                              (search1 X Y) ) )
                        X )
                     '((Q)  # Generator
                        (use Obj
                           (loop
                              (T
                                 (nor  # Done
                                    (setq Obj ((cdaar Q) (caaar Q)))
                                    (cdr Q) ) )
                              (T (unless (cdar Q) Obj) Obj)  # Result
                              (if Obj
                                 (let L (cdar Q)
                                    (con Q (cons (car Q) (cdr Q)))
                                    (set Q (search1 Obj L)) )
                                 (set Q (cadr Q))
                                 (con Q (cddr Q)) ) ) ) )
                     (let  # Filter
                        (@Exe
                           (if (pair (caar Y))
                              (cons
                                 (lit (car (shift 'Y)))
                                 '(X V) )
                              (list 'match>
                                 (lit
                                    (if (atom (cdar Y))
                                       (with (meta X (cdar Y))  # +Joint
                                          (meta (: type) (: slot)) )
                                       (meta (cdar Y) (caar Y)) ) )  # +index
                                 'V
                                 (list '; 'X (caar Y))
                                 'X ) )
                           @Lst (flip (mapcar car (cdr Y))) )
                        (curry (@Lst @Exe) (X V)
                           (let L '@Lst
                              (recur (X L)
                                 (if L
                                    (pick recurse
                                       (fish ext? (get X (++ L)))
                                       (circ L) )
                                    @Exe ) ) ) ) ) ) ) )
            (setq X (next))
            (NIL (setq Y (next))
               (and X (set (cdr (made)) @)) ) ) ) ) )

# Multiple indexes
(de relQs (@Lst . @)
   (cons
      (curry (@Lst) (X)
         (cons
            (list
               (mapcar '((Y) (relQ X Y)) '@Lst) )
            '((Q)
               (or
                  ((cdaar Q) (caaar Q))
                  (and
                     (cdar Q)
                     (shift Q)
                     ((cdaar Q) (caaar Q)) ) ) ) ) )
      (let
         (@L
            (mapcar
               '((Y) (meta (cdr Y) (car Y)))
               @Lst )
            @V (mapcar car @Lst) )
         (curry (@L @V) (X Val)
            (find
               '((R V) (match> R Val (get X V) X))
               '@L
               '@V ) ) )
      (rest) ) )

# Iterate all objects of given class
(de forall (X . Prg)
   (for
      (This
         (seq
            (or
               (and (pair X) (car @))
               (; X Dbf 1)
               (meta X 'Dbf 1)
               1 ) )
         This
         (seq This) )
      (and (isa (fin X) This) (run Prg 1)) ) )

# Define object variables as relations
(de rel Lst
   (def *Class
      (car Lst)
      (new (cadr Lst) (car Lst) (cddr Lst)) ) )

# Find or create object
(de request (Typ Var . @)
   (let Dbf (or (meta Typ 'Dbf 1) 1)
      (ifn Var
         (new Dbf Typ)
         (with (meta Typ Var)
            (or
               (pass db Var (: cls))
               (if (: hook)
                  (pass new Dbf Typ @ (next) Var)
                  (pass new Dbf Typ Var) ) ) ) ) ) )

(de request! (Typ Var . @)
   (prog2
      (dbSync)
      (pass request Typ Var)
      (commit 'upd) ) )

# Create or update object
(private) *ObjIdx

(de obj Lst
   (let Obj
      (let L (++ Lst)
         (if (pair (car L))
            (apply request L)
            (cache '*ObjIdx (++ Lst)
               (new (or (meta L 'Dbf 1) 1) L) ) ) )
      (while Lst
         (let (K (++ Lst)  V (++ Lst))
            (if (=T K)
               (lose> Obj)
               (put> Obj K V) ) ) )
      Obj ) )

# Create or update lots of objects
(de create (Typ Key Vars . Prg)
   (prune 0)
   (setq Vars  # ((var fd lst cnt . cnt) ..)
      (mapcar
         '((Var)
            (if (isa '+index (meta Typ Var))
               (cons Var
                  (open (tmp (pack "create-" Var)))
                  NIL 0 1000000 )
               Var ) )
         Vars ) )
   (while (run Prg)  # (val ..)
      (let (Lst @  Obj (or (fin Lst) (new (meta Typ 'Dbf 1) Typ)))
         (and Key (++ Lst) (put> Obj Key @))
         (let store '((Tree Key Val Dbf) (link Key))
            (mapc
               '((V Val)
                  (when (or Val (fin Lst))
                     (if (atom V)
                        (put> Obj V Val)
                        (out (cadr V)
                           (for Key (make (put> Obj (car V) Val))
                              (at (cdddr V) (push (cddr V) Key))
                              (pr Key Obj) ) ) ) ) )
               Vars
               Lst ) ) )
      (at (0 . 1000000) (commit) (prune 2)) )
   (commit)
   (prune 0)
   (let Lst
      (extract
         '((V)
            (unless (atom V)
               (close (cadr V))
               (let
                  (Var (car V)
                     File (tmp (pack "create-" Var))
                     N 0 )
                  (setq V
                     (mapcar
                        '((Key)
                           (let F (tmp (pack "create-" (inc 'N)))
                              (cons Key F
                                 (or (open F) (quit "Too many files")) ) ) )
                        (cons NIL (sort (caddr V))) ) )
                  (in File
                     (while (setq Key (rd))
                        (out (cddr (rank Key V))
                           (pr Key (rd)) ) ) )
                  (%@ "unlink" NIL File)
                  (let (Dbf (meta Typ Var 'dbf)  Tree (cons Var (new T)))
                     (for R V
                        (close (cddr R))
                        (for X
                           (sort
                              (make
                                 (in (cadr R)
                                    (while (rd)
                                       (link (cons @ (rd))) ) ) ) )
                           (store Tree (car X) (cdr X) Dbf)
                           (at (0 . 1000) (prune 2)) )
                        (commit)
                        (prune 2)
                        (%@ "unlink" NIL (cadr R)) )
                     (commit)
                     Tree ) ) ) )
         Vars )
      (prune)
      (for Tree Lst
         (let
            (Base (get *DB (meta Typ (car Tree) 'cls))
               Root (get (cdr Tree) (car Tree)) )
            (ifn (get Base (car Tree))
               (put Base (car Tree) Root)
               (touch Base)
               (inc @ (car Root)) ) )
         (zap (cdr Tree)) )
      (commit) ) )

### Debug ###
`*Dbg

(noLint 'create 'store)

(load "@lib/sq.l")
pil21/lib/pilog.l0000644000000000000000000003655614533305713010753 0ustar  # 04dec23 Software Lab. Alexander Burger

(private) (CL Q R L Prg)

(de be CL
   (clause CL) )

(de clause (CL)
   (with (++ CL)
      (if (== *Rule This)
         (queue (:: T) CL)
         (=: T (list CL))
         (setq *Rule This) )
      (def This T (: T)) ) )

(de repeat ()
   (conc (get *Rule T) (get *Rule T)) )

(de asserta (CL)
   (push (prop CL 1 T) (cdr CL)) )

(de assertz (CL)
   (queue (prop CL 1 T) (cdr CL)) )

(de retract (X)
   (if (sym? X)
      (put X T)
      (put (car X) T
         (delete (cdr X) (get (car X) T)) ) ) )

(de rules @
   (while (args)
      (let S (next)
         (for ((N . L) (get S T) L)
            (prin N " (be ")
            (print S)
            (for X (++ L)
               (space)
               (print X) )
            (prinl ")")
            (T (== L (get S T))
               (println '(repeat)) ) )
         S ) ) )

### Pilog Interpreter ###
(private) (Env Dbg *R)

(de goal (CL . @)
   (let Env '(T)
      (while (args)
         (push 'Env
            (cons (cons 0 (next)) 1 (next)) ) )
      (while (and CL (pat? (car CL)))
         (push 'Env
            (cons
               (cons 0 (++ CL))
               (cons 1 (eval (++ CL))) ) ) )
      (cons
         (cons
            (conc (list 1 (0) NIL CL NIL) Env) ) ) ) )

(de fail ()
   (goal '((NIL))) )

(de pilog (CL . Prg)
   (for (Q (goal CL) (prove Q))
      (bind @ (run Prg)) ) )

(de solve (CL . Prg)
   (make
      (if Prg
         (for (Q (goal CL) (prove Q))
            (link (bind @ (run Prg))) )
         (for (Q (goal CL) (prove Q))
            (link @) ) ) ) )

(de query (Q Dbg)
   (use R
      (loop
         (NIL (prove Q Dbg))
         (T (=T (setq R @)) T)
         (for X R
            (space)
            (print (car X))
            (print '=)
            (print (cdr X)) )
         (prinl)
         (T (= "\e" (key)) T) ) ) )

(de ? CL
   (let L
      (make
         (while (nor (pat? (car CL)) (lst? (car CL)))
            (link (++ CL)) ) )
      (query (goal CL) L) ) )

### Basic Rules ###
(private) (_or _for)

(be repeat)
(repeat)

(be true)

(be not @P (1 @P) T (fail))
(be not @P)

(be call @P (2 (cons @P)))

(be or @L (^ @C (box @L)) (_or @C))

(be _or (@C) (3 (pop @C)))
(be _or (@C) (^ @ (not (val @C))) T (fail))
(repeat)

(be nil (@X) (^ @ (not @X)))


(be equal (@X @X))

(be different (@X @X) T (fail))
(be different (@ @))

(be append (NIL @X @X))
(be append ((@A . @X) @Y (@A . @Z)) (append @X @Y @Z))

(be member (@X (@X . @)))
(be member (@X (@ . @Y)) (member @X @Y))

(be delete (@A (@A . @Z) @Z))
(be delete (@A (@X . @Y) (@X . @Z))
   (delete @A @Y @Z) )

(be permute ((@X) (@X)))
(be permute (@L (@X . @Y))
   (delete @X @L @D)
   (permute @D @Y) )

(be uniq (@B @X)
   (^ @
      (not (idx @B (cons (hash @X) @X) T)) ) )


(be asserta (@C) (^ @ (asserta @C)))
(be assertz (@C) (^ @ (assertz @C)))

(be retract (@C)
   (2 (cons @C))
   (^ @ (retract (list (car @C) (cdr @C)))) )

(be clause (@H @B)
   (^ @A (get @H T))
   (member @B @A) )

(be show (@X) (^ @ (show @X)))

(be for (@N @End) (for @N 1 @End 1))
(be for (@N @Beg @End) (for @N @Beg @End 1))
(be for (@N @Beg @End @Step) (equal @N @Beg))
(be for (@N @Beg @End @Step)
   (^ @I (box @Beg))
   (_for @N @I @End @Step) )

(be _for (@N @I @End @Step)
   (^ @
      (if (>= @End (val @I))
         (> (inc @I @Step) @End)
         (> @End (dec @I @Step)) ) )
   T
   (fail) )

(be _for (@N @I @End @Step)
   (^ @N (val @I)) )

(repeat)


### DB ###
(de initQuery (Var Cls Hook Val)
   (let (Tree (tree Var Cls Hook)  Rel (get Cls Var))
      (when (find '((B) (isa '+index B)) (get Rel 'bag))
         (setq Rel @) )
      (when (or (isa '+Fold Rel) (isa '+IdxFold Rel))
         (setq Val (fold Val)) )
      (cond
         ((pair Val)
            (cond
               ((and (pair (cdr Val)) (; Rel aux))
                  (cond
                     ((atom (car Val))
                        (and (; Rel ub) (setq Val (ubZval Val)))
                        (init Tree Val (append Val T)) )
                     ((; Rel ub)
                        (init Tree
                           (ubZval (car Val))
                           (ubZval (cdr Val) T) ) )
                     ((>= (cdr Val) (car Val))
                        (init Tree (car Val) (append (cdr Val) T)) )
                     (T (init Tree (append (car Val) T) (cdr Val))) ) )
               ((isa '+Key Rel)
                  (init Tree (car Val) (cdr Val)) )
               ((>= (cdr Val) (car Val))
                  (init Tree
                     (cons (car Val))
                     (cons (cdr Val) T) ) )
               (T
                  (init Tree
                     (cons (car Val) T)
                     (cons (cdr Val)) ) ) ) )
         ((or (num? Val) (ext? Val))
            (if (isa '+Key Rel)
               (init Tree Val Val)
               (init Tree (cons Val) (cons Val T)) ) )
         ((=T Val) (init Tree))
         ((isa '+Key Rel)
            (init Tree Val (pack Val `(char T))) )
         ((isa '+Idx Rel)
            (let Q (init Tree (cons Val) (cons (pack Val `(char T)) T))
               (if (cdr Q)
                  Q
                  (setq Val (pack (car (split (chop Val) " "))))
                  (init Tree (cons Val) (cons (pack Val `(char T)) T)) ) ) )
         (T (init Tree (cons Val) (cons (pack Val `(char T)) T))) ) ) )


(private) _db

# (db var cls obj)
(be db (@Var @Cls @Obj)
   (^ @C (box))  # (obj ..)
   (^ @Q
      (box
         (with (or (get @Cls @Var) (meta @Cls @Var))
            (initQuery (: var) (: cls) NIL '(NIL . T)) ) ) )
   (_db @Obj) )

# (db var cls hook|val obj)
(be db (@Var @Cls @X @Obj)
   (^ @C (box))  # (obj ..)
   (^ @Q
      (box
         (with (or (get @Cls @Var) (meta @Cls @Var))
            (if (: hook)
               (initQuery (: var) (: cls) @X '(NIL . T))
               (initQuery (: var) (: cls) NIL @X) ) ) ) )
   (_db @Obj) )

# (db var cls hook val obj)
(be db (@Var @Cls @Hook @Val @Obj)
   (^ @C (box))  # (obj ..)
   (^ @Q
      (box
         (with (or (get @Cls @Var) (meta @Cls @Var))
            (initQuery (: var) (: cls) @Hook @Val) ) ) )
   (_db @Obj) )

(be _db (@Obj)
   (^ @
      (let (Q (val (-> @Q 2))  Cls (-> @Cls 2))
         (loop
            (NIL (step Q (= '(NIL) (caaar Q))) T)
            (T
               (and
                  (isa Cls (setq *R @))
                  (not (idx (-> @C 2) *R T)) ) ) ) ) )
   T
   (fail) )

(be _db (@Obj) (^ @Obj *R))

(repeat)


(private) (_lst _map)

(be val (@V . @L)
   (^ @V (apply get @L))
   T )

(be lst (@V . @L)
   (^ @Lst (box (apply get @L)))
   (_lst @V @Lst) )

(be _lst (@Val @Lst) (^ @ (not (val @Lst))) T (fail))
(be _lst (@Val @Lst) (^ @Val (pop @Lst)))
(repeat)

(be map (@V . @L)
   (^ @Lst (box (apply get @L)))
   (_map @V @Lst) )

(be _map (@Val @Lst) (^ @ (not (val @Lst))) T (fail))
(be _map (@Val @Lst) (^ @Val (prog1 (val @Lst) (pop @Lst))))
(repeat)


(private) (_same _range _head _hold _fold _part _tolr)

(be isa (@Typ . @L)
   (^ @
      (or
         (not @Typ)
         (isa @Typ (apply get @L)) ) ) )

(be same (@V . @L)
   (^ @
      (or (not @V) (_same (car @L) (cdr @L))) ) )

(de _same (X L)
   (cond
      ((not L)
         (if (atom X)
            (= @V X)
            (member @V X) ) )
      ((atom X)
         (_same (get X (car L)) (cdr L)) )
      ((atom (car L))
         (pick
            '((Y) (_same (get Y (car L)) (cdr L)))
            X ) )
      (T (_same (apply get (car L) X) (cdr L))) ) )

(be bool (@F . @L)
   (^ @
      (or (not @F) (bool (apply get @L))) ) )

(be ub (@A @R . @L)
   (^ @
      (or
         (not @R)
         (let X (apply get @L)
            (fully
               '((K V1 V2)
                  (>= V2 (get X K) V1) )
               @A
               (car @R)
               (cdr @R) ) ) ) ) )

(be range (@R . @L)
   (^ @
      (or (not @R) (_range (car @L) (cdr @L))) ) )

(de _range (X L)
   (cond
      ((not L)
         (if (atom X)
            (or
               (<= (car @R) X (cdr @R))
               (>= (car @R) X (cdr @R)) )
            (find
               '((Y)
                  (or
                     (<= (car @R) Y (cdr @R))
                     (>= (car @R) Y (cdr @R)) ) )
               X ) ) )
      ((atom X)
         (_range (get X (car L)) (cdr L)) )
      ((atom (car L))
         (pick
            '((Y) (_range (get Y (car L)) (cdr L)))
            X ) )
      (T (_range (apply get (car L) X) (cdr L))) ) )

(be head (@S . @L)
   (^ @
      (or (not @S) (_head (car @L) (cdr @L))) ) )

(de _head (X L)
   (cond
      ((not L)
         (if (atom X)
            (pre? @S X)
            (find '((Y) (pre? @S Y)) X) ) )
      ((atom X)
         (_head (get X (car L)) (cdr L)) )
      ((atom (car L))
         (pick
            '((Y) (_head (get Y (car L)) (cdr L)))
            X ) )
      (T (_head (apply get (car L) X) (cdr L))) ) )

(be hold (@S . @L)
   (^ @
      (or (not @S) (_hold (car @L) (cdr @L))) ) )

(de _hold (X L)
   (cond
      ((not L)
         (if (atom X)
            (sub? @S X)
            (find '((Y) (sub? @S Y)) X) ) )
      ((atom X)
         (_hold (get X (car L)) (cdr L)) )
      ((atom (car L))
         (pick
            '((Y) (_hold (get Y (car L)) (cdr L)))
            X ) )
      (T (_hold (apply get (car L) X) (cdr L))) ) )

(be fold (@S . @L)
   (^ @
      (or
         (not (setq @S (fold @S)))
         (_fold (car @L) (cdr @L)) ) ) )

(de _fold (X L)
   (cond
      ((not L)
         (if (atom X)
            (pre? @S (fold X))
            (find '((Y) (pre? @S (fold Y))) X) ) )
      ((atom X)
         (_fold (get X (car L)) (cdr L)) )
      ((atom (car L))
         (pick
            '((Y) (_fold (get Y (car L)) (cdr L)))
            X ) )
      (T (_fold (apply get (car L) X) (cdr L))) ) )

(be part (@S . @L)
   (^ @
      (or
         (not (setq @S (fold @S)))
         (_part (car @L) (cdr @L)) ) ) )

(de _part (X L)
   (cond
      ((not L)
         (if (atom X)
            (sub? @S (fold X))
            (find '((Y) (sub? @S (fold Y))) X) ) )
      ((atom X)
         (_part (get X (car L)) (cdr L)) )
      ((atom (car L))
         (pick
            '((Y) (_part (get Y (car L)) (cdr L)))
            X ) )
      (T (_part (apply get (car L) X) (cdr L))) ) )

(be tolr (@S . @L)
   (^ @
      (or
         (not (setq @S (fold @S)))
         (_tolr (car @L) (cdr @L)) ) ) )

(de _tolr (X L)
   (cond
      ((not L)
         (if (atom X)
            (or (sub? @S (fold X)) (pre? (ext:Snx @S) (ext:Snx X)))
            (let P (ext:Snx @S)
               (find
                  '((Y)
                     (or (sub? @S (fold Y)) (pre? P (ext:Snx Y))) )
                  X ) ) ) )
      ((atom X)
         (_tolr (get X (car L)) (cdr L)) )
      ((atom (car L))
         (pick
            '((Y) (_tolr (get Y (car L)) (cdr L)))
            X ) )
      (T (_tolr (apply get (car L) X) (cdr L))) ) )


(private) (_select _initSel _gen _sel)

(de _select (Lst Flg)
   (let? X
      (nond
         ((atom (car Lst))
            (make
               (for (L (++ Lst) L)
                  (let
                     (Var (++ L)
                        Cls (++ L)
                        Hook (and (get Cls Var 'hook) (++ L))
                        Val (++ L) )
                     (and (or Val Flg) (chain (_initSel))) ) ) ) )
         ((pat? (car Lst))
            (let
               (Var (++ Lst)
                  Cls (++ Lst)
                  Hook (and (get Cls Var 'hook) (++ Lst))
                  Val (++ Lst) )
               (and (or Val Flg) (_initSel)) ) )
         (NIL
            (let (Var (++ Lst) Val (++ Lst))
               (and
                  (or Flg (apply or Val))
                  (cons Var (goal (++ Lst))) ) ) ) )
      (cons
         (cons
            (for (L NIL Lst)
               (push 'L (++ Lst) NIL)
               L )
            X ) ) ) )

(de _initSel ()
   (with (treeRel Var Cls)
      (let Tree (tree Var (: cls) Hook)
         (conc
            (and
               (isa '+IdxFold This)
               (<> Val (fold Val))
               (init Tree (cons Val) (cons (pack Val `(char T)) T)) )
            (initQuery Var (: cls) Hook Val)
            (and
               (isa '+Sn This)
               (init Tree
                  (cons (setq Val (ext:Snx Val)))
                  (cons (pack Val `(char T)) T) ) ) ) ) ) )

(de _gen (Lst Q)
   (cond
      (Lst
         (use X
            (loop
               (T
                  (cond
                     ((atom (car Lst))
                        (prog1 (car Lst) (set Lst)) )
                     ((atom (caar Lst)) (pop Lst))
                     (T
                        (prog1
                           (step (car Lst) (= '(NIL) (caar (caar Lst))))
                           (or (cdaar Lst) (set Lst)) ) ) )
                  @ )
               (NIL (setq X (_gen (cddr Lst) Q)))
               (set Lst
                  (let Y (cadr Lst)
                     (cond
                        ((atom Y) (get X Y))
                        ((=T (caddr Y))
                           (initQuery (car Y) (cadr Y) X (cadddr Y)) )  # X = Hook
                        (T
                           (initQuery
                              (car Y)
                              (cadr Y)
                              (caddr Y)
                              (if (cadddr Y)
                                 (cons
                                    (cons X (car @))
                                    (cons X (cdr @)) )
                                 X ) ) ) ) ) ) ) ) )
      ((pat? (car Q)) (get (prove (cdr Q)) @))
      (T (step Q (= '(NIL) (caaar Q)))) ) )

(private) (@Obj @X @Lst @P @C)

(be select ((@Obj . @X) . @Lst)
   (^ @ (unify @X))
   (^ @P (box (cdr @Lst)))
   (^ @C
      (box  # ((obj ..) curr . lst)
         (let L
            (or
               (mapcan _select (car @Lst))
               (_select (caar @Lst) T) )
            (cons NIL L L) ) ) )
   (_gen @Obj)
   (^ @ (unify 2))
   (_sel) )

(be _gen (@Obj)
   (^ @
      (let C (caadr (val (-> @C 2)))
         (not (setq *R (_gen (car C) (cdr C)))) ) )
   T
   (fail) )

(be _gen (@Obj) (^ @Obj *R))

(repeat)

(be _sel ()
   (2 (val (-> @P 2)))
   (^ @
      (let C (val (-> @C 2))
         (unless (idx C *R T)
            (rot (cddr C) (offset (cadr C) (cddr C)))
            (set (cdr C) (cddr C)) ) ) )
   T )

(be _sel ()
   (^ @
      (let C (cdr (val (-> @C 2)))
         (set C (or (cdar C) (cdr C))) ) )
   (fail) )

### Remote queries ###
(de rqry Args
   (for (Q (goal (cdr Args)) (prove Q))
      (pr (get @ (car Args)))
      (NIL (flush)) )
   (bye) )

(be remote (@Lst . @CL)
   (^ @Sockets
      (box
         (prog1
            (cdr @Lst)
            (for X @  # (out . in)
               ((car X)
                  (cons 'rqry (car @Lst) @CL) ) ) ) ) )
   (^ @ (unify (car @Lst)))
   (_remote @Lst) )

(be _remote ((@Obj . @))
   (^ @ (not (val (-> @Sockets 2))))
   T
   (fail) )

(be _remote ((@Obj . @))
   (^ @Obj
      (let (Box (-> @Sockets 2)  Lst (val Box))
         (rot Lst)
         (loop
            (T ((cdr (++ Lst))) @)
            (NIL (set Box Lst)) ) ) ) )

(repeat)

(be revolve (@Lst . @CL)
   (^ @Gen
      (prog1 (box)
         (for X (cddr @Lst)
            (push @
               (goal
                  (cons (cadr @Lst) (lit X) @CL) ) ) )
         (push @ (car @Lst)) ) )
   (^ @ (unify (car @Lst)))
   (_revolve @Lst) )

(be _revolve ((@Val . @))
   (^ @ (not (cdar (-> @Gen 2))))
   T
   (fail) )

(be _revolve ((@Val . @))
   (^ @Val
      (let L (val (-> @Gen 2))
         (rot (cdr L))
         (loop
            (T (prove (cadr L))
               (get @ (car L)) )
            (NIL (con L (cddr L))) ) ) ) )

(repeat)
pil21/lib/dbgc.l0000644000000000000000000000272114437033160010520 0ustar  # 04jun23 Software Lab. Alexander Burger

### DB Garbage Collection ###

(private) (markData markExt)

(de markExt (S)
   (unless (mark S T)
      (markData (val S))
      (maps markData S)
      (wipe S) ) )

(de markData (X)
   (while (pair X)
      (markData (++ X)) )
   (and (ext? X) (markExt X)) )

(let Cnt 0
   (dbSync)
   (markExt *DB)
   (for L *ExtDBs  # ("path/"  )
      (let ((P N E) L  Lck)
         (for I N
            (let (Fd (open (pack P (hax (dec I))))  (Cnt . Siz) (blk Fd 0))
               (and (=1 I) (setq Lck Fd))
               (for Blk (dec Cnt)
                  (mapc markExt
                     (fish ext? (ext E (blk Fd Blk Siz Lck))) ) )
               (close Fd) ) ) ) )
   (finally (mark 0)
      (for (F . @) (or *Dbs (2))
         (for (S (seq F)  S  (seq S))
            (unless (mark S)
               (inc 'Cnt)
               (and (isa '+Entity S) (zap> S))
               (zap S) ) ) ) )
   (when *Blob
      (use (@S @R F S)
         (let Pat (conc (chop *Blob) '(@S "." @R))
            (in (list 'find *Blob "-type" "f")
               (while (setq F (line))
                  (when (match Pat F)
                     (unless
                        (and
                           (setq S (extern (pack (delete "/" @S T))))
                           (get S (intern @R)) )
                        (inc 'Cnt)
                        (%@ "unlink" NIL (pack F)) )
                     (wipe S) ) ) ) ) ) )
   (commit)
   (gt0 Cnt) )
pil21/lib/too.l0000644000000000000000000003471314516734724010444 0ustar  # 27oct23 Software Lab. Alexander Burger

(private) (Prg C Q X Y Cls Name)

(de admin Prg
   (out 2
      (prinl *Pid " + Admin " (stamp))
      (tell 'bye)
      (for (F . @) (or *Dbs (2))
         (when (dbck F)
            (quit "DB Check" (cons F @)) ) )
      (run Prg)
      (when (load "@lib/dbgc.l")
         (prinl "dbgc " @) )
      (prinl *Pid " - Admin " (stamp)) ) )

### Local Backup ###
(de snapshot (Dst . @)
   (when (info (pack Dst "/1"))
      (for (L (flip (sort (extract format (dir Dst))))  L)
         (let N (++ L)
            (call "mv" (pack Dst '/ N) (pack Dst '/ (inc N)))
            (when (> (car L) (*/ N 59 60))
               (call "rm" "-rf" (pack Dst '/ (++ L))) ) ) ) )
   (when (call "mkdir" (pack Dst "/1"))
      (let Ign NIL
         (while (args)
            (let A (next)
               (if (pre? "-" A)
                  (push 'Ign (pack (cdr (chop A))))
                  (let
                     (Lst (filter bool (split (chop A) '/))
                        Src (car Lst)
                        Old (pack Dst "/2/" Src)
                        New (pack Dst "/1/" Src) )
                     (recur (Lst Src Old New)
                        (ifn (cdr Lst)
                           (recur (Src Old New)
                              (unless (member Src Ign)
                                 (cond
                                    ((=T (car (info Src T)))  # Directory
                                       (call "mkdir" "-p" New)
                                       (for F (dir Src T)
                                          (unless (member F '("." ".."))
                                             (recurse
                                                (pack Src '/ F)
                                                (pack Old '/ F)
                                                (pack New '/ F) ) ) )
                                       (call "touch" "-r" Src New) )
                                    ((= (info Src T) (info Old T))  # Same
                                       (%@ "link" 'I Old New) )
                                    (T (call "cp" "-a" Src New)) ) ) )  # Changed or new
                           (call "mkdir" "-p" New)
                           (recurse
                              (cdr Lst)
                              (pack Src '/ (cadr Lst))
                              (pack Old '/ (cadr Lst))
                              (pack New '/ (cadr Lst)) )
                           (call "touch" "-r" Src New) ) ) ) ) ) ) ) ) )

(de purge (Dst N)
   (for D (dir Dst)
      (when (>= (format D) N)
         (call "rm" "-rf" (pack Dst '/ D)) ) ) )

### DB Garbage Collection ###
(de dbgc ()
   (load "@lib/dbgc.l") )

### DB Mapping ###
(private) (ObjFun TreeFun Hook Base)

(de dbMap (ObjFun TreeFun)
   (default ObjFun quote TreeFun quote)
   (finally (mark 0)
      (_dbMap *DB)
      (dbMapT *DB) ) )

(de _dbMap (Hook)
   (unless (mark Hook T)
      (ObjFun Hook)
      (for X (getl Hook)
         (when (pair X)
            (if
               (and
                  (ext? (car X))
                  (not (isa '+Entity (car X)))
                  (sym? (cdr X))
                  (find
                     '((X) (isa '+relation (car X)))
                     (getl (cdr X)) ) )
               (let (Base (car X)  Cls (cdr X))
                  (dbMapT Base)
                  (for X (getl Base)
                     (when
                        (and
                           (pair X)
                           (sym? (cdr X))
                           (pair (car X))
                           (num? (caar X))
                           (ext? (cdar X)) )
                        (TreeFun Base (car X) (cdr X) Cls Hook)
                        (iter (tree (cdr X) Cls Hook) _dbMap) ) )
                  (wipe Base) )
               (dbMapV (car X)) ) ) )
      (wipe Hook) ) )

(de dbMapT (Base)
   (let X (val Base)
      (when
         (and
            (pair X)
            (num? (car X))
            (ext? (cdr X)) )
         (TreeFun Base X)
         (iter Base dbMapV) ) ) )

(de dbMapV (X)
   (while (pair X)
      (dbMapV (++ X)) )
   (and (ext? X) (_dbMap X)) )

(de refObj (Obj Flg)
   (make
      (recur (Obj)
         (for (F . @) (or *Dbs (2))
            (for (This (seq F) This (seq This))
               (when
                  (or
                     (fish == (val This) NIL Obj)
                     (fish == (getl This) NIL Obj) )
                  (if (and Flg (: T))
                     (recurse This)
                     (link This) ) ) ) ) )
      (for L *ExtDBs  # ("path/"  )
         (let ((P N E) L  Lck)
            (for I N
               (let (Fd (open (pack P (hax (dec I))))  (Cnt . Siz) (blk Fd 0))
                  (and (=1 I) (setq Lck Fd))
                  (for Blk (dec Cnt)
                     (let B (ext E (blk Fd Blk Siz Lck))
                        (when (fish == B NIL Obj)
                           (link (cons P (id I Blk))) ) ) )
                  (close Fd) ) ) ) ) ) )

### DB Check ###
(de dbCheck ()
   (for (F . N) (or *Dbs (2))  # Low-level integrity check
      (unless (pair (println F N (dbck F T)))
         (quit 'dbck @) ) )
   (dbSync)
   (dbMap  # Check tree structures
      NIL
      '((Base Root Var Cls Hook)
         (println Base Root Var Cls Hook)
         (unless (= (car Root) (chkTree (cdr Root)))
            (quit "Tree size mismatch") )
         (when Var
            (scan (tree Var Cls Hook)
               '((K V)
                  (or
                     (isa Cls V)
                     (isa '+Alt (meta V Var))
                     (quit "Bad Type" V) )
                  (unless (has> V Var (if (pair K) (car K) K))
                     (quit "Bad Value" K) ) )
               NIL T T ) ) ) )
   (and *Dbs (dbfCheck))  # Check DB file assignments
   (and (dangling) (println 'dangling @))  # Show dangling index references
   (and (badECnt) (println 'badECnt @))  # Show entity count mismatches
   (rollback) )

# Check Index References
(de dangling ()
   (make
      (for (F . @) (or *Dbs (2))
         (for (Obj (seq F) Obj (seq Obj))
            (and
               (isa '+Entity Obj)
               (dangle Obj)
               (link @) )
            (wipe Obj) ) ) ) )

(de dangle (This)
   (unless (: T)
      (and
         (make
            (for X (getl This)
               (let V (or (atom X) (++ X))
                  (unless (rel?> This X V)
                     (link X) ) ) ) )
         (cons This @) ) ) )

# Entity Counts
(de badECnt ()
   (let Cnt NIL
      (for (F . @) (or *Dbs (2))
         (for (This (seq F) This (seq This))
            (and
               (isa '+Entity This)
               (not (: T))
               (for Cls (type This)
                  (recur (Cls)
                     (or
                        (== '+Entity Cls)
                        (when (isa '+Entity Cls)
                           (for C (type Cls)
                              (recurse C) )
                           (accu 'Cnt Cls 1) ) ) ) ) ) ) )
      (filter
         '((X)
            (<> (cdr X) (get *DB (car X) 0)) )
         Cnt ) ) )

(de fixECnt ()
   (for X (getl *DB)
      (and (pair X) (set (car X) 0)) )
   (for (F . @) (or *Dbs (2))
      (for (This (seq F) This (seq This))
         (and
            (isa '+Entity This)
            (not (: T))
            (incECnt This) )
         (at (0 . 10000) (commit)) ) )
   (commit) )

(de badDep (X Var)
   (let Lst (get (fin X) Var 'dep)
      (make
         (forall X
            (unless (get This Var)
               (when
                  (extract
                     '((S) (and (get This S) S))
                     Lst )
                  (link (cons This @)) ) ) ) ) ) )

### Rebuild tree ###
(de rebuild (X Var Cls Hook)
   (let Lst NIL
      (let? Base (get (or Hook *DB) Cls)
         (unless X
            (setq Lst
               (if (; (treeRel Var Cls) hook)
                  (collect Var Cls Hook)
                  (collect Var Cls) ) ) )
         (zapTree (get Base Var -1))
         (put Base Var NIL)
         (commit) )
      (nond
         (X
            (let Len (length Lst)
               (recur (Lst Len)
                  (unless (=0 Len)
                     (let (N (>> 1 (inc Len))  L (nth Lst N))
                        (re-index (car L) Var Hook)
                        (recurse Lst (dec N))
                        (recurse (cdr L) (- Len N)) ) ) ) ) )
         ((atom X)
            (for Obj X
               (re-index Obj Var Hook) ) )
         (NIL
            (for (Obj (seq X) Obj (seq Obj))
               (and (isa Cls Obj) (re-index Obj Var Hook)) ) ) )
      (commit) ) )

(de re-index (Obj Var Hook)
   (unless (get Obj T)
      (when (get Obj Var)
         (rel> (meta Obj Var) Obj NIL
            (put> (meta Obj Var) Obj NIL @)
            Hook )
         (at (0 . 10000) (commit)) ) ) )

### Database file management ###
(de dbfCheck ()
   (for Cls (all)
      (when
         (and
            (= `(char "+") (char Cls))
            (isa '+Entity Cls)
            (not (isa '+Remote Cls)) )
         (or
            (; Cls Dbf)
            (meta Cls 'Dbf)
            (println 'dbfCheck Cls) )
         (for Rel (getl Cls)
            (and
               (pair Rel)
               (isa '+relation (car Rel))
               (or
                  (isa '+index (car Rel))
                  (isa '+Swap (car Rel))
                  (find
                     '((B)
                        (or
                           (isa '+index B)
                           (isa '+Swap B) ) )
                     (; Rel 1 bag) ) )
               (not (; @ dbf))
               (println 'dbfCheck (cdr Rel) Cls) ) ) ) ) )

(de displaced ()
   (make
      (for (F . @) *Dbs
         (for (Obj (seq F) Obj (seq Obj))
            (when
               (or
                  (isa '+Remote Obj)
                  (and
                     (isa '+Entity Obj)
                     (<>
                        (meta Obj 'Dbf 1)
                        (car (id Obj T)) ) ) )
               (link Obj) )
            (wipe Obj) ) ) ) )

### Relocate Object ###
(dm (move!> . +Entity) (Dbf)
   (for L *ExtDBs  # ("path/"  )
      (let ((P N E) L  Lck)
         (for I N
            (let (Fd (open (pack P (hax (dec I))))  (Cnt . Siz) (blk Fd 0))
               (finally (close Fd)
                  (and (=1 I) (setq Lck Fd))
                  (for Blk (dec Cnt)
                     (let B (ext E (blk Fd Blk Siz Lck))
                        (when (fish == B NIL This)
                           (quit "Can't move" (cons P (id I Blk))) ) ) ) ) ) ) ) )
   (dbSync)
   (let New
      (new
         (or Dbf (meta This 'Dbf 1))
         (val This) )
      (for X (getl This)
         (if (atom X)
            (ifn (meta This X)
               (put New X T)
               (let Rel @
                  (if (isa '+Blob Rel)
                     (let F (blob This X)
                        (put> New X F)
                        (blob+ New X)
                        (%@ "unlink" NIL F) )
                     (lose> Rel This T)
                     (put> New X T) ) ) )
            (ifn (meta This (cdr X))
               (put New (cdr X) (car X))
               (lose> @ This (car X))
               (put> New (cdr X) (car X)) ) ) )
      (decECnt This)
      (=: T T)
      (for (F . @) *Dbs
         (for (Obj (seq F) Obj (seq Obj))
            (let L (getl Obj)
               (when (fish == L This)
                  (for X L
                     (let? Rel (and (pair X) (meta Obj (cdr X)))
                        (put> Obj (cdr X)
                           (fill
                              (if (isa '+Swap Rel)
                                 (val (car X))
                                 (car X) )
                              This
                              New ) ) ) ) ) ) ) )
      (commit 'upd)
      New ) )

### Dump Objects ###
(zero *DumpBlob)

(dm (dumpKey> . +Entity) ()
   (unless (: T)
      (pick
         '((X)
            (when (isa '+Key (meta This (fin X)))
               (if (meta This (fin X) 'hook)
                  (cons (fin X) (get This @) X)
                  (cons (fin X) X) ) ) )
         (getl This) ) ) )

(dm (dumpType> . +Entity) ()
   (type This) )

(dm (dumpValue> . +Entity) (X)
   X )

(de dump @
   (let C (cons 0 10000)
      (for (Q (pass search) (search Q))
         (let (Obj @  K (fin (dumpExt Obj)))
            (for X (getl Obj)
               (unless (or (= K (fin X)) (= `(char "+") (char (fin X))))
                  (let? Y (dumpValue> Obj X)
                     (cond
                        ((pair Y)
                           (prinl)
                           (space 3)
                           (if (atom (cdr Y))
                              (printsp (cdr Y))
                              (printsp (cadr Y))
                              (prin "`") )
                           (dumpVal (car Y)) )
                        ((isa '+Blob (meta Obj X))
                           (let F (blob Obj X)
                              (ifn (info F)
                                 (msg F " no blob")
                                 (prinl)
                                 (space 3)
                                 (prin Y " `(tmp " (inc '*DumpBlob) ")")
                                 (call "cp" "-a" F (tmp *DumpBlob)) ) ) )
                        (T
                           (prinl)
                           (space 3)
                           (print Y T) ) ) ) ) )
            (prinl " )") )
         (at C (println '(commit))) )
      (println '(commit)) ) )

(de dumpExt (Obj)
   (prin "(obj ")
   (let K (dumpKey> Obj)
      (ifn (last K)
         (print (dumpType> Obj) (id Obj T))
         (prin "(")
         (printsp (dumpType> Obj) (car K))
         (dumpVal (cadr K))
         (when (pair (cddr K))
            (space)
            (dumpVal (car @)) )
         (prin ")") )
      K ) )

(de dumpVal (X)
   (nond
      ((atom X)
         (prin "(")
         (dumpVal (++ X))
         (while (pair X)
            (space)
            (dumpVal (++ X)) )
         (when X (prin " . ") (dumpVal X))
         (prin ")") )
      ((ext? X) (print X))
      ((type X) (print (val X)))
      (NIL (prin "`") (dumpExt X) (prin ")")) ) )

# Dump/load data and blobs
(de dumpDB (Name . Prg)
   (out (pack Name ".l") (run Prg))
   (when (dir (tmp))
      (out (pack Name ".tgz")
         (chdir (tmp)
            (in (append '("tar" "cfz" "-") (filter format @))
               (echo) ) ) ) ) )

(de loadDB (Name)
   (let Tgz (pack Name ".tgz")
      (when (and (info Tgz) (n0 (car @)))
         (in Tgz
            (chdir (tmp)
               (out '("tar" "xfz" "-") (echo)) ) ) ) )
   (load (pack Name ".l") ) )
pil21/lib/debug.l0000644000000000000000000002730714533310176010720 0ustar  # 04dec23 Software Lab. Alexander Burger

# Prompt
(de *Prompt
   (casq (car (symbols)) (pico) (T @)) )

(private) (_who _match nest nst1 nst2 C D E M S X Y Z Fun Prg Who dep1 dep2)

# Edit history
(de h ()
   (let F (tmp "history")
      (out F
         (mapc prinl (history)) )
      (and
         (vi (cons T F))
         (history
            (in F
               (make (while (line T) (link @))) ) )
         T ) ) )

# Browsing
(de help (Sym Ex)
   (when (; Sym doc)
      (prinl "========================================")
      (in @
         (from
            (pack
               "
" "%3E"
                  "\^" "%5E"
                  "|" "%7C")
               "\">" ) )
         (out '("w3m" "-T" "text/html" "-dump")
            (prin "
")
            (echo "")
            (echo "
")
            (prinl "
")
            (echo "\n
")
            (ifn Ex
               (prinl "

")
               (prin "
")
               (prinl (echo "\n
")) ) ) ) )
   Sym )

(de docs (Dir)
   (when (=T (car (info Dir)))
      (let All (all)
         (for F (dir Dir)
            (when (match '("r" "e" "f" @ "." "h" "t" "m" "l") (chop F))
               (let P (pack Dir F)
                  (in P
                     (while (from "
" "%3E"
                     "\^" "%5E"
                     "|" "%7C" ) )
               "@doc/ref.html" ) ) ) ) )

(de more (M Fun)
   (let *Dbg NIL
      (if (pair M)
         ((default Fun println) (++ M))
         (println (type M))
         (setq
            Fun (list '(X) (list 'pp 'X (lit M)))
            M (mapcar car (filter pair (val M))) ) )
      (loop
         (T (atom M))
         (T (= "\e" (key)) T)
         (Fun (++ M)) ) ) )

(de what (S)
   (let *Dbg NIL
      (setq S (chop S))
      (filter
         '(("X") (match S (chop "X")))
         (all) ) ) )

(de who (X . Prg)
   (let (*Dbg NIL  Who '(Who @ @@ @@@))
      (make (mapc _who (all))) ) )

(and noLint (@ 'who 'Prg))

(de _who (Y)
   (unless (or (ext? Y T) (memq Y Who))
      (push 'Who Y)
      (ifn (= `(char "+") (char Y))
         (and (pair (val Y)) (nest @) (link Y))
         (for Z (pair (val Y))
            (if (atom Z)
               (and (_match Z) (link Y))
               (when (nest (cdr Z))
                  (link (cons (car Z) Y)) ) ) )
         (maps
            '((Z)
               (if (atom Z)
                  (and (_match Z) (link Y))
                  (when (nest (car Z))
                     (link (cons (cdr Z) Y)) ) ) )
            Y ) ) ) )

(de nest (Y)
   (nst1 Y)
   (nst2 Y) )

(de nst1 (Y)
   (let Z (setq Y (strip Y))
      (loop
         (T (atom Y) (and (sym? Y) (_who Y)))
         (and (sym? (car Y)) (_who (car Y)))
         (and (pair (car Y)) (nst1 @))
         (T (== Z (setq Y (cdr Y)))) ) ) )

(de nst2 (Y)
   (let Z (setq Y (strip Y))
      (loop
         (T (atom Y) (_match Y))
         (T (or (_match (car Y)) (nst2 (car Y)))
            T )
         (T (== Z (setq Y (cdr Y)))) ) ) )

(de _match (D)
   (and
      (cond
         ((str? X) (and (str? D) (= X D)))
         ((sym? X) (== X D))
         (T (match X D)) )
      (or
         (not Prg)
         (let *Dbg (up 2 *Dbg) (run Prg)) ) ) )

(de has (X)
   (let *Dbg NIL
      (filter
         '((S) (= X (val S)))
         (all) ) ) )

(de can (X)
   (let *Dbg NIL
      (extract
         '((Y)
            (and
               (= `(char "+") (char Y))
               (asoq X (val Y))
               (cons X Y) ) )
         (all) ) ) )

(private) (Flg Nsp Lst Sym N L S)

# Namespaces nested in current search order
(de namespaces (Flg)
   (let N 3
      (make
         (for Nsp (symbols)
            (recur (Nsp N)
               (link Nsp)
               (when Flg
                  (space N)
                  (println Nsp) )
               (for S (all Nsp)
                  (and
                     (pair (val S))
                     (== '\~ (car @))
                     (not (memq S (made)))
                     (recurse S (+ N 3)) ) ) ) ) ) ) )

# Namespace shadowing
(de shadows (Flg)
   (let Lst (mapcan all (symbols))
      (make
         (while (cdr Lst)
            (let Sym (++ Lst)
               (unless (member Sym (made))
                  (let? L
                     (filter
                        '((S)
                           (and
                              (= S Sym)
                              (n== S Sym)
                              (val S) ) )
                        Lst )
                     (when Flg
                        (space 3)
                        (apply println L Sym) )
                     (link Sym) ) ) ) ) ) ) )

# Class dependencies
(de dep (C)
   (let *Dbg NIL
      (dep1 0 C)
      (dep2 3 C)
      C ) )

(de dep1 (N C)
   (for X (type C)
      (dep1 (+ 3 N) X) )
   (space N)
   (println C) )

(de dep2 (N C)
   (for X (all)
      (when
         (and
            (= `(char "+") (char X))
            (memq C (type X)) )
         (space N)
         (println X)
         (dep2 (+ 3 N) X) ) ) )

# Inherited methods
(de methods (Obj)
   (make
      (let Mark NIL
         (recur (Obj)
            (for X (val Obj)
               (nond
                  ((pair X) (recurse X))
                  ((memq (car X) Mark)
                     (link (cons (car X) Obj))
                     (push 'Mark (car X)) ) ) ) ) ) ) )

(private) (_dbg _dbg2 dbg ubg traced? U)

# Single-Stepping
(de _dbg (Lst)
   (or
      (atom (car Lst))
      (num? (caar Lst))
      (flg? (caar Lst))
      (== '! (caar Lst))
      (set Lst (cons '! (car Lst))) ) )

(de _dbg2 (Lst)
   (map
      '((L)
         (if (and (pair (car L)) (flg? (caar L)))
            (map _dbg (cdar L))
            (_dbg L) ) )
      Lst ) )

(de dbg (Lst)
   (when (pair Lst)
      (casq (++ Lst)
         ((case casq state)
            (_dbg Lst)
            (for L (cdr Lst)
               (map _dbg (cdr L)) ) )
         ((cond nond)
            (for L Lst
               (map _dbg L) ) )
         (quote
            (when (fun? Lst)
               (map _dbg (cdr Lst)) ) )
         ((job use let let? recur)
            (map _dbg (cdr Lst)) )
         (loop
            (_dbg2 Lst) )
         ((bind do)
            (_dbg Lst)
            (_dbg2 (cdr Lst)) )
         (for
            (and (pair (car Lst)) (map _dbg (cdar Lst)))
            (_dbg2 (cdr Lst)) )
         (T (map _dbg Lst)) )
      T ) )

(de d ()
   (let *Dbg NIL
      (dbg ^) ) )

(de -debug ()
   (debug (intern (opt))) )

(de debug (X C)
   (ifn (traced? X C)
      (let *Dbg NIL
         (when (pair X)
            (setq C (cdr X)  X (car X)) )
         (or
            (dbg (if C (method X C) (getd X)))
            (quit "Can't debug" X) ) )
      (untrace X C)
      (debug X C)
      (trace X C) ) )

(de ubg (Lst)
   (when (pair Lst)
      (map
         '((L)
            (when (pair (car L))
               (when (== '! (caar L))
                  (set L (cdar L)) )
               (ubg (car L)) ) )
         Lst )
      T ) )

(de u ()
   (let *Dbg NIL
      (ubg ^) ) )

(de unbug (X C)
   (let *Dbg NIL
      (when (pair X)
         (setq C (cdr X)  X (car X)) )
      (or
         (ubg (if C (method X C) (getd X)))
         (quit "Can't unbug" X) ) ) )

# Tracing
(de traced? (X C)
   (setq X
      (if C
         (method X C)
         (getd X) ) )
   (and
      (pair X)
      (pair (cadr X))
      (== '$ (caadr X)) ) )

# Convert ((X Y) A B) --> ((X Y) ($ foo (X Y) A B))
(de -trace ()
   (trace (intern (opt))) )

(de trace (X C)
   (let *Dbg NIL
      (when (pair X)
         (setq C (cdr X)  X (car X)) )
      (if C
         (unless (traced? X C)
            (or (method X C) (quit "Can't trace" X))
            (con @
               (cons
                  (conc
                     (list '$ (cons X C) (car @))
                     (cdr @) ) ) ) )
         (unless (traced? X)
            (and (sym? (getd X)) (quit "Can't trace" X))
            (and (num? (getd X)) (expr X))
            (set X
               (list
                  (car (getd X))
                  (conc (list '$ X) (getd X)) ) ) ) )
      X ) )

# Convert ((X Y) ($ foo (X Y) A B)) --> ((X Y) A B)
(de untrace (X C)
   (let *Dbg NIL
      (when (pair X)
         (setq C (cdr X)  X (car X)) )
      (if C
         (when (traced? X C)
            (con
               (method X C)
               (cdddr (cadr (method X C))) ) )
         (when (traced? X)
            (let Y (set X (cddadr (getd X)))
               (and
                  (== '@ (++ Y))
                  (=1 (length Y))
                  (= 2 (length (car Y)))
                  (== 'pass (caar Y))
                  (sym? (cdadr Y))
                  (subr X) ) ) ) )
      X ) )

(de *NoTrace
   @ @@ @@@
   pp show more led
   what who can dep d e debug u unbug trace untrace )

(de traceAll (Excl)
   (let *Dbg NIL
      (for X (all)
         (or
            (memq X Excl)
            (memq X *NoTrace)
            (= `(char "*") (char X))
            (cond
               ((= `(char "+") (char X))
                  (mapc trace
                     (extract
                        '((Y)
                           (and
                              (pair Y)
                              (fun? (cdr Y))
                              (cons (car Y) X) ) )
                        (val X) ) ) )
               ((pair (getd X))
                  (trace X) ) ) ) ) ) )

# Process Listing
(when (member *OS '("Android" "Linux"))
   (de proc @
      (apply call
         (make (while (args) (link "-C" (next))))
         "ps" "-H" "-o" "pid,ppid,start,size,pcpu,cmd" ) ) )

# Benchmarking
(de bench Prg
   (let U (usec)
      (prog1
         (run Prg 1)
         (out 2
            (prinl
               (format (*/ (- (usec) U) 1000) 3)
               " sec" ) ) ) ) )

# Backtrace
(de bt (Flg)
   (let (S NIL  *Dbg)
      (for (L (trail T) L)
         (if (pair (car L))
            (let E (++ L)
               (push 'S
                  (list
                     (if (getd (box? (car E)))
                        (cons @ (cdr E))
                        E ) ) ) )
            (conc
               (car (default S (cons (cons))))
               (cons (cons (++ L) (++ L))) ) )
         (T (== '^ (car L)))
         (T
            (and
               (pair (car L))
               (== 'bt (caar L)) ) ) )
      (for L S
         (let? X (++ L)
            (pretty
               (cons
                  (or
                     (and (sym? (car X)) (car X))
                     (find
                        '((S) (== (car X) (val S)))
                        (all) )
                     (car X) )
                  (less (cdr X)) ) ) )
         (prinl)
         (while L
            (space 3)
            (println (caar L) (less (cdr (++ L)))) )
         (NIL (or Flg (<> "\e" (key))) T) ) ) )

# Source code
`(info "@lib/map")

(symbols 'llvm 'pico)

(in "@lib/map"
   (while (read)
      (let Sym @
         (if (get Sym '*Dbg)
            (set @ (read))
            (put Sym '*Dbg (cons (read))) ) ) ) )
pil21/lib/lint.l0000644000000000000000000002110414753314265010574 0ustar  # 13feb25 Software Lab. Alexander Burger

# *NoLint

(private) (global? local? dlsym? lint1 lint2 lintVar lintDup lintLoop
_lintq lintFun A C Lst S X Y *L *X *Var *Dup *Def *Bnd *Use)

(de noLint (X V)
   (if V
      (push1 '*NoLint (cons X V))
      (push1q '*NoLint X) ) )

(de global? (S)
   (or
      (memq S '(NIL ^ @ @@ @@@ This T))
      (member (char S) '(`(char '*) `(char '+)))
      (== '\~ (car (pair (val S))))
      (memq S *NoLint)
      (and
         (>= (length S) 4)
         (fully upp? (delete "-" (chop S))) ) ) )

(de local? (S)
   (or
      (str? S)
      (member (char S) '(`(char '*) `(char '_))) ) )

(de dlsym? (S)
   (and
      (car (setq S (split (chop S) ':)))
      (cadr S)
      (low? (caar S)) ) )

(de lint1 (X)
   (cond
      ((atom X)
         (when (sym? X)
            (cond
               ((memq X *L) (setq *Use (delq X *Use)))
               ((local? X) (lint2 (val X)))
               (T
                  (or
                     (getd X)
                     (global? X)
                     (member (cons *X X) *NoLint)
                     (push1q '*Bnd X) ) ) ) ) )
      ((num? (car X)))
      (T
         (casq (car X)
            ((: ::))
            (; (lint1 (cadr X)))
            (quote
               (let F (fun? (cdr X))
                  (if (or (and (pair F) (not (fin @))) (== '@ F))
                     (use *L (lintFun (cdr X)))
                     (lint2 (cdr X)) ) ) )
            ((de dm)
               (let *X (cadr X)
                  (lintFun (cddr X)) ) )
            (recur
               (let recurse (cdr X)
                  (lintFun recurse) ) )
            (tco
               (lintFun (cdr X)) )
            (task
               (lint1 (cadr X))
               (let Y (cddr X)
                  (use *L
                     (while (num? (car Y))
                        (++ Y) )
                     (while (and (car Y) (sym? @))
                        (lintVar (++ Y))
                        (lint1 (++ Y)) )
                     (mapc lint1 Y) ) ) )
            (macro
               (lint2 (cdr X)) )
            ((let? buf)
               (use *L
                  (lintVar (cadr X))
                  (mapc lint1 (cddr X)) ) )
            (let
               (use *L
                  (if (atom (cadr X))
                     (lintVar (cadr X))
                     (for (L (cadr X) L (cddr L))
                        (if (pair (car L))
                           (mapc lintVar
                              (fish
                                 '((X) (and X (atom X)))
                                 (car L) ) )
                           (lintVar (car L)) )
                        (lint1 (cadr L)) ) )
                  (mapc lint1 (cddr X)) ) )
            (use
               (use *L
                  (if (atom (cadr X))
                     (lintVar (cadr X))
                     (mapc lintVar (cadr X)) )
                  (mapc lint1 (cddr X)) ) )
            (for
               (use *L
                  (let Y (cadr X)
                     (cond
                        ((atom Y)            # (for X (1 2 ..) ..)
                           (lint1 (caddr X))
                           (lintVar Y)
                           (lintLoop (cdddr X)) )
                        ((atom (cdr Y))      # (for (I . X) (1 2 ..) ..)
                           (lintVar (car Y))
                           (lint1 (caddr X))
                           (lintVar (cdr Y))
                           (lintLoop (cdddr X)) )
                        ((atom (car Y))      # (for (X (1 2 ..) ..) ..)
                           (lint1 (cadr Y))
                           (lintVar (car Y))
                           (mapc lint1 (cddr Y))
                           (lintLoop (cddr X)) )
                        (T                     # (for ((I . L) (1 2 ..) ..) ..)
                           (lintVar (caar Y))
                           (lint1 (cadr Y))
                           (lintVar (cdar Y))
                           (mapc lint1 (cddr Y))
                           (lintLoop (cddr X)) ) ) ) ) )
            ((case casq state)
               (lint1 (cadr X))
               (for X (cddr X)
                  (mapc lint1 (cdr X)) ) )
            ((cond nond)
               (for X (cdr X)
                  (mapc lint1 X) ) )
            (loop
               (lintLoop (cdr X)) )
            (do
               (lint1 (cadr X))
               (lintLoop (cddr X)) )
            (=:
               (lint1 (last (cddr X))) )
            ((dec inc pop push push1 queue fifo val idx accu)
               (_lintq '(T)) )
            ((onOff default)
               (and (atom (cadr X)) (lint1 (cadr X))) )
            ((cut port)
               (_lintq '(NIL T)) )
            (set
               (_lintq '(T NIL .)) )
            (xchg
               (_lintq '(T T .)) )
            (T
               (cond
                  ((pair (car X))
                     (lint1 @)
                     (mapc lint2 (cdr X)) )
                  ((memq (car X) *L)
                     (setq *Use (delq (car X) *Use))
                     (mapc lint2 (cdr X)) )
                  ((fun? (val (car X)))
                     (if (num? @)
                        (mapc lint1 (cdr X))
                        (when (local? (car X))
                           (lint2 (val (car X))) )
                        (let Y (car (getd (++ X)))
                           (while (and (pair X) (pair Y))
                              (lint1 (++ X))
                              (++ Y) )
                           (if (or (== '@ Y) (= "Prg" Y) (= "*Prg" Y))
                              (mapc lint1 X)
                              (lint2 X) ) ) ) )
                  (T
                     (or
                        (str? (car X))
                        (dlsym? (car X))
                        (== '@ (car X))
                        (memq (car X) *NoLint)
                        (push1q '*Def (car X)) )
                     (mapc lint1 (cdr X)) ) ) ) ) ) ) )

(de lint2 (X Mark)
   (cond
      ((memq X Mark))
      ((atom X)
         (and (memq X *L) (setq *Use (delq X *Use))) )
      (T (lint2 (car X))
         (lint2 (cdr X) (cons X Mark)) ) ) )

(de lintVar (X Flg)
   (cond
      ((or
            (not (sym? X))
            (memq X '(NIL *DB *Solo ^ meth quote T)) )
         (push '*Var X) )
      ((not (global? X))
         (unless (member (cons *X X) *NoLint)
            (or Flg (push1q '*Use X))
            (and (low? X) (push '*Var X)) )
         (push '*L X) ) ) )

(de lintDup (X Lst)
   (and
      (memq X Lst)
      (not (member (cons *X X) *NoLint))
      (push '*Dup X) ) )

(de lintLoop (Lst)
   (for Y Lst
      (if (and (pair Y) (or (=T (car Y)) (not (car Y))))
         (mapc lint1 (cdr Y))
         (lint1 Y) ) ) )

(de _lintq (Lst)
   (mapc
      '((X Flg)
         (lint1 (if Flg (strip X) X)) )
      (cdr X)
      Lst ) )

(de lintFun (Lst)
   (when (pair Lst)
      (when (car Lst)
         (map
            '(((A . L))
               (lintDup A L)
               (lintVar A T) )
            (fish atom @) ) )
      (mapc lint1 (cdr Lst)) ) )

(de lint (X C)
   (let (*L NIL  *Var NIL  *Dup NIL  *Def NIL  *Bnd NIL  *Use NIL)
      (when (pair X)
         (setq  C (cdr X)  X (car X)) )
      (cond
         (C  # Method
            (let *X (cons X C)
               (lintFun (method X C)) ) )
         ((pair (val X))  # Function
            (let *X X
               (lintFun (val X)) ) )
         ((info X)  # File name
            (let *X X
               (in X (while (read) (lint1 @))) ) )
         (T (quit "Can't lint" X)) )
      (when (or *Var *Dup *Def *Bnd *Use)
         (make
            # Bad variables
            (and *Var (link (cons 'var *Var)))
            # Duplicate parameters
            (and *Dup (link (cons 'dup *Dup)))
            # Undefined functions
            (and *Def (link (cons 'def *Def)))
            # Unbound variables
            (and *Bnd (<> `(char '_) (char X)) (link (cons 'bnd *Bnd)))
            # Unused variables
            (and *Use (link (cons 'use *Use))) ) ) ) )

(de lintAll @
   (let *Dbg NIL
      (make
         (for X (all)
            (cond
               ((and (= `(char "+") (char X)) (pair (val X)))
                  (for Y @
                     (and
                        (pair Y)
                        (pair (cdr Y))
                        (lint (car Y) X)
                        (link (cons (cons (car Y) X) @)) ) ) )
               ((and
                     (not (global? X))
                     (pair (val X))
                     (lint X) )
                  (link (cons X @)) ) ) )
         (while (args)
            (let A (next)
               (and (lint A) (link (cons A @))) ) ) ) ) )
pil21/lib/sq.l0000644000000000000000000000376514533313567010266 0ustar  # 04dec23 Software Lab. Alexander Burger

# (select [var ..] cls [hook] [var val ..])
(de select Lst
   (let
      (Vars
         (make
            (until (pre? "+" (car Lst))
               (unless Lst
                  (quit "Missing class") )
               (link (++ Lst)) ) )
         Cls (++ Lst)
         Hook (and (ext? (car Lst)) (++ Lst)) )
      (default Lst
         (list
            (or
               (and (sym? (car Vars)) (car Vars))
               (recur (Cls)
                  (or
                     (and
                        (find
                           '((X)
                              (isa '(+Need +index) (car (pair X))) )
                           (getl Cls) )
                        (; @ 1 var) )
                     (cdr
                        (maxi caar
                           (getl (get (or Hook *DB) Cls)) ) )
                     (pick recurse (type Cls)) ) ) ) ) )
      (for
         (Q
            (apply search
               (make
                  (loop
                     (prog1 (++ Lst)
                        (link
                           (++ Lst)
                           (list
                              (make (link @ Cls) (and Hook (link Hook))) ) ) )
                     (NIL Lst) ) ) )
            (search Q) )
         (T
            (when (setq This (isa Cls @))
               (ifn Vars
                  (show This)
                  (for X Vars
                     (cond
                        ((pair X)
                           (printsp (eval X)) )
                        ((meta This X)
                           (print> @ (get This X))
                           (space) )
                        (T (printsp (get This X))) ) )
                  (println This) )
               (= "\e" (key)) )
            This ) ) ) )

(dm (print> . +relation) (Val)
   (print Val) )

(dm (print> . +Number) (Val)
   (if (num? Val)
      (prin (format Val (: scl)))
      (print Val) ) )

(dm (print> . +Date) (Val)
   (print (if (num? Val) (datStr Val) Val)) )
pil21/lib/test.l0000644000000000000000000000116014070301136010566 0ustar  # 04jul21 Software Lab. Alexander Burger

### Unit Tests ###
# Local usage:
# ./pil lib/test.l -bye +

# Global usage:
# pil @lib/test.l -bye +

(unless *Dbg
   (quit "Needs debug mode '+'") )

(setq
   *CMD (cmd)
   *PWD (in '(pwd) (line T)) )

(load
   "@test/src/main.l"
   "@test/src/apply.l"
   "@test/src/flow.l"
   "@test/src/sym.l"
   "@test/src/subr.l"
   "@test/src/big.l"
   "@test/src/io.l"
   "@test/src/db.l"
   "@test/src/net.l"
   "@test/src/ext.l"
   "@test/src/ht.l" )

(load "@test/lib.l")
(load "@test/lib/db.l")
(load "@test/lib/misc.l")

(load "@test/lib/lint.l")

(load "@test/lib/math.l")

(msg 'OK)
pil21/test/src/apply.l0000644000000000000000000000634614233510452011753 0ustar  # 01may22 Software Lab. Alexander Burger

### apply ###
(test 6 (apply + (1 2 3)))
(test 360 (apply * (5 6) 3 4))
(test 27 (apply '((X Y Z) (* X (+ Y Z))) (3 4 5)))
(test (5 7 9) (apply mapcar '((1 2 3) (4 5 6)) +))


### pass ###
(test 24 ((quote (N . @) (* N (pass + 6))) 2 1 2 3))


### fun ###
(test '(NIL NIL NIL)
   (mapcar fun
      '(gt0 ((N) (bit? 1 N)) ((N) (> N 4)))
      -2 ) )
(test (2 NIL NIL)
   (mapcar fun
      '(gt0 ((N) (bit? 1 N)) ((N) (> N 4)))
      2 ) )
(test (3 1 NIL)
   (mapcar fun
      '(gt0 ((N) (bit? 1 N)) ((N) (> N 4)))
      3 ) )
(test (7 1 T)
   (mapcar fun
      '(gt0 ((N) (bit? 1 N)) ((N) (> N 4)))
      7 ) )


### maps ###
(let L '((1 . a) (2 . b) flg)
   (test L (let X (box) (putl X (reverse L)) (make (maps link X)))) )


### map ###
(test '((1 2 3) (2 3) (3)) (make (map link (1 2 3))))


### mapc ###
(test (1 2 3) (make (mapc link (1 2 3))))


### maplist ###
(test '(((1 2 3) A B C) ((2 3) B C) ((3) C)) (maplist cons (1 2 3) '(A B C)))


### mapcar ###
(test (5 7 9) (mapcar + (1 2 3) (4 5 6)))
(test (26 38 52 68) (mapcar '((X Y) (+ X (* Y Y))) (1 2 3 4) (5 6 7 8)))


### mapcon ###
(test (1 2 3 4 5 2 3 4 5 3 4 5 4 5 5) (mapcon copy (1 2 3 4 5)))


### mapcan ###
(test '(c b a f e d i h g) (mapcan reverse '((a b c) (d e f) (g h i))))


### filter ###
(test (1 2 3) (filter num? (1 A 2 (B) 3 CDE)))


### extract ###
(let (A NIL  B 1  C NIL  D 2  E NIL  F 3)
   (test (1 2 3)
      (extract val '(A B C D E F)) )
   (test (1 2 3)
      (extract val '(B D E F)) ) )


### seek ###
(test (12 19 22) (seek '((X) (> (car X) 9)) (1 5 8 12 19 22)))
(let (A -1  B 2  C 3)
   (test '(B C) (seek '((L) (gt0 (val (car L)))) '(A B C)))
   (test 2 @@) )


### find ###
(test '(B) (find pair (1 A 2 (B) 3 CDE)))
(test 4 (find > (1 2 3 4 5 6) (6 5 4 3 2 1)))
(test 4 (find '((A B) (> A B)) (1 2 3 4 5 6) (6 5 4 3 2 1)))
(let (A -1  B 2  C 3)
   (test 'B (find '((X) (gt0 (val X))) '(A B C)))
   (test 2 @@) )


### pick ###
(test "Hello"
   (pick '((X) (get X 'str))
      (list (box) (prog1 (box) (put @ 'str "Hello")) (box)) ) )


### fully ###
(test T (fully gt0 (1 2 3)))
(test NIL (fully gt0 (1 -2 3)))

### cnt ###
(test 2 (cnt cdr '((1 . T) (2) (3 4) (5))))


### sum ###
(test 6 (sum val (list (box 1) (box) (box 2) (box 'a) (box 3))))


### maxi mini ###
(let (A 1 B 2 C 3)
   (test 'C (maxi val '(A B C)))
   (test 3 @@)
   (test 'A (mini val '(A B C)))
   (test 1 @@)
   (test '(A B C) (by val sort '(C A B))) )


### fish ###
(test (1 2 3)
   (fish gt0 '(a -2 (1 b (-3 c 2)) 3 d -1)) )
(test (-2 1 -3 -1)
   (fish < '(a -2 (1 b (-3 c 2)) 3 d -1) NIL 2) )
(test '(a b c d)
   (fish sym? '(a -2 (1 b (-3 c 2)) 3 d -1)) )
(test (3 7)
   (fish
      '((X)
         (if (and (pair X) (=1 (car X)))
            "skip"
            (gt0 X) ) )
      '(a -2 (1 b (-3 c 2)) 3 d -1 7)
      "skip" ) )
(test '(b b)
   (fish == '(a 1 (b (3 b)) 3) NIL 'b) )


### by ###
(test '(A B C)
   (let (A 1 B 2 C 3)
      (by val sort '(C A B)) ) )
(test '((3 11 9 5 7 1) (6 2 4 10 12 8))
   (by '((N) (bit? 1 N))
      group
      (3 11 6 2 9 5 4 10 12 7 8 1) ) )
(test '(("x" "x" "x") ("y") ("z" "z"))
   (by name group '("x" "x" "y" "z" "x" "z")) )
(test '((123 "xyz") ((1 2) "XY") ("abcd" (1 2 3 4)))
   (by length group '(123 (1 2) "abcd" "xyz" (1 2 3 4) "XY")) )
pil21/test/src/big.l0000644000000000000000000000712213737115263011371 0ustar  # 06oct20 Software Lab. Alexander Burger

### format ###
(scl 0)
(test "123456789" (format 123456789))
(test "12346" (format 12345.6789))
(test "1234567.89" (format 123456789 2))
(test "1234567,89" (format 123456789 2 ","))
(test "1.234.567,89" (format 123456789 2 "," "."))
(test 123456789 (format "123456789"))
(test 12345678900 (format "1234567.89" 4))
(test NIL (format "1.234.567,89"))
(test 12345678900 (format "1234567,89" 4 ","))
(test NIL (format "1.234.567,89" 4 ","))
(test 12345678900 (format "1.234.567,89" 4 "," "."))
(test 123456 (format (1 "23" (4 5 6))))


### + ###
(test 6 (+ 1 2 3))
(test 0 (+ 1 2 -3))
(test NIL (+ NIL 7))


### - ###
(test -7 (- 7))
(test 7 (- -7))
(test 6 (- 7 2 -1))
(test NIL (- NIL 7))


### inc ###
(test 8 (inc 7))
(test -6 (inc -7))
(test 0 (inc -1))
(test 1 (inc 0))
(test (8 -6 0 1) (let L (7 -7 -1 0) (map inc L) L))
(test NIL (inc NIL))
(let N 0
   (test 1 (inc 'N))
   (test 1 N)
   (test 8 (inc 'N 7))
   (test 8 N) )
(let L (1 2 3 4)
   (test 3 (inc (cdr L)))
   (test (1 3 3 4) L) )


### dec ###
(test 7 (dec 8))
(test -8 (dec -7))
(test -1 (dec 0))
(test (7 -8 -1) (let L (8 -7 0) (map dec L) L))
(test NIL (dec NIL))
(let N 7
   (test 6 (dec 'N))
   (test 6 N)
   (test 3 (dec 'N 3))
   (test 3 N) )


### * ###
(test 6 (* 1 2 3))
(test -60 (* -5 3 2 2))
(test NIL (* NIL 7))


### */ ###
(test 6 (*/ 3 4 2))
(test -247 (*/ 1234 -2 10))
(test 17 (*/ 100 6))
(test NIL (*/ 3 4 NIL))


### / ###
(test 4 (/ 12 3))
(test -5 (/ 60 -3 2 2))
(test NIL (/ 10 NIL))


### % ###
(test 2 (% 17 5))
(test -2 (% -17 5))
(test 1 (% 5 2))
(test 5 (% 15 10))
(test 1 (% 15 10 2))
(test NIL (% NIL 7))


### >> ###
(test 4 (>> 1 8))
(test 2 (>> 3 16))
(test 128 (>> -3 16))
(test -32 (>> -1 -16))
(test 0 (>> 1 -1))


### lt0 ###
(test -2 (lt0 -2))
(test NIL (lt0 7))
(test NIL (lt0 0))


### le0 ###
(test -7 (le0 -7))
(test NIL (le0 2))
(test 0 (le0 0))


### ge0 ###
(test 7 (ge0 7))
(test NIL (ge0 -2))
(test 0 (ge0 0))


### gt0 ###
(test 7 (gt0 7))
(test NIL (gt0 -2))
(test NIL (gt0 0))


### abs ###
(test 7 (abs -7))
(test 7 (abs 7))
(test NIL (abs NIL))


### bit? ###
(test 7 (bit? 7 15 255))
(test NIL (bit? 1 2))
(test 1 (bit? 1 3))
(test 1 (bit? 1 -3))
(test 1 (bit? -1 3))
(test 1 (bit? -1 -3))
(test (hex "100000000000000000000")
   (bit? (hex "100000000000000000000") (hex "300000000000000000000")) )


### & ###
(test 2 (& 6 3))
(test 1 (& 7 3 1))
(test NIL (& 7 NIL))
(test 1 (& 1 3))
(test 1 (& 1 -3))
(test 1 (& -1 3))
(test 1 (& -1 -3))
(test (hex "100000000000000000000")
   (& (hex "100000000000000000000") (hex "300000000000000000000")) )


### | ###
(test 15 (| 1 2 4 8))
(test NIL (| NIL 1))
(test 3 (| 1 2))
(test 3 (| 1 -2))
(test 3 (| -1 2))
(test 3 (| -1 -2))
(test (hex "300000000000000000000")
   (| (hex "100000000000000000000") (hex "200000000000000000000")) )


### x| ###
(test 5 (x| 2 7))
(test 4 (x| 2 7 1))
(test NIL (x| NIL 1))
(test 3 (x| 1 2))
(test 3 (x| 1 -2))
(test 3 (x| -1 2))
(test 3 (x| -1 -2))
(test (hex "300000000000000000000")
   (x| (hex "100000000000000000000") (hex "200000000000000000000")) )


### sqrt ###
(test 8 (sqrt 64))
(test 4 (sqrt 21))
(test 5 (sqrt 21 T))
(test 31 (sqrt 1000))
(test 32 (sqrt 1000 T))
(test 458 (sqrt 2100 100))
(test 479 (sqrt 230000))
(test 480 (sqrt 2300 100))
(test 800 (sqrt 6400 100))
(test 100000000000000000000
   (sqrt 10000000000000000000000000000000000000000) )
(test NIL (sqrt NIL))


### seed rand hash ###
(test -417605464 (seed "init string"))
(test -1061886707 (rand))
(test 822065436 (rand))
(test 5 (rand 3 9))
(test 3 (rand 3 9))
(test 1 (hash 0))
(test 55682 (hash 1))
(test 35970 (hash 7))
(test 29691 (hash 1234567))
pil21/test/src/db.l0000644000000000000000000000212614300340344011177 0ustar  # 21aug22 Software Lab. Alexander Burger

(test T (pool (tmp "db") (2 3)))

### extern ###
(test NIL (extern (box)))
(test *DB (extern "1"))


### ext? ###
(test *DB (ext? *DB))
(test NIL (ext? 'abc))
(test NIL (ext? "abc"))
(test NIL (ext? 123))


### touch ###
(test *DB (touch *DB))
(rollback)


### id ###
(test *DB (id 1))
(test 1 (id *DB))
(let I (id 3 4)
   (test (3 . 4) (id I T)) )


### wipe ###
(set *DB (1 2 3 4))
(put *DB 'a 1)
(put *DB 'b 2)
(test (1 2 3 4) (val *DB))
(test '((2 . b) (1 . a)) (getl *DB))
(wipe *DB)
(test (1 2 3 4) (val *DB))
(test '((2 . b) (1 . a)) (getl *DB))
(rollback)


### lieu ###
(test NIL (lieu *DB))
(test *DB (val *DB) (lieu *DB))
(rollback)


### commit rollback ###
(let (X (new 1)  Y (new 2))
   (set X 1  Y 2)
   (commit)
   (test 1 (val X))
   (test 2 (val Y))
   (set X 111)
   (set Y 222)
   (test 111 (val X))
   (test 222 (val Y))
   (rollback)
   (test 1 (val X))
   (test 2 (val Y)) )


### mark ###
(test NIL (mark *DB))
(test NIL (mark *DB T))
(test T (mark *DB))
(test T (mark *DB 0))
(test NIL (mark *DB))


### dbck ###
(test NIL (dbck))

(rollback)
pil21/test/src/ext.l0000644000000000000000000000247514412566743011442 0ustar  # 03apr23 Software Lab. Alexander Burger

### ext:Snx ###
(test "PSLSFSNTSNNLSF"
   (ext:Snx "PicoLisp is not Common Lisp") )
(test "PSLSFSNT"
   (ext:Snx "PicoLisp is not Common Lisp" 8) )


### ext:Base64 ###
(test "TQ=="
   (pipe (ext:Base64 77) (line T)) )
(test "AQID"
   (pipe (ext:Base64 1 2 3) (line T)) )
(test '("A" "Q" "I" "D" "B" "A" "U" "G" "B" "w" "=" "=")
   (make
      (let L (1 2 3 4 5 6 7)
         (output (link @@)
            (while L
               (ext:Base64 (++ L) (++ L) (++ L)) ) ) ) ) )

(test (77)
   (pipe
      (prinl "TQ==")
      (make (while (ext:Base64) (link @))) ) )
(test (1 2 3)
   (pipe
      (prinl "AQID")
      (make (while (ext:Base64) (link @))) ) )
(test (1 2 3 4 5 6 7)
   (let L '("A" "Q" "I" "D" "B" "A" "U" "G" "B" "w" "=" "=")
      (make
         (input (++ L)
            (while (ext:Base64) (link @)) ) ) ) )

(let F (tmp "base64")
   (out F
      (pipe
         (prin "Polyfon zwitschernd aßen Mäxchens Vögel Rüben, Joghurt und Quark")
         (while (ext:Base64 (rd 1) (rd 1) (rd 1))) ) )

   (test "UG9seWZvbiB6d2l0c2NoZXJuZCBhw59lbiBNw6R4Y2hlbnMgVsO2Z2VsIFLDvGJlbiwgSm9naHVydCB1bmQgUXVhcms="
      (in F (line T)) )

   (test "Polyfon zwitschernd aßen Mäxchens Vögel Rüben, Joghurt und Quark"
      (pipe
         (in F (while (ext:Base64) (wr @)))
         (line T) ) ) )
pil21/test/src/flow.l0000644000000000000000000002145114752053120011567 0ustar  # 09feb25 Software Lab. Alexander Burger

### quote ###
(test (1 2 3) (quote 1 2 3))


### as ###
(test NIL (as (= 3 4) A B C))
(test '(A B C) (as (= 3 3) A B C))


### lit ###
(test 123 (lit 123))
(test NIL (lit NIL))
(test T (lit T))
(test (1) (lit '(1)))
(test ''"abc" (lit "abc"))
(test ''a (lit 'a))
(test (1 2 3) (lit '(1 2 3)))
(test ''(a b c) (lit '(a b c)))


### eval ###
(test 6 (eval (list '+ 1 2 3)))
(let (X 'Y  Y 7)
   (test 7 (eval X)) )
(when 3
   ((quote (N)
         (when 2
            (test 1 N)
            (test 2 (eval '@ 1))
            (test 3 (eval '@ 2)) ) )
      1 ) )


### run ###
(test 6 (run (list (list '+ 1 2 3))))
(test 5
   (when 2
      ((quote (N)
            (and 1 (run '((+ N @)) 1)) )
         3 ) ) )


### def ###
(test '"a"
   (def '"a" '((X Y) (* X (+ X Y)))) )
(test '((X Y) (* X (+ X Y)))
   "a" )


### de ###
(test '"b"
   (de "b" (X Y) (* X (+ X Y))) )
(test '((X Y) (* X (+ X Y)))
   "b" )


### dm ###
(off "+Cls" "+A")
(class "+Cls" "+A")

(test '"foo>"
   (dm "foo>" (X Y)
      (* X (+ X Y)) ) )
(test '"foo>"
   (dm ("foo>" . "+Cls") (X Y)
      (* X (+ X Y)) ) )
(test '(("foo>" (X Y) (* X (+ X Y))) "+A")
   "+Cls" )


### box ###
(let X (box '(A B C))
   (test X (box? X))
   (test '(A B C) (val X)) )


### new type isa method meth send try ###
(let X (new '("+Cls"))
   (test X (box? X))
   (test 21 ("foo>" X 3 4))
   (test '("+Cls") (type X))
   (test X (isa '"+Cls" X))
   (test NIL (isa '(A B C) X))
   (test '((X Y) (* X (+ X Y)))
      (method '"foo>" X) )
   (test meth "foo>")
   (test 21 (send '"foo>" X 3 4))
   (test NIL (try '"bar>" X))
   (test 21 (try '"foo>" X 3 4)) )


### super ###
(off "+Sub")
(class "+Sub" "+Cls")

(dm ("foo>" . "+Sub") (X Y)
   (super X Y) )
(let X (new '("+Sub"))
   (test 21 ("foo>" X 3 4)) )


### super ###
(off "+Pref")
(class "+Pref")

(dm ("foo>" . "+Pref") (X Y)
   (extra X Y) )
(let X (new '("+Pref" "+Sub"))
   (test 21 ("foo>" X 3 4)) )


### with ###
(let X (box)
   (put X 'a 1)
   (put X 'b 2)
   (test (1 2)
      (with X (list (: a) (: b))) ) )


### bind ###
(let X 123
   (test "Hello"
      (bind 'X
         (setq X "Hello")
         X ) )
   (test (3 4 12)
      (bind '((X . 3) (Y . 4))
         (list X Y (* X Y)) ) ) )


### job ###
(off "tst")

(de "tst" ()
   (job '((A . 0) (B . 0))
      (cons (inc 'A) (inc 'B 2)) ) )

(test (1 . 2) ("tst"))
(test (2 . 4) ("tst"))
(test (3 . 6) ("tst"))


### let let? use ###
(let N 1
   (test NIL (let? N NIL N))
   (test 7 (let? N 7 N))
   (use N
      (setq N 2)
      (let N 3
         (test 3 N) )
      (test 2 N) )
   (test 1 N) )
(let N 1
   (use (N)
      (setq N 2)
      (let (N 3)
         (test 3 N) )
      (test 2 N) )
   (test 1 N) )

(test (1 2 (3) 4)
   (let (A 1  (B . C) (2 3)  D 4)
      (list A B C D) ) )
(test (1 (2 3) 4 (7 8 9))
   (let (((A . B) (C) . D) '((1 2 3) (4 5 6) 7 8 9))
      (list A B C D) ) )
(test (1 8)
   (let (((A . NIL) NIL NIL D) '((1 2 3) (4 5 6) 7 8 9))
      (list A D) ) )

### and ###
(test 7 (and T 123 7))
(test NIL (and NIL 123))


### or ###
(test NIL (or NIL))
(test 7 (or NIL 7 123))


### nand ###
(test NIL (nand T 123 7))
(test T (nand NIL 123))


### nor ###
(test T (nor NIL))
(test NIL (nor NIL 7 123))


### xor ###
(test T (xor T NIL))
(test T (xor NIL T))
(test NIL (xor NIL NIL))
(test NIL (xor T T))


### bool ###
(test T (bool 'a))
(test T (bool 123))
(test NIL (bool NIL))


### not ###
(test T (not NIL))
(test NIL (not T))
(test NIL (not 'a))


### nil ###
(test NIL (nil (+ 1 2 3)))


### t ###
(test T (t (+ 1 2 3)))


### prog ###
(let N 7
   (test 3
      (prog (dec 'N) (dec 'N) (dec 'N) (dec 'N) N) ) )


### prog1 prog2 ###
(test 1 (prog1 1 2 3))
(test 2 (prog2 1 2 3))


### if ###
(test 1 (if (= 3 3) 1 2))
(test 2 (if (= 3 4) 1 2))


### ifn ###
(test 2 (ifn (= 3 3) 1 2))
(test 1 (ifn (= 3 4) 1 2))


### if2 ###
(test 'both
   (if2 T T 'both 'first 'second 'none) )
(test 'first
   (if2 T NIL 'both 'first 'second 'none) )
(test 'second
   (if2 NIL T 'both 'first 'second 'none) )
(test 'none
   (if2 NIL NIL 'both 'first 'second 'none) )
(test 4 (if2 3 4 @))
(test 7 (and 7 (if2 @ @ @)))
(test 7 (and 7 (if2 @ NIL 1 @)))
(test 7 (and 7 (if2 NIL @ 1 2 @)))


### if@@ ###
(test (1 3 . 4)
   (if@@ (inc (setq @@ 3))
      (cons 1 @@ @)
      (cons 2 @@ @) ) )
(test (2 NIL)
   (if@@ (off @@)
      (cons 1 @@ @)
      (cons 2 @@ @) ) )

### when ###
(test 7 (when (= 3 3) 7))
(test NIL (when (= 3 4) 7))


### unless ###
(test NIL (unless (= 3 3) 7))
(test 7 (unless (= 3 4) 7))


### cond ###
(test 1 (cond ((= 3 3) 1) (T 2)))
(test 2 (cond ((= 3 4) 1) (T 2)))


### nond ###
(test 2 (nond ((= 3 3) 1) (NIL 2)))
(test 1 (nond ((= 3 4) 1) (NIL 2)))
(test (1 . a)
   (nond ((num? 'a) (cons 1 'a)) (NIL (cons 2 @))) )
(test (2 . 7)
   (nond ((num? 7) (cons 1 7)) (NIL (cons 2 @))) )


### case ###
(test 1 (case 'a (a 1) ((b c) 2) (T 3)))
(test 2 (case 'b (a 1) ((b c) 2) (T 3)))
(test 2 (case '"b" (a 1) ((b c) 2) (T 3)))
(test 2 (case 'c (a 1) ((b c) 2) (T 3)))
(test 2 (case "c" (a 1) ((b c) 2) (T 3)))
(test 3 (case 'd (a 1) ((b c) 2) (T 3)))

(test 3 (casq 'a ("a" 1) (("b" "c") 2) (T 3)))
(test 3 (casq 'b ("a" 1) (("b" "c") 2) (T 3)))
(test 2 (casq '"b" ("a" 1) (("b" "c") 2) (T 3)))
(test 2 (casq '"c" ("a" 1) (("b" "c") 2) (T 3)))
(test 3 (casq 'b (a 1) ("b" 2) ((a b c) 3) (c 4)))


### state ###
(off "tst")

(de "tst" ()
   (job '((Cnt . 4))
      (state '(start)
         (start 'run
            (link 'start) )
         (run (and (gt0 (dec 'Cnt)) 'run)
            (link 'run) )
         (run 'stop
            (link 'run) )
         (stop 'start
            (setq Cnt 4)
            (link 'stop) ) ) ) )

(test '(start run run run run stop  start run run run run stop)
   (make (do 12 ("tst"))) )
(test '(start run run)
   (make (do 3 ("tst"))) )


### while ###
(test (1 2 3 4 5 6 7)
   (make
      (let N 0
         (while (>= 7 (inc 'N))
            (link N) ) ) ) )


### until ###
(test (1 2 3 4 5 6 7)
   (make
      (let N 0
         (until (> (inc 'N) 7)
            (link N) ) ) ) )


### loop ###
(test (1 2 3 4 5 6 7)
   (make
      (let N 1
         (loop
            (link N)
            (T (> (inc 'N) 7)) ) ) ) )
(test (1 2 3 4 5 6 7)
   (make
      (let N 1
         (loop
            (link N)
            (NIL (>= 7 (inc 'N))) ) ) ) )

(test
   '(a . 3)
   (loop (T NIL (cons @ 1)) (NIL 'a (cons @ 2)) (NIL NIL (cons @ 3))) )


### do ###
(test (1 2 3 4 5 6 7)
   (make
      (let N 0
         (do 7
            (link (inc 'N)) ) ) ) )
(test (1 2 3 4 5 6 7)
   (make
      (let N 1
         (do T
            (link N)
            (T (> (inc 'N) 7)) ) ) ) )


### at ###
(test (1 2 3 - 4 5 6 - 7 8 9 -)
   (make
      (let N 0
         (do 9
            (link (inc 'N))
            (at (0 . 3) (link '-)) ) ) ) )


### for ###
(test (1 2 3 4 5 6 7)
   (make
      (for N (1 2 3 4 5 6 7)
         (link N) ) ) )
(test (1 2 3 4 5 6 7)
   (make
      (for (N . X) '(a b c d e f g)
         (link N) ) ) )
(test (1 2 3 4 5 6 7)
   (make
      (for N 7
         (link N) ) ) )
(test (1 2 3 4 5 6 7)
   (make
      (for (N 1 (>= 7 N) (inc N))
         (link N) ) ) )
(test (1 2 3 4 5 6 7)
   (make
      (for ((N . X) 7 (gt0 X) (dec X))
         (link N) ) ) )
(test (1 2 3 4 5 6 7)
   (make
      (for (N 1 T)
         (link N)
         (T (> (inc 'N) 7)) ) ) )


### tco tc ###
(test (8 7 6 5 4 3 2 1 OK)
   (make
      (let N 8
         (tco (N)
            (if (=0 N)
               (link 'OK)
               (link N)
               (tc (dec N)) ) ) ) ) )

(use Idx
   (balance 'Idx (range 1 7))
   (test (4 2 1 3 6 5 7)
      (make
         (recur (Idx)
            (tco (Idx)
               (when Idx
                  (link (car Idx))
                  (recurse (cadr Idx))
                  (tc (cddr Idx)) ) ) ) ) ) )


### catch throw ###
(test NIL (catch NIL (throw)))
(test 'b (catch 'a 'b))
(test NIL @@)
(test 'b (catch 'a (throw 'a 'b)))
(test T @@)
(test 123 (catch T (throw 'a 123)))
(test "Undefined"
   (catch '("Undefined") (mist)) )
(test T @@)
(test "No such file"
   (catch '("No such file")
      (in "doesntExist" (foo)) ) )
(test 6
   (casq
      (catch '("No such file" "Undefined" "expected")
         (+ 1 2 3) )
      ("No such file" (shouldNotComeHere))
      ("Undefined" (shouldNotComeHere))
      ("expected" (shouldNotComeHere))
      (T @) ) )


### finally ###
(test 'B
   (let X 'A
      (catch NIL
         (finally (setq X 'B)
            (setq X 'C)
            (throw)
            (setq X 'D) ) )
      X ) )


### co yield ###
(test (1 2 3 (1 2 3))
   (make
      (do 4
         (link
            (co "co123"
               (make
                  (yield (link 1))
                  (yield (link 2))
                  (yield (link 3)) ) ) ) ) ) )


### exec ###
(test
   (123 abc)
   (pipe (exec 'echo 123 "abc")
      (list (read) (read)) ) )

### call ###
(test T (call "test" "-d" (path "@test")))
(test NIL (call "test" "-f" (path "@test")))


### kill ###
(test T (kill *Pid 0))
pil21/test/src/ht.l0000644000000000000000000000217613737101142011236 0ustar  # 06oct20 Software Lab. Alexander Burger

### ht:Prin ###
(test "1<2>3&äöü<i>ÄÖÜß"
   (pipe (ht:Prin "1<2>3&äöüÄÖÜß") (line T)) )


### ht:Fmt ###
(test "+123&abc&$def&-123&_+1_xyz_+7"
   (ht:Fmt 123 "abc" 'def '{123} (1 "xyz" 7)) )


### ht:Pack ###
(test "A+B%20C"
   (ht:Pack '("A" "+" "B" "%" "2" "0" "C")) )
(test "A+B C"
   (ht:Pack '("A" "+" "B" "%" "2" "0" "C") T) )
(test "a b>c"
   (ht:Pack '("a" "%" "2" "0" "b" "&" "g" "t" ";" "c") T) )
(test "a€z"
   (ht:Pack '("a" "&" "#" "8" "3" "6" "4" ";" "z")) )
(test "äöü"
   (ht:Pack '("%" "C" "3" "%" "A" "4" "%" "C" "3" "%" "B" "6" "%" "C" "3" "%" "B" "C") T) )


### ht:Read ###
(test NIL
   (pipe (prin "abcde") (ht:Read 0)) )
(test NIL
   (pipe (prin "abcde") (ht:Read 6)) )
(test NIL
   (pipe NIL (ht:Read 3)) )
(test NIL
   (pipe (prin "äö") (ht:Read 3)) )
(test '("ä" "ö")
   (pipe (prin "äö") (ht:Read 4)) )
(test '("a" "b" "c")
   (pipe (prin "abcde") (ht:Read 3)) )
(test '("ä" "ö" "ü")
   (pipe (prin "äöüxyz") (ht:Read 6)) )


### ht:In ht:Out ###
(test "Hello world"
   (pipe (ht:Out T (prinl "Hello world")) (ht:In T (line T))) )
pil21/test/src/io.l0000644000000000000000000001171514243621632011235 0ustar  # 26may22 Software Lab. Alexander Burger

### path ###
(test 'task (cadr (in (path "@lib.l") (read))))
(test (char "+") (char (path "+@")))


### read ###
(test (1 2 3) (~(1 2) 3))
(test (1 3) (~(1 . 2) 3))
(test (1 2 3 4) (1 ~(2 3) 4))
(test (1 2 4) (1 ~(2 . 3) 4))
(test (1 2 3) [1 2 3])
(test (1 2 3) (1 2 3]
(test (1 2 3) (1 2 3)]
(test (1 (2 3)) (1 (2 3]
(test (quote 1 (2 (3))) '(1 (2 (3]
(test (quote 1 (2 (3))) '[1 (2 (3])
(test (1 abc (d e f))
   (pipe (prinl "(1 abc (d e f))")
      (read) ) )
(test '(abc "=" def_ghi "(" ("x" "y" "z") "+" "-" 123 ")")
   (pipe (prinl "abc = def_ghi(\"xyz\"+-123) # Comment")
      (make
         (while (read "_" "#")
            (link @) ) ) ) )


### wait ###
(let (*Run NIL  *Cnt 0)
   (test (1 2 3 4 5 6 7)
      (make
         (task -10 0  (link (inc '*Cnt)))
         (wait NIL (>= *Cnt 7)) ) ) )


### peek char ###
(pipe (prin "ab")
   (test "a" (peek))
   (test "a" (char))
   (test "b" (peek))
   (test "b" (char))
   (test NIL (peek))
   (test NIL (char)) )
(test "A" (char 65))
(test 65 (char "A"))


### skip ###
(test "a"
   (pipe (prinl "# Comment\na")
      (skip "#") ) )
(test "#"
   (pipe (prinl "# Comment\na")
      (skip) ) )


### eof ###
(test T (pipe NIL (eof)))
(test NIL (pipe (prin "a") (eof)))
(test T (pipe (prin "a") (eof T) (eof)))


### from till ###
(test "cd"
   (pipe (prin "ab.cd:ef")
      (from ".")
      (till ":" T) ) )


### line ###
(test '("a" "b" "c")
   (pipe (prin "abc\n") (line)) )
(test "abc"
   (pipe (prin "abc") (line T)) )
(test '("abc" "def")
   (pipe (prin "abc\ndef")
      (list (line T) (line T)) ) )
(test '("abc" "def")
   (pipe (prin "abc\rdef")
      (list (line T) (line T)) ) )
(test '("abc" "def")
   (pipe (prin "abc\r\ndef")
      (list (line T) (line T)) ) )
(test '("a" "bc" "def")
   (pipe (prin "abcdef")
      (line T 1 2 3) ) )


### any ###
(test '(a b c d) (any "(a b # Comment\nc d)"))
(test "A String" (any "\"A String\""))


### sym ###
(test "(abc \"Hello\" 123)"
   (sym '(abc "Hello" 123)) )


### str ###
(test '(a (1 2) b)
   (str "a (1 2) b") )
(test '(a (1 2))
   (str "a (1 2) # b") )
(test "a \"Hello\" DEF"
   (str '(a "Hello" DEF)) )


### load ###
(test 6 (load "-* 1 2 3"))


### in out err ###
(out (tmp "file")
   (println 123)
   (println 'abc)
   (println '(d e f)) )
(in (tmp "file")
   (test 123 (read))
   (in (tmp "file")
      (test 123 (read))
      (test 'abc (in -1 (read))) )
   (test '(d e f) (read)) )

(let Err (tmp "err")
   (test 1 (err Err (msg 1)))
   (test 2 (err (pack "+" Err) (msg 2)))
   (test "1\n2\n" (in Err (till NIL T))) )


### input output ###
(test "A" (input "A" (char)))
(test '(+ 2 (* 3 4))
   (let S (chop "(+ 2 (* 3 4))") (input (++ S) (read))) )

(test "(+ 2 (* 3 4))"
   (pack (make (output (link @@) (print '(+ 2 (* 3 4)))))) )


### pipe ###
(test 123 (pipe (println 123) (read)))
(test "ABC DEF GHI"
   (pipe
      (out '(tr "[a-z]" "[A-Z]") (prinl "abc def ghi"))
      (line T) ) )


### open close ###
(let F (open (tmp "file"))
   (test 123 (in F (read)))
   (test 'abc (in F (read)))
   (test '(d e f) (in F (read)))
   (test F (close F)) )


### echo ###
(out (tmp "echo")
   (in (tmp "file")
      (echo) ) )
(in (tmp "echo")
   (test 123 (read))
   (test 'abc (read))
   (test '(d e f) (read)) )
(let F (tmp "file")
   (test "12"
      (pipe (in F (echo 2))
         (line T) ) )
   (test "23"
      (pipe (in F (echo 1 2))
         (line T) ) ) )


### prin prinl space print printsp println ###
(out (tmp "prin")
   (prin 1)
   (prinl 2)
   (space)
   (print 3)
   (printsp 4)
   (println 5) )
(test (12 "\n" " " 34 5)
   (in (tmp "prin")
      (list (read) (char) (char) (read) (read)) ) )


### flush rewind ###
(out (tmp "prin")
   (prinl "abc")
   (flush)
   (test "abc" (in (tmp "prin") (line T)))
   (rewind) )
(out (tmp "prin") (prinl "def"))
(test "def" (in (tmp "prin") (line T)))


### ext rd pr ###
(let L (list (id 1 2) (cons (id 3 9) 'a) (cons (id 2 7) 'b))
   (let L5 (list (id 6 2) (cons (id 8 9) 'a) (cons (id 7 7) 'b))
      (out (tmp "ext")
         (ext 5 (pr L5)) )
      (test L
         (in (tmp "ext") (rd)) )
      (test L5
         (in (tmp "ext") (ext 5 (rd))) ) ) )

(pipe
   (for N 4096
      (pr N) )
   (for N 4096
      (test N (rd)) ) )
(pipe
   (for C 4096
      (pr (char C)) )
   (for C 4096
      (test C (char (rd))) ) )
(pipe
   (pr (7 "abc" (1 2 3) 'a))
   (test (7 "abc" (1 2 3) 'a) (rd)) )
(test "def"
   (out (tmp "pr")
      (pr 'abc "EOF" 123 "def") ) )
(test '(abc "EOF" 123 "def")
   (in (tmp "pr")
      (make
         (use X
            (until (== "EOF" (setq X (rd "EOF")))
               (link X) ) ) ) ) )

(let N 1
   (do 200
      (test N
         (pipe (pr N) (rd)) )
      (test (- N)
         (pipe (pr (- N)) (rd)) )
      (setq N (* 2 N))
      (wait 10) ) )

### wr ###
(test 3
   (out (tmp "wr")
      (wr 1 2 3) ) )
(test (hex "010203")
   (in (tmp "wr")
      (rd 3) ) )

(for I 100
   (let (L (need I "01")  N (hex (pack L)))
      (test N
         (pipe (apply wr (mapcar format L)) (rd I)) )
      (wait 10) ) )
pil21/test/src/main.l0000644000000000000000000001024014536336632011552 0ustar  # 13dec23 Software Lab. Alexander Burger

### Evaluation ###
(test 2
   (when 1
      ('((N) N) (and 2))
      @ ) )

### alarm ###
(let N 6
   (alarm 1 (inc 'N))
   (test 6 N)
   (wait 2000)
   (test 7 N)
   (alarm 0) )


### sigio ###
(unless (member *OS '("SunOS" "OpenBSD" "Cygwin" "AIX" "HP-UX" "IRIX64"))
   (sigio (setq "SigSock" (port T 0 "SigPort"))
      (setq "SigVal" (udp "SigSock")) )
   (udp "localhost" "SigPort" '(a b c))
   (wait 200)
   (test '(a b c) "SigVal")
   (close "SigSock") )


### kids ###
(test
   (make
      (do 7
         (link (or (fork) (wait 2000) (bye))) ) )
   (flip (kids)) )

### protect ###
(test NIL (pipe (prog (kill *Pid) (pr 7)) (rd)))
(test 7 (pipe (protect (kill *Pid) (pr 7)) (rd)))


### quit ###
(test "Quit" (catch '("Quit") (quit "Quit")))


### byte ###
(test (18 18)
   (let A (adr (81064793292668929))  # cnt 1200000000000012
      (list (byte A) (byte (+ A 7))) ) )

(test "ABC"
   (let P (native "@" "malloc" 'P 8)
      (byte P (char "A"))
      (byte (inc P) (char "B"))
      (byte (+ P 2) (char "C"))
      (byte (+ P 3) 0)
      (prog1
         (native "@" "strdup" 'S P)
         (native "@" "free" NIL P) ) ) )


### adr ###
(let (X (box 7)  L (123))
   (test 7 (val (adr (adr X))))
   (test 123 (car (adr (adr L)))) )

### env ###
(setq *E (env))
(test NIL *E)

(let (A 1 B 2)
   (setq *E (env)) )
(test '((A . 1) (B . 2)) *E)

(let (A 1 B 2)
   (setq *E (env '(A B))) )
(test '((B . 2) (A . 1)) *E)

(let (A 1 B 2)
   (setq *E (env 'X 7 '(A B (C . 3)) 'Y 8)) )
(test '((Y . 8) (C . 3) (B . 2) (A . 1) (X . 7)) *E)


### trail ###
(when trail
   (let
      (F '((A B) (G (inc A) (dec B)))
         G '((X Y) (trail T)) )
      (test '(@X (F 3 4) A 3 B 4 (G (inc A) (dec B)) X 4 Y 3)
         (F 3 4) ) ) )

### up ###
(test 1
   (let N 1
      ((quote (N) (up N)) 2) ) )
(test 7
   (let N 1
      ((quote (N) (up N 7)) 2)
      N ) )


### sys ###
(test "PicoLisp" (sys "TEST" "PicoLisp"))
(test "PicoLisp" (sys "TEST"))


### args next arg rest ####
(test '(T 1 3 (2 3 4))
   (let foo '(@ (list (args) (next) (arg 2) (rest)))
      (foo 1 2 3 4) ) )

(test (7 NIL)
   ((quote @ (list (next) (next))) 7) )


### usec ###
(let U (usec)
   (wait 400)
   (test 4 (*/ (- (usec) U) 100000)) )


### pwd ###
(test *PWD (pwd))


### cd ###
(chdir "/"
   (test "/" (pwd)) )


### info ###
(test '(T . @) (info "@test"))
(test (5 . @)
   (out (tmp "info") (prinl "info"))
   (info (tmp "info")) )


### file ###
(test (cons (tmp) "file" 1)
   (out (tmp "file") (println '(file)))
   (load (tmp "file")) )


### dir ###
(call "mkdir" "-p" (tmp "dir"))
(out (tmp "dir/.abc"))
(out (tmp "dir/a"))
(out (tmp "dir/b"))
(out (tmp "dir/c"))

(test '("a" "b" "c") (sort (dir (tmp "dir"))))
(test '("." ".." ".abc" "a" "b" "c") (sort (dir (tmp "dir") T)))


### cmd ###
(cmd "test")
(test "test" (cmd))


### argv ###
(test '("abc" "123")
   (pipe
      (call *CMD "-prog (println (argv)) (bye)" "abc" 123)
      (read) ) )
(test '("abc" "123")
   (pipe
      (call *CMD "-prog (argv A B) (println (list A B)) (bye)" "abc" 123)
      (read) ) )


### opt ###
(test '("abc" "123")
   (pipe
      (call *CMD "-prog (println (list (opt) (opt))) (bye)" "abc" 123)
      (read) ) )
(test "abc"
   (pipe
      (call *CMD "-de f () (println (opt))" "-f" "abc" "-bye")
      (read) ) )


### date time ###
(use (Dat1 Tim1 Dat2 Tim2 D1 T1 D2 T2)
   (until
      (=
         (setq Dat1 (date)  Tim1 (time T))
         (prog
            (setq
               Dat2 (date T)
               Tim2 (time T)
               D1 (in '(date "+%Y %m %d") (list (read) (read) (read)))
               T1 (in '(date "+%H %M %S") (list (read) (read) (read)))
               D2 (in '(date "-u" "+%Y %m %d") (list (read) (read) (read)))
               T2 (in '(date "-u" "+%H %M %S") (list (read) (read) (read))) )
            (time) ) ) )
   (test Tim1 (time T1))
   (test Tim1 (apply time T1))
   (test Tim2 (time T2))
   (test Dat1 (date D1))
   (test Dat1 (apply date D1))
   (test Dat2 (date D2)) )

(test (2000 7 15) (date 730622))
(test 730622 (date 2000 7 15))
(test 730622 (date (2000 7 15)))
(test NIL (date NIL))

(test (11 17 23) (time 40643))
(test 40643 (time 11 17 23))
(test 40643 (time (11 17 23)))
(test NIL (time NIL))
pil21/test/src/net.l0000644000000000000000000000104413737101117011404 0ustar  # 06oct20 Software Lab. Alexander Burger

### port listen connect ###
(test '(a b c)
   (let P (port 0 "ListenPort")
      (unless (fork)
         (close P)
         (until (connect "localhost" "ListenPort")
            (wait 80) )
         (out @ (pr '(a b c)))
         (bye) )
      (prog1
         (in (listen P) (rd))
         (close P) ) ) )


### udp ###
(test '(a b c)
   (let P (port T 0 "UdpPort")
      (if (fork)
         (udp P)
         (close P)
         (wait 400)
         (udp "localhost" "UdpPort" '(a b c))
         (bye) ) ) )
pil21/test/src/subr.l0000644000000000000000000003337114266045256011612 0ustar  # 20jul22 Software Lab. Alexander Burger

### c[ad]*r ###
(let L '(1 2 3 4 5)
   (test 1 (car L))
   (test (2 3 4 5) (cdr L))
   (test 2 (cadr L))
   (test (3 4 5) (cddr L))
   (test 3 (caddr L))
   (test (4 5) (cdddr L))
   (test 4 (cadddr L))
   (test (5) (cddddr L)) )
(let L '((1 2 3) (4 5))
   (test 1 (caar L))
   (test (2 3) (cdar L))
   (test 2 (cadar L))
   (test (3) (cddar L))
   (test 4 (caadr L))
   (test (5) (cdadr L)) )
(let L '(((1 2)))
   (test 1 (caaar L))
   (test (2) (cdaar L)) )


### nth ###
(test '(b c d) (nth '(a b c d) 2))
(test '(c) (nth '(a (b c) d) 2 2))


### con ###
(let C (1 . a)
   (test '(b c d) (con C '(b c d)))
   (test (1 b c d) C) )


### cons ###
(test (1 . 2) (cons 1 2))
(test '(a b c d) (cons 'a '(b c d)))
(test '((a b) c d) (cons '(a b) '(c d)))
(test '(a b c . d) (cons 'a 'b 'c 'd))


### conc ###
(let (A (1 2 3)  B '(a b c))
   (test (1 2 3 a b c) (conc A B))
   (test (1 2 3 a b c) A) )

(test (1 2 3 4 5 6)
   (conc (1 2 3) NIL (4 5 6)) )


### circ ###
(let C (circ 'a 'b 'c)
   (test '(a b c . @) C)
   (test T (== C (cdddr C))) )


### rot ###
(test (4 1 2 3) (rot (1 2 3 4)))
(test (3 1 2 4 5 6) (rot (1 2 3 4 5 6) 3))
(test (3 1 2 . @Z) (rot (1 2 3 .)))


### list ###
(test (1 2 3 4) (list 1 2 3 4))
(test '(a (2 3) "OK") (list 'a (2 3) "OK"))


### need ###
(test '(NIL NIL NIL NIL NIL) (need 5))
(test '(NIL NIL a b c) (need 5 '(a b c)))
(test '(a b c NIL NIL) (need -5 '(a b c)))
(test '(" " " " a b c) (need 5 '(a b c) " "))
(test (0 0 0) (need 3 0))


### range ###
(test (1 2 3 4 5 6) (range 1 6))
(test (6 5 4 3 2 1) (range 6 1))
(test (-3 -2 -1 0 1 2 3) (range -3 3))
(test (3 1 -1 -3) (range 3 -3 2))
(test (-3 -2 -1) (range -3 -1))


### full ###
(test T (full (1 2 3)))
(test NIL (full (1 NIL 3)))
(test T (full 123))


### make made chain link yoke ###
(let (A 'a I 'i)
   (test '(x y z z a)
      (make
         (link (for A '(x y z) (link A)))
         (link A) ) )
   (test (-1 0 1 x 2 y 3 z i a)
      (make
         (made (cons 0 (box)))
         (for (I . A) '(x y z) (link I A))
         (test (0 1 x 2 y 3 z) (made))
         (made (cons -1 (made)))
         (link I A) ) )
   (test (1 2 3 4 5 6 7 8 9)
      (make (chain (1 2 3)) (chain (4 5 6) (7 8 9))) )
   (test '(a b c)
      (make (yoke 'b) (link 'c) (yoke 'a)) )
   (test '((x y z) (y z) (z) (z) a)
      (make (link (for (A '(x y z) A (cdr A)) (link A))) (link A)) )
   (test (1 (x y z) 2 (y z) 3 (z) (z) i a)
      (make (link (for ((I . A) '(x y z) A (cdr A)) (link I A))) (link I A)) ) )


### copy ###
(test T (=T (copy T)))
(let L (1 2 3)
   (test T (== L L))
   (test NIL (== L (copy L)))
   (test T (= L (copy L)))
   (test T (= (1 2 3) (copy L))) )


### mix ###
(test '(c d a b) (mix '(a b c d) 3 4 1 2))
(test '(a A d D) (mix '(a b c d) 1 'A 4 'D))


### append ###
(test '(a b c 1 2 3) (append '(a b c) (1 2 3)))
(test (1 2 3 . 4) (append (1) (2) (3) 4))


### delete ###
(test (1 3)
   (delete 2 (1 2 3)) )
(test '((1 2) (5 6) (3 4))
   (delete (3 4) '((1 2) (3 4) (5 6) (3 4))) )
(test (1 2 3 1 2 3)
   (delete 1 (1 1 2 3 1 2 3)) )
(test (2 3 2 3)
   (delete 1 (1 1 2 3 1 2 3) T) )


### delq ###
(test '(a c)
   (delq 'b '(a b c)) )
(test (1 (2) 3)
   (delq (2) (1 (2) 3)) )
(test '(a b c a b c)
   (delq 'a '(a a b c a b c)) )
(test '(b c b c)
   (delq 'a '(a a b c a b c) T) )


### replace ###
(test '(A b b A) (replace '(a b b a) 'a 'A))
(test '(a B B a) (replace '(a b b a) 'b 'B))
(test '(B A A B) (replace '(a b b a) 'a 'B 'b 'A))


### insert ###
(test '(a b 777 c d e) (insert 3 '(a b c d e) 777))
(test (777 a b c d e) (insert 1 '(a b c d e) 777))
(test '(a b c d e 777) (insert 9 '(a b c d e) 777))


### remove ###
(test '(a b d e) (remove 3 '(a b c d e)))
(test '(b c d e) (remove 1 '(a b c d e)))
(test '(a b c d e) (remove 9 '(a b c d e)))


### place ###
(test (7) (place 1 NIL 7))
(test (7 2 3) (place -1 (1 2 3) 7))
(test '(a b 777 d e) (place 3 '(a b c d e) 777))
(test (777 b c d e) (place 1 '(a b c d e) 777))
(test '(a b c d e 777) (place 9 '(a b c d e) 777))


### strip ###
(test 123 (strip 123))
(test '(a) (strip '''(a)))
(test '(a b c) (strip (quote quote a b c)))


### split ###
(test '((1) (2 b) (c 4 d 5) (6))
   (split (1 a 2 b 3 c 4 d 5 e 6) 'e 3 'a) )
(test '("The" "quick" "brown" "fox")
   (mapcar pack (split (chop "The quick brown fox") " ")) )


### reverse ###
(test (4 3 2 1) (reverse (1 2 3 4)))
(test NIL (reverse NIL))


### flip ###
(test (4 3 2 1) (flip (1 2 3 4)))
(test (3 2 1 4 5 6) (flip (1 2 3 4 5 6) 3))
(test NIL (flip NIL))


### trim ###
(test (1 NIL 2) (trim (1 NIL 2 NIL NIL)))
(test '(a b) (trim '(a b " " " ")))


### clip ###
(test (1 NIL 2) (clip '(NIL 1 NIL 2 NIL)))
(test '(a " " b) (clip '(" " a " " b " ")))


### head ###
(test '(a b c) (head 3 '(a b c d e f)))
(test NIL (head NIL '(a b c d e f)))
(test NIL (head 0 '(a b c d e f)))
(test '(a b c d e f) (head 10 '(a b c d e f)))
(test '(a b c d) (head -2 '(a b c d e f)))
(test '(a b c) (head '(a b c) '(a b c d e f)))


### tail ###
(test '(d e f) (tail 3 '(a b c d e f)))
(test '(c d e f) (tail -2 '(a b c d e f)))
(test NIL (tail NIL '(a b c d e f)))
(test NIL (tail 0 '(a b c d e f)))
(test '(a b c d e f) (tail 10 '(a b c d e f)))
(test '(d e f) (tail '(d e f) '(a b c d e f)))


### stem ###
(test '("g" "h" "i") (stem (chop "abc/def\\ghi") "/" "\\"))
(test '("g" "h" "i") (stem (chop "abc/def\\ghi") "\\" "/"))


### fin ###
(test 'a (fin 'a))
(test 'b (fin '(a . b)))
(test 'c (fin '(a b . c)))
(test NIL (fin '(a b c)))


### last ###
(test 4 (last (1 2 3 4)))
(test '(d e f) (last '((a b) c (d e f))))


### == ###
(test T (== 'a 'a))
(test T (== 'NIL NIL (val NIL) (car NIL) (cdr NIL)))
(test NIL (== (1 2 3) (1 2 3)))


### n== ###
(test NIL (n== 'a 'a))
(test T (n== (1) (1)))


### = ###
(test T (= 6 (* 1 2 3)))
(test T (= "a" "a"))
(test T (== "a" "a"))
(test T (= (1 (2) 3) (1 (2) 3)))
(test T (= (1 . (2 3 .)) (1 . (2 3 .))))
(test T (= (1 .) (1 .)))


### <> ###
(test T (<> 'a 'b))
(test T (<> 'a 'b 'b))
(test NIL (<> 'a 'a 'a))


### =0 ###
(test 0 (=0 (- 6 3 2 1)))
(test NIL (=0 'a))


### =1 ###
(test 1 (=1 (- 6 3 2)))
(test NIL (=0 'a))


### =T ###
(test NIL (=T 0))
(test NIL (=T "T"))
(test T (=T T))


### n0 ###
(test NIL (n0 (- 6 3 2 1)))
(test T (n0 'a))


### nT ###
(test T (nT 0))
(test T (nT "T"))
(test NIL (nT T))


### < ###
(test T (< 3 4))
(test T (< 'a 'b 'c))
(test T (< 999 'a))
(test T (< NIL 7 'x (1) T))


### <= ###
(test T (<= 3 3))
(test T (<= 1 2 3))
(test T (<= "abc" "abc" "def"))


### > ###
(test T (> 4 3))
(test T (> 'A 999))
(test T (> T (1) 'x 7 NIL))
(test T (> (1 1 .) (1 .)))


### >= ###
(test T (>= 'A 999))
(test T (>= 3 2 2 1))


### max ###
(test 'z (max 2 'a 'z 9))
(test (5) (max (5) (2 3) 'X))


### min ###
(test 2 (min 2 'a 'z 9))
(test 'X (min (5) (2 3) 'X))


### atom ###
(test T (atom 123))
(test T (atom 'a))
(test T (atom NIL))
(test NIL (atom (123)))


### pair ###
(test NIL (pair NIL))
(test (1 . 2) (pair (1 . 2)))
(test (1 2 3) (pair (1 2 3)))


### circ? ###
(test NIL (circ? 'a))
(test NIL (circ? (1 2 3)))
(test (2 3 . @) (circ? (1 . (2 3 .))))


### lst? ###
(test T (lst? NIL))
(test NIL (lst? T))
(test T (lst? (1 . 2)))
(test T (lst? (1 2 3)))


### num? ###
(test 123 (num? 123))
(test NIL (num? 'abc))
(test NIL (num? (1 2 3)))


### sym? ###
(test T (sym? 'a))
(test T (sym? NIL))
(test NIL (sym? 123))
(test NIL (sym? '(a b)))


### flg? ###
(test T (flg? T))
(test T (flg? NIL))
(test NIL (flg? 0))
(test T (flg? (= 3 3)))
(test T (flg? (= 3 4)))
(test NIL (flg? (+ 3 4)))


### member ###
(test (3 4 5 6) (member 3 (1 2 3 4 5 6)))
(test (3 . @) (member 3 (1 2 3 4 5 6 .)))
(test NIL (member 9 (1 2 3 4 5 6)))
(test NIL (member 9 (1 2 3 4 5 6 .)))
(test '((d e f) (g h i))
   (member '(d e f) '((a b c) (d e f) (g h i))) )


### memq ###
(test '(c d e f) (memq 'c '(a b c d e f)))
(test '(c . @) (memq 'c '(a b c d e f .)))
(test NIL (memq (2) '((1) (2) (3))))
(test NIL (memq (2) '((1) (2) (3) .)))
(test 'c (memq 'c '(a b . c)))
(test '(b c a . @Z) (memq 'b '(a b c .)))
(test NIL (memq 'd '(a b c .)))


### mmeq ###
(test NIL (mmeq '(a b c) '(d e f)))
(test '(b x) (mmeq '(a b c) '(d b x)))


### sect ###
(test (3 4) (sect (1 2 3 4) (3 4 5 6)))
(test (1 2 3) (sect (1 2 3) (1 2 3)))
(test NIL (sect (1 2 3) (4 5 6)))


### diff ###
(test (1 3 5) (diff (1 2 3 4 5) (2 4)))
(test (1 2 3) (diff (1 2 3) NIL))
(test NIL (diff (1 2 3) (1 2 3)))


### index ###
(test 3 (index 'c '(a b c d e f)))
(test NIL (index 'z '(a b c d e f)))
(test 3 (index '(5 6) '((1 2) (3 4) (5 6) (7 8))))


### offset ###
(test 3 (offset '(c d e f) '(a b c d e f)))
(test NIL (offset '(c d e) '(a b c d e f)))


### prior ###
(let (L (1 2 3 4 5 6)  X (cdddr L))
   (test NIL (prior L L))
   (test NIL (prior NIL L))
   (test (3 4 5 6) (prior X L)) )


### length ###
(test 3 (length "abc"))
(test 3 (length "äbc"))
(test 3 (length 123))
(test 3 (length (1 (2) 3)))
(test T (length (1 2 3 .)))
(test T (length (1 . (2 3 .))))


### size ###
(test 3 (size "abc"))
(test 4 (size "äbc"))
(test 1 (size 127))
(test 2 (size 128))
(test 4 (size (1 (2) 3)))
(test 3 (size (1 2 3 .)))
(test 8 (size '((1 2 3) (4 5 6))))
(test 6 (size '((1 2 .) (4 5 .))))
(test 3 (size (1 . (2 3 .))))


### bytes ###
(test 4 (bytes "abc"))
(test 5 (bytes "äbc"))
(test 9 (bytes "abcdefgh"))
(test 2 (bytes 127))
(test 3 (bytes 128))
(test 10 (bytes (101 (102) 103)))
(test 9 (bytes (101 102 103 .)))
(let (L (7 "abc" (1 2 3) 'a)  F (tmp "bytes"))
   (out F (pr L))
   (test (bytes L) (car (info F))) )


### assoc ###
(test '("b" . 7)
   (assoc "b" '((999 1 2 3) ("b" . 7) ("ok" "Hello"))) )
(test '("b" . 7)
   (assoc "b" '((999 1 2 3) ("b" . 7) ("ok" "Hello") .)) )
(test (999 1 2 3)
   (assoc 999 '((999 1 2 3) ("b" . 7) ("ok" "Hello"))) )
(test NIL
   (assoc 'u '((999 1 2 3) ("b" . 7) ("ok" "Hello"))) )
(test NIL
   (assoc 'u '((999 1 2 3) ("b" . 7) ("ok" "Hello") .)) )


### rassoc ###
(test '("b" . 7)
   (rassoc 7 '((999 1 2 3) ("b" . 7) ("ok" "Hello"))) )
(test '("b" . 7)
   (rassoc 7 '((999 1 2 3) ("b" . 7) ("ok" "Hello") .)) )
(test (999 1 2 3)
   (rassoc (1 2 3) '((999 1 2 3) ("b" . 7) ("ok" "Hello"))) )
(test NIL
   (rassoc 'u '((999 1 2 3) ("b" . 7) ("ok" "Hello"))) )
(test NIL
   (rassoc 'u '((999 1 2 3) ("b" . 7) ("ok" "Hello") .)) )


### asoq ###
(test NIL
   (asoq (9) '(((9) 1 2 3) (b . 7) ("ok" "Hello"))) )
(test NIL
   (asoq (9) '(((9) 1 2 3) (b . 7) ("ok" "Hello") .)) )
(test '(b . 7)
   (asoq 'b '(((9) 1 2 3) (b . 7) ("ok" "Hello"))) )
(test '(b . 7)
   (asoq 'b '(((9) 1 2 3) (b . 7) ("ok" "Hello") .)) )


### rasoq ###
(test '(2 . b)
   (rasoq 'b '((1 . a) (2 . b) (3 . c))) )
(test '(2 . b)
   (rasoq 'b '((1 . a) (2 . b) (3 . c) .)) )
(test NIL
   (rasoq "b" '((1 . a) (2 . b) (3 . c))) )
(test NIL
   (rasoq "b" '((1 . a) (2 . b) (3 . c) .)) )


### rank ###
(test NIL
   (rank 0 '((1 . a) (100 . b) (1000 . c))) )
(test (1 . a)
   (rank 50 '((1 . a) (100 . b) (1000 . c))) )
(test (100 . b)
   (rank 100 '((1 . a) (100 . b) (1000 . c))) )
(test (100 . b)
   (rank 300 '((1 . a) (100 . b) (1000 . c))) )
(test (1000 . c)
   (rank 9999 '((1 . a) (100 . b) (1000 . c))) )
(test (100 . b)
   (rank 50 '((1000 . a) (100 . b) (1 . c)) T) )


### match ###
(use (@A @B @X @Y @Z)
   (test T
      (match '(@A is @B) '(This is a test)) )
   (test '(This) @A)
   (test '(a test) @B)
   (test T
      (match '(@X (d @Y) @Z) '((a b c) (d (e f) g) h i)) )
   (test '((a b c)) @X)
   (test '((e f) g) @Y)
   (test '(h i) @Z) )


### fill ###
(let (@X 1234  @Y (1 2 3 4))
   (test 1234 (fill '@X))
   (test '(a b (c 1234) (((1 2 3 4) . d) e))
      (fill '(a b (c @X) ((@Y . d) e))) ) )
(test (1 a b c 9)
   (fill (1 ^(list 'a 'b 'c) 9)) )
(test (1 5 7)
   (fill (1 ^(+ 2 3) 7)) )
(let X 2 (test (1 2 3) (fill (1 X 3) 'X)))
(let X 2 (test (1 2 3) (fill (1 X 3) '(X))))
(test (1 (a (7 . 2) c) 3)
   (fill (1 (a (b . 2) c) 3) 'b 7) )
(test (1 (a (b . 123) c) 3)
   (fill (1 (a (b . 2) c) 3) 2 123) )


### prove ###
(test T
   (prove (goal '((equal 3 3)))) )
(test '((@X . 3))
   (prove (goal '((equal 3 @X)))) )
(test NIL
   (prove (goal '((equal 3 4)))) )


### -> ###
(test '((@A . 3) (@B . 7))
   (prove (goal '(@A 3 (^ @B (+ 4 (-> @A)))))) )
(test '((@A . 3) (@B . 7))
   (prove (goal '(@A 3 (^ @B (+ 4 @A))))) )
(test '((@A . 3) (@B . 4) (@N . 12))
   (prove (goal '(@A 3 @B 4 (^ @N (* @A @B))))) )


### unify ###
(test '((@A ((NIL . @C) 0 . @C) ((NIL . @B) 0 . @B) T))
   (prove (goal '((^ @A (unify '(@B @C)))))) )


### not/1 call/1 or/2 nil/1 uniq/2 ###
(test NIL
   (prove (goal '(@A 3 @B 3 (not (equal @A @B))))) )
(test '((@A . 3) (@B . 4))
   (prove (goal '(@A 3 @B 4 (not (equal @A @B))))) )
(test '((@A 1 2 3) (@X 4 5 6))
   (prove (goal '(@A (1 2 3) (call append @A @X (1 2 3 4 5 6))))) )
(test '((@X . 7))
   (prove (goal '((or ((equal 3 @X) (equal @X 4)) ((equal 7 @X) (equal @X 7)))))) )
(test '((@X)) (prove (goal '(@X NIL (nil @X)))))
(test '(a b c d)
   (solve '((^ @B (box)) (lst @X (a b c b c d)) (uniq @B @X)) @X) )


### asserta/1 assertz/1 retract/1 ###
(test T
   (prove
      (goal
         (quote
            (asserta (a (2)))
            (assertz (a (3)))
            (asserta (a (1))) ) ) ) )
(test '(((1)) ((2)) ((3)))
   (get 'a T) )
(test T
   (prove (goal '((retract (a 2))))) )
(test '(((1)) ((3)))
   (get 'a T) )


### clause/2 ###
(test T
   (prove (goal '((clause append ((NIL @X @X)))))) )
(test '((@C (NIL @X @X)))
   (prove (goal '((clause append @C)))) )


### for/2 for/3 for/4 ###
(test '(((@I . 1)) ((@I . 2)) ((@I . 3)))
   (solve '((for @I 3))) )
(test '(((@I . 3)) ((@I . 4)) ((@I . 5)) ((@I . 6)) ((@I . 7)))
   (solve '((for @I 3 7))) )
(test '(((@I . 7)) ((@I . 5)) ((@I . 3)))
   (solve '((for @I 7 3 2))) )


### group ###
(test '((1 a b c) (2 d e f))
   (group '((1 . a) (1 . b) (1 . c) (2 . d) (2 . e) (2 . f))) )


### sort ###
(test '(NIL 1 2 3 4 a b c d (1 2 3) (a b c) (x y z) T)
   (sort '(a 3 1 (1 2 3) d b 4 T NIL (a b c) (x y z) c 2)) )
(test '(T (x y z) (a b c) (1 2 3) d c b a 4 3 2 1 NIL)
   (sort '(a 3 1 (1 2 3) d b 4 T NIL (a b c) (x y z) c 2) >) )
pil21/test/src/sym.l0000644000000000000000000002142714437027620011441 0ustar  # 04jun23 Software Lab. Alexander Burger

### name ###
(test "abc" (name 'abc))
(test "A123" (name '{A123}))
(let X (box)
   (test NIL (name X)) )


### sp? ###
(test T (sp? " \t\n"))
(test NIL (sp? " abc"))
(test NIL (sp? 123))


### pat? ###
(test `(char '@) (char (pat? '@)))
(test NIL (pat? "ABC"))
(test NIL (pat? 123))


### fun? ###
(test 1000000000 (fun? 1000000000))
(test NIL (fun? 12345678901234567890))
(test '(A B) (fun? '((A B) (* A B))))
(test NIL (fun? '((A B) (* A B) . C)))
(test NIL (fun? (1 2 3 4)))
(test NIL (fun? '((A 2 B) (* A B))))
(test T (fun? '(NIL (* 3 4))))


### getd ###
(test car (getd 'car))
(test '((File . @) (load File))
   (getd 'script) )
(test NIL (getd 1))


### all ###
(test '(test)
   (filter '((S) (= S "test")) (all)) )


### symbols nsp ###
(when symbols
   (test T (bool (pair pico)))
   (test '(pico) (symbols 'myLib 'pico)) )

(when symbols
   (one Foo)
   (test 'pico (nsp 'symbols))
   (test 'myLib (nsp 'Foo))
   (test '(myLib pico) (symbols 'pico)) )

(when symbols
   (test 1 myLib~Foo)
   (test NIL (nsp 'myLib~Foo)) )

### intern ###
(test car (val (intern (pack "c" "a" "r"))))
(test car (val (intern '("c" "a" "r"))))


### ==== ###
(setq *Sym "abc")
(test T (== *Sym "abc"))
(====)
(test NIL (== *Sym "abc"))


### box? ###
(let X (box)
   (test X (box? X)) )
(test NIL (box? 123))
(test NIL (box? 'a))
(test NIL (box? NIL))


### str? ###
(test NIL (str? 123))
(test NIL (str? '{A123}))
(test NIL (str? 'abc))
(test "abc" (str? "abc"))


### zap ###
(test "abc" (str? (zap 'abc)))


### chop ###
(test '("c" "a" "r") (chop 'car))
(test '("H" "e" "l" "l" "o") (chop "Hello"))
(test '("1" "2" "3") (chop 123))
(test (1 2 3) (chop (1 2 3)))
(test NIL (chop NIL))


### pack ###
(test "car is 1 symbol name"
   (pack 'car " is " 1 '(" symbol " name)) )


### glue ###
(test 1 (glue NIL 1))
(test "a" (glue NIL '(a)))
(test "ab" (glue NIL '(a b)))
(test "a,b" (glue "," '(a b)))
(test "a8b" (glue 8 '(a b)))
(test "a123b123c" (glue (1 2 3) '(a b c)))


### text ###
(test "abc XYZ def 123" (text "abc @1 def @2" 'XYZ 123))
(test "aXYZz" (text "a@3z" 1 2 '(X Y Z)))
(test "a@bc.de" (text "a@@bc.@1" "de"))
(test "10.11.12" (text "@A.@B.@C" 1 2 3 4 5 6 7 8 9 10 11 12))
(test "1 2 3 4 5 6 7 8 9 10 11 12"
   (text "@1 @2 @3 @4 @5 @6 @7 @8 @9 @A @B @C" 1 2 3 4 5 6 7 8 9 10 11 12) )


### pre? ###
(test "abcdefg" (pre? "" "abcdefg"))
(test NIL (pre? "abc" ""))
(test "abcdefg" (pre? "abc" "abcdefg"))
(test NIL (pre? "def" "abcdefg"))
(test "abcdefg" (pre? "" "abcdefg"))
(test "7fach" (pre? (+ 3 4) "7fach"))


### sub? ###
(test "abcdefg" (sub? "" "abcdefg"))
(test NIL (sub? "abc" ""))
(test "abcdefg" (sub? "cde" "abcdefg"))
(test "abcdefg" (sub? "def" "abcdefg"))
(test NIL (sub? "abb" "abcdefg"))
(test "abcdefg" (sub? "" "abcdefg"))


### val ###
(let L '(a b c)
   (test '(a b c) (val 'L))
   (test 'b (val (cdr L))) )


### set ###
(use L
   (test '(a b c) (set 'L '(a b c)))
   (test 999 (set (cdr L) 999))
   (test '(a 999 c) L) )


### setq ###
(use (A B)
   (test (123 123)
      (setq  A 123  B (list A A)) )
   (test 123 A)
   (test (123 123) B) )


### swap ###
(let (A 1  L (1 2 3))
   (test 1 (swap 'A 7))
   (test 7 (swap 'A 'xyz))
   (test 3 (swap (cddr L) A))
   (test (1 2 xyz) L) )


### xchg ###
(let (A 1  B 2  C '(a b c))
   (test 2 (xchg 'A C  'B (cdr C)))
   (test 'a A)
   (test 'b B)
   (test (1 2 c) C) )


### on off onOff zero one ###
(use (A B)
   (test T (on A B))
   (test T A)
   (test T B)
   (test NIL (off A))
   (test NIL A)
   (test NIL (onOff B))
   (test NIL B)
   (test T (onOff A B))
   (test T A)
   (test T B)
   (test 0 (zero A B))
   (test 0 A)
   (test 0 B)
   (test 1 (one A B))
   (test 1 A)
   (test 1 B) )


### default ###
(let (A NIL  B NIL)
   (test 2 (default A 1  B 2))
   (test A 1)
   (test B 2)
   (test 2 (default A 7  B 8))
   (test A 1)
   (test B 2) )


### push push1 pop ++ shift cut ###
(let L NIL
   (test 0 (push 'L 4 3 2 1 0))
   (test L (0 1 2 3 4))
   (test (1 2 3 4) (shift 'L))
   (test 0 (push1 'L 0))
   (test 1 (push1 'L 1))
   (test L (0 1 2 3 4))
   (test 0 (pop 'L))
   (test 1 (++ L))
   (test (2 3) (cut 2 'L))
   (test (4) L) )

### push1q ###
(let L NIL
   (test (2) (push1q 'L 'a (1) 'b (2)))
   (test (1) (push1q 'L 'b (1)))
   (test '((1) (2) b (1) a) L) )

### del ###
(let (L '((a b c) (d e f))  S (new))
   (put S 'lst L)
   (test '((a b c)) (del '(d e f) 'L))
   (test '(a b c) (del 'x L))
   (test '(a c) (del 'b L))
   (with S
      (test '((a b c)) (del '(d e f) (:: lst)))
      (test NIL (del '(a b c) (:: lst)))
      (test NIL (: lst)) ) )
(let L (1 1 2 3 1 2 3)
   (test (2 3 2 3) (del 1 'L T)) )


### queue ###
(let A NIL
   (test 1 (queue 'A 1))
   (test 2 (queue 'A 2))
   (test 3 (queue 'A 3))
   (test (1 2 3) A) )


### fifo ###
(let X NIL
   (test 1 (fifo 'X 1))
   (test 3 (fifo 'X 2 3))
   (test 1 (fifo 'X))
   (test 2 (fifo 'X))
   (test 3 (fifo 'X)) )


### rid ###
(let E (1 . 2)
   (test 2 (rid 'E 1)) )
(let E (1 2 3 2 4 . 2)
   (test (1 3 4) (rid 'E 2))
   (test (3 4) (rid 'E 1))
   (test (3) (rid 'E 4))
   (test (3) (rid 'E 7))
   (test NIL (rid 'E 3)) )
(let E NIL
   (fifo 'E 1 2 3 2 4 2)
   (test (2 1 2 3 2 4 . @Z) E)
   (test (4 1 3 . @Z) (rid 'E 2)) )


### idx lup ###
(let X NIL
   (test NIL (idx 'X 'd T))
   (test NIL (idx 'X (2 . f) T))
   (test NIL (idx 'X (3 . g) T))
   (test NIL (idx 'X '(a b c) T))
   (test NIL (idx 'X 17 T))
   (test NIL (idx 'X 'A T))
   (test '(d . @) (idx 'X 'd T))
   (test NIL (idx 'X T T))
   (test '(A) (idx 'X 'A))
   (test '(17 A d (2 . f) (3 . g) (a b c) T)
      (idx 'X) )
   (test (2 . f) (lup X 2))
   (test '((2 . f) (3 . g)) (lup X 1 4))
   (test '(17 . @) (idx 'X 17 NIL))
   (test '(A d (2 . f) (3 . g) (a b c) T)
      (idx 'X) )
   (off X)
   (for N '((4 . D) 3 (2 . B) Y (3 . C) Z (6 . F) 7 (7 . G) X (1 . A) T (5 . E) 5)
      (idx 'X N T) )
   (test '(3 5 7 X Y Z (1 . A) (2 . B) (3 . C) (4 . D) (5 . E) (6 . F) (7 . G) T)
      (idx 'X) )
   (test '((3 . C) (4 . D) (5 . E))
      (lup X 3 5) )
   (test '((1 . A) (2 . B) (3 . C) (4 . D) (5 . E) (6 . F) (7 . G))
         (lup X 0 9) ) )


### enum enum? ###
(let E NIL
   (for (I . S) '(a b c d e f g h i j k l m n o)
      (set (enum 'E I) S) )
   (test '(a (b (d (h) l) f (j) n) c (e (i) m) g (k) o)
      E )
   (test '(a b c d e f g h i j k l m n o)
      (make (for I 15 (link (val (enum 'E I))))) )
   (test NIL
      (enum 'E 0) )
   (test '((8 . h) (4 . d) (12 . l) (2 . b) (10 . j) (6 . f) (14 . n) (1 . a) (9 . i) (5 . e) (13 . m) (3 . c) (11 . k) (7 . g) (15 . o))
      (enum 'E) )
   (test '(g . @) (enum? E 7))
   (test NIL (enum? E 16)) )

(let G NIL
   (for I 4
      (for J 4
         (set (enum 'G I J) (* I J)) ) )
   (test (1 . @) (enum? G 1 1))
   (test (6 . @) (enum? G 2 3))
   (test (12 . @) (enum? G 3 4))
   (test NIL (enum? G 5))
   (test NIL (enum? G 1 5)) )

### put get prop ; =: : :: putl getl ###
(let (A (box)  B (box A)  C (box (cons A B)))
   (put B 'a A)
   (put C 'b B)
   (put A 'x 1)
   (put B 'a 'y 2)
   (put C 0 -1 'a 'z 3)
   (test '(NIL . p) (prop 'A 'p))
   (test 1 (get A 'x))
   (test 1 (; A x))
   (test 2 (with A (: y)))
   (test 2 (get A 'y))
   (test 2 (; A y))
   (test 2 (with B (: 0 y)))
   (test 2 (get B 0 'y))
   (test 2 (; B 0 y))
   (test 3 (with C (: b a z)))
   (test 3 (with C (: 0 1 z)))
   (test 3 (with C (: 0 -1 a z)))
   (test 3 (get C 0 1 'z))
   (test 3 (get C 0 -1 'a 'z))
   (test 3 (; C 0 -1 a z))
   (test 1 (push (prop 'A 'p) 1))
   (test 1 (with 'A (pop (:: p))))
   (test NIL (get 'A 'p))
   (test (3 . z) (prop C 0 -1 'a 'z))
   (test 9 (with C (=: 0 -1 a z (* 3 3))))
   (test (9 . z) (with C (:: 0 -1 a z)))
   (test (putl C 0 -1 'a '((1 . x) (2 . y))) (flip (getl C 'b 0))) )

(test NIL (get (1 2 3) 0))
(test 1 (get (1 2 3) 1))
(test 3 (get (1 2 3) 3))
(test NIL (get (1 2 3) 4))
(test (3) (get (1 2 3) -2))
(test 1 (get '((a (b . 1) (c . 2)) (d (e . 3) (f . 4))) 'a 'b))
(test 4 (get '((a (b . 1) (c . 2)) (d (e . 3) (f . 4))) 'd 'f))


### wipe ###
(let X (box (1 2 3 4))
   (put X 'a 1)
   (put X 'b 2)
   (test (1 2 3 4) (val X))
   (test '((2 . b) (1 . a)) (getl X))
   (wipe X)
   (test NIL (val X))
   (test NIL (getl X)) )

(setq "W" (1 2 3 4))
(put '"W" 'a 1)
(put '"W" 'b 2)
(test (1 2 3 4) "W")
(test '((2 . b) (1 . a)) (getl '"W"))
(wipe '"W")
(test NIL "W")
(test NIL (getl '"W"))


### meta ###
(let A '("B")
   (put '"B" 'a 123)
   (test 123 (meta 'A 'a)) )


### low? ###
(test "a" (low? "a"))
(test NIL (low? "A"))
(test NIL (low? 123))
(test NIL (low? "."))


### upp? ###
(test "A" (upp? "A"))
(test NIL (upp? "a"))
(test NIL (upp? 123))
(test NIL (upp? "."))


### lowc ###
(test "abc" (lowc "ABC"))
(test "äöü" (lowc "ÄÖÜ"))
(test "äöü" (lowc "äöü"))
(test 123 (lowc 123))


### uppc ###
(test "ABC" (uppc "abc"))
(test "ÄÖÜ" (uppc "äöü"))
(test "ÄÖÜ" (uppc "ÄÖÜ"))
(test 123 (lowc 123))


### fold ###
(test "1a2b3" (fold " 1A 2-b/3"))
(test "1a2" (fold " 1A 2-B/3" 3))
pil21/test/lib.l0000644000000000000000000000721214055407520010601 0ustar  # 01jun21 Software Lab. Alexander Burger

### task ###
(test (3 . 4)
   (let (*Run NIL  *A NIL  *B NIL)
      (task -10 0 (setq *A 3))
      (task (port T 0 "TaskPort") (eval (udp @)))
      (udp "localhost" "TaskPort" '(setq *B 4))
      (wait NIL (and *A *B))
      (cons *A *B) ) )


### timeout ###
(test '((-1 3600000 (bye)))
   (let *Run NIL
      (timeout 3600000)
      *Run ) )


### abort ###
(test 6 (abort 2 (+ 1 2 3)))
(test NIL (abort 2 (wait 4000)))


### macro ###
(test 6
   (let (@A 1  @B 2  @C 3)
      (macro (* @A @B @C)) ) )


### later ###
(test '((@ . 1) (@ . 4) (@ . 9) (@ . 16) (@ . 25) (@ . 36))
   (prog1
      (mapcan
         '((N) (later (cons) (cons *Pid (* N N))))
         (1 2 3 4 5 6) )
      (wait NIL (full @)) ) )


### recur recurse ###
(test 720
   (let N 6
      (recur (N)
         (if (=0 N)
            1
            (* N (recurse (dec N))) ) ) ) )


### curry ###
(test '((N) (* 7 N))
   ((quote (@X) (curry (@X) (N) (* @X N))) 7) )
(test 21
   (((quote (@X) (curry (@X) (N) (* @X N))) 7) 3) )
(test '((N) (job '((A . 1)) (+ A 7 N)))
   (let (A 1 @X 7) (curry (A @X) (N) (+ A @X N))) )


### cache ###
(let C NIL
   (test 0 (cache 'C 1234 0))
   (test 7 (cache 'C 4321 7))
   (test 7 (cache 'C 4321 8))
   (inc (cache 'C 4321))
   (test 8 (val (cache 'C 4321))) )


### expr subr undef ###
(let foo car
   (test 7 (foo (7)))
   (test T (== 'pass (caadr (expr 'foo))))
   (test car (subr 'foo))
   (test car (undef 'foo))
   (test NIL (val 'foo)) )


### redef ###
(let foo inc
   (redef foo (N) (inc (foo N)))
   (test 3 (foo 1)) )


### daemon patch ###
(let foo car
   (daemon 'foo (msg 'daemon))
   (test T (= '(msg 'daemon) (cadr (getd 'foo))))
   (patch foo 'daemon 'patch)
   (test T (= '(msg 'patch) (cadr (getd 'foo)))) )


### scl ###
(scl 0)
(test 123 (any "123.45"))
(scl 1)
(test (1235) (scl 1 (str "123.45")))
(test 1235 (any "123.45"))
(scl 3)
(test 123450 (any "123.45"))


### ** ###
(test 32768 (** 2 15))
(test 1 (** 123 0))
(test 0 (** 3 -1))


### accu ###
(off Sum)

(test '(a . 1) (accu 'Sum 'a 1))
(test 6 (accu 'Sum 'a 5))
(test (22 . 100) (accu 'Sum 22 100))
(test '((22 . 100) (a . 6)) Sum)

(test '((b . 2) (a . 3))
   (let L NIL (accu 'L 'a 2) (accu 'L 'b 2) (accu 'L 'a 1) L) )


### script ###
(out (tmp "script")
   (println '(pass * 7)) )
(test 42 (script (tmp "script") 2 3))


### once ###
(let N 0
   (test 1
      (once (inc 'N))
      (once (inc 'N))
      N ) )


### rc ###
(let F (tmp "rc")
   (rc F 'a 123)
   (rc F 'b "test"  'c (1 2 3))
   (test '((c 1 2 3) (b . "test") (a . 123))
      (in F (read)) )
   (test 123 (rc F 'a))
   (test "test" (rc F 'b))
   (test (1 2 3) (rc F 'c)) )


### acquire release ###
(let F (tmp "sema")
   (test *Pid (acquire F))
   (test T (acquire F))
   (test *Pid (in F (rd)))
   (test NIL (release F))
   (test NIL (in F (rd))) )


### uniq ###
(test (2 4 6 1 3 5) (uniq (2 4 6 1 2 3 4 5 6 1 3 5)))


### qsym ###
(let "A" 1234
   (put '"A" 'a 1)
   (put '"A" 'b 2)
   (put '"A" 'f T)
   (test (1234 f (2 . b) (1 . a))
      (qsym . "A") ) )

### loc ###
(let (X 'foo  bar '((A B) (foo B A)))
   (test "foo" (zap 'foo))
   (test "foo" (str? "foo"))
   (test T (== X (loc "foo" bar))) )


### class ###
(off "+A" "+B" "+C")
(test '"+A" (class "+A" "+B" "+C"))
(test '"+A" *Class)
(test '("+B" "+C") "+A")


### object ###
(off "Obj")
(test '"Obj"
   (object '"Obj" '("+A" "+B" "+C")  'a 1 'b 2 'c 3) )
(test '((3 . c) (2 . b) (1 . a) (@X . *Dbg))
   (getl '"Obj") )


### extend var var: ###
(test '"+B" (extend "+B"))
(test T (== *Class '"+B"))

(test 1 (var a . 1))
(test 2 (var (b . "+B") . 2))
(test '((2 . b) (1 . a)) (cdr (getl '"+B")))

(with '"Obj"
   (test 1 (var: a))
   (test 2 (var: b)) )
pil21/test/lib/db.l0000644000000000000000000000424614300340626011166 0ustar  # 21aug22 Software Lab. Alexander Burger

### +Joint ###
(test T (pool (tmp "db")))

(class +A +Entity)
(rel k (+Key +String))
(rel b (+List +Bag)
   ((+Joint) a (+B))
   ((+Number)) )

(class +B +Entity)
(rel k (+Key +String))
(rel a (+Joint) b (+A) list asoq)

(let
   (A (new T '(+A) 'k "a")
      B (new T '(+B) 'k "b")
      C (new T '(+B) 'k "c") )

   (test T (bool (has> A 'k "a")))
   (test T (bool (has> B 'k "b")))
   (test A (db 'k '+A "a"))
   (test B (db 'k '+B "b"))
   (test C (db 'k '+B "c"))

   (put> B 'a A)
   (test (list (list B)) (; A b))
   (test A (; B a))

   (test T (bool (has> A 'b B)))
   (test T (bool (has> A 'b (list B))))
   (test T (bool (has> A 'b (list (list B)))))

   (test T (bool (has> B 'a A)))

   (put> B 'a NIL)
   (test NIL (; A b))
   (test NIL (; B a))

   (put> A 'b (list (list B 123)))
   (test (list (list B 123)) (; A b))
   (test A (; B a))

   (put> A 'b (list (list C 7)))
   (test (list (list C 7)) (; A b))
   (test NIL (; B a))
   (test A (; C a))

   (put> A 'b NIL)
   (test NIL (; A b))
   (test NIL (; B a)) )

(rollback)

### +Swap ###
(class +C +Entity)
(rel s (+Swap +String))
(rel l (+Swap +List +String))
(rel b (+List +Bag)
   ((+Number))
   ((+Swap +String)) )
(rel c (+Swap +List +Bag)
   ((+Number))
   ((+String)) )

(let A
   (new T '(+C)
      's "a"
      'l '("b" "c")
      'b '((123 "def"))
      'c '((123 "def")) )

   (test T (bool (has> A 's "a")))
   (test NIL (has> A 's "x"))
   (test T (bool (has> A 'l '("b" "c"))))
   (test NIL (has> A 'l '("b")))
   (test NIL (has> A 'l '("c")))
   (test NIL (has> A 'l '("x")))
   (test T (bool (has> A 'b '((123 "def")))))
   (test NIL (has> A 'b '((123))))
   (test NIL (has> A 'b '(("def"))))
   (test T (bool (has> A 'c '((123 "def")))))
   (test NIL (has> A 'c '((123))))
   (test NIL (has> A 'c '(("def"))))

   (let S (; A l)
      (put> A 'l '("x"))
      (test S (; A l))
      (test '("x") (; A l 0)) )

   (let S (; A b 1 2)
      (put> A 'b (list (list 4 S)))
      (test S (; A b 1 2))
      (test "def" (; A b 1 2 0))
      (test 4 (; A b 1 1))
      (put> A 'b '((7 "y")))
      (test S (; A b 1 2))
      (test 7 (; A b 1 1))
      (test "y" (; A b 1 2 0)) ) )

(rollback)
pil21/test/lib/lint.l0000644000000000000000000000065513737101205011550 0ustar  # 06oct20 Software Lab. Alexander Burger

### noLint ###
(let foo '(() (bar FreeVariable))
   (use *NoLint
      (noLint 'bar)
      (noLint 'foo 'FreeVariable)
      (test NIL (lint 'foo)) ) )


### lint ###
(let foo '((R S T R) (let N 7 (bar X Y)))
    (test '((var T) (dup R) (def bar) (bnd Y X) (use N))
       (lint 'foo) ) )

(let foo '(() (task -6000 0 X 7 (println N)))
   (test '((bnd N) (use X))
       (lint 'foo) ) )
pil21/test/lib/math.l0000644000000000000000000000114513737101221011524 0ustar  # 06oct20 Software Lab. Alexander Burger

(scl 6)
(load "@lib/math.l")

### pow ###
(test 8.0 (pow 2.0 3.0))
(test 8.0 (pow 64.0 0.5))

### exp ###
(test 2.718282 (exp 1.0))

### log ###
(test 0.693147 (log 2.0))

### sin ###
(test 0.0 (sin 0.0))
(test 1.0 (sin (/ pi 2)))

### cos ###
(test 1.0 (cos 0.0))
(test -1.0 (cos pi))

### tan ###
(test 0.0 (tan 0.0))
(test 0.0 (tan pi))

### asin ###
(test 0.0 (asin 0.0))
(test (/ pi 2) (asin 1.0))

### acos ###
(test 0.0 (acos 1.0))
(test pi (acos -1.0))

### atan ###
(test 0.0 (atan 0.0))

### atan2 ###
(test 0.0 (atan2 0.0 1.0))
(test (/ pi 2) (atan2 1.0 0.0))
pil21/test/lib/misc.l0000644000000000000000000001057514243620463011544 0ustar  # 26may22 Software Lab. Alexander Burger

### locale ###
(locale "DE" "de")
(test "Ja" (val ,"Yes"))
(locale)


### align ###
(test "   a" (align 4 'a))
(test "   a" (align 4 "a"))
(test "12  " (align -4 12))
(test "   a  12   b" (align (4 4 4) "a" 12 "b"))


### center ###
(test " 12" (center 4 12))
(test " a" (center 4 "a"))
(test "   a" (center 7 'a))
(test " a  b  c" (center (3 3 3) "a" "b" "c"))


### wrap ###
(test "The quick brown fox\njumps over the lazy\ndog"
   (wrap 20 (chop "The quick brown fox jumps over the lazy dog")) )
(test "The\nquick\nbrown\nfox\njumps\nover the\nlazy dog"
   (wrap 8 (chop "The quick brown fox jumps over the lazy dog")) )
(test "The\nquick\nbrown\nfox\njumps\nover\nthe\nlazy\ndog"
   (wrap 2 (chop "The quick brown fox jumps over the lazy dog")) )
(test '("The" "quick" "brown" "fox" "jumps" "over the" "lazy dog")
   (wrap 8 "The quick brown fox jumps over the lazy dog") )


### pad ###
(test "00001" (pad 5 1))
(test "123456789" (pad 5 123456789))


### bin ###
(test "1001001" (bin (+ 64 8 1)))
(test (+ 64 8 1) (bin "1001001"))
(test "-110110" (bin -54))
(test -54 (bin "-110110"))


### oct ###
(test "111" (oct (+ 64 8 1)))
(test (+ 64 8 1) (oct "111"))
(test "-66" (oct -54))
(test -54 (oct "-66"))


### hex ###
(test "111" (hex (+ 256 16 1)))
(test (+ 256 16 1) (hex "111"))
(test "-FFFF" (hex -65535))


### money ###
(test "1,234,567.89" (money 123456789))
(test "1,234,567.89 EUR" (money 123456789 "EUR"))

(locale "DE" "de")
(test "1.234.567,89 EUR" (money 123456789 "EUR"))
(locale)


### round ###
(scl 4)
(test "12.35" (round 123456 2))
(test "12.3456" (round 123456 6))
(test "12.346" (round 123456))


### balance ###
(test (5 (2 (1) 3 NIL 4) 7 (6) 8 NIL 9)
   (let I NIL (balance 'I (sort (1 4 2 5 3 6 7 9 8))) I) )


### *Allow allowed allow ###
(allowed ("app/")
   "start" "stop" "lib.css" "psh" )
(allow "myFoo")
(allow "myDir/" T)

(test '(("psh" ("lib.css" NIL "myFoo") "start" NIL "stop") "app/" "myDir/")
   *Allow )

(test '("lib.css" "myFoo" "psh" "start" "stop")
   (idx *Allow) )

(test '("app/" "myDir/")
   (cdr *Allow) )


### telStr ###
(test "+49 1234 5678-0" (telStr "49 1234 5678-0"))

(locale "DE" "de")
(test "01234 5678-0" (telStr "49 1234 5678-0"))
(locale)


### expTel ###
(test "49 1234 5678-0" (expTel "+49 1234 5678-0"))
(test "49 1234 5678-0" (expTel "0049 1234 5678-0"))
(test NIL (expTel "01234 5678-0"))

(locale "DE" "de")
(test "49 1234 5678-0" (expTel "01234 5678-0"))
(locale)


### dat$ ###
(test "20070601" (dat$ (date 2007 6 1)))
(test "2007-06-01" (dat$ (date 2007 6 1) "-"))


### $dat ###
(test 733134 ($dat "20070601"))
(test 733134 ($dat "2007-06-01" "-"))


### datSym ###
(test "01jun07" (datSym (date 2007 6 1)))


### datStr ###
(test "2007-06-01" (datStr (date 2007 6 1)))

(locale "DE" "de")
(test "01.06.2007" (datStr (date 2007 6 1)))
(test "01.06.07" (datStr (date 2007 6 1) T))
(locale)


### strDat ###
(test 733134 (strDat "2007-06-01"))
(test NIL (strDat "01.06.2007"))

(locale "DE" "de")
(test 733134 (strDat "01.06.2007"))
(test 733134 (strDat "1.6.2007"))
(locale)


### expDat ###
(test 733133 (date 2007 5 31))
(test 733133 (expDat "31057"))
(test 733133 (expDat "310507"))
(test 733133 (expDat "2007-05-31"))
(test 733133 (expDat "7-5-31"))

(let D (date)
   (test D (expDat "."))
   (test (inc D) (expDat "+1"))
   (test (dec D) (expDat "-1")) )

(locale "DE" "de")
(test 733133 (expDat "31.5.7"))
(locale)


### day ###
(test "Friday" (day (date 2007 6 1)))

(locale "DE" "de")
(test "Freitag" (day (date 2007 6 1)))
(test "Fr"
   (day (date 2007 6 1) '("Mo" "Tu" "We" "Th" "Fr" "Sa" "Su")) )
(locale)


### week ###
(test 22 (week (date 2007 6 1)))


### ultimo ###
(test (2007 1 31) (date (ultimo 2007 1)))
(test (2007 2 28) (date (ultimo 2007 2)))
(test (2004 2 29) (date (ultimo 2004 2)))
(test (2000 2 29) (date (ultimo 2000 2)))
(test (1900 2 28) (date (ultimo 1900 2)))


### tim$ ###
(test "10:57" (tim$ (time 10 57 56)))
(test "10:57:56" (tim$ (time 10 57 56) T))


### $tim ###
(test (10 57 56) (time ($tim "10:57:56")))
(test (10 57 0) (time ($tim "10:57")))
(test (10 0 0) (time ($tim "10")))


### stamp ###
(test "2007-06-01 10:57:56"
   (stamp (date 2007 6 1) (time 10 57 56)) )


### chdir ###
(let P (pwd)
   (chdir "/"
      (test "/" (pwd)) )
   (test P *PWD) )


### dirname basename ###
(test "a/b/c/" (dirname "a/b/c/d"))
(test "a/b/c/" (dirname "a/b/c/d/"))
(test "d" (basename "a/b/c/d"))
(test "d" (basename "a/b/c/d/"))
pil21/lib/http.l0000644000000000000000000003566714734432717010632 0ustar  # 30dec24 Software Lab. Alexander Burger

# *HPorts *Home *Gate *Host *Port *Port1 *Port% *Http1 *Chunked
# *Sock *Agent *ContL *ContLen *MPartLim *MPartEnd "*HtSet"
# *Post *Uri *Url *Timeout *SesId *ConId *Retire
# *Referer *Cookies "*Cookies"

(default
   *HPorts 0
   *Timeout (* 300 1000) )

(private) (Host Port Sock How Prg)

(mapc allow '(*Adr *Gate *Cipher *Host *ContL))

(zero *Http1)

(de *Mimes
   (`(chop "html") "text/html; charset=utf-8")
   (`(chop "svg") "image/svg+xml; charset=utf-8")
   (`(chop "au") "audio/basic" 3600)
   (`(chop "wav") "audio/x-wav" 3600)
   (`(chop "mp3") "audio/x-mpeg" 3600)
   (`(chop "mp4") "video/mp4" 3600)
   (`(chop "gif") "image/gif" 3600)
   (`(chop "tif") "image/tiff" 3600)
   (`(chop "tiff") "image/tiff" 3600)
   (`(chop "bmp") "image/bmp" 86400)
   (`(chop "png") "image/png" 86400)
   (`(chop "jpg") "image/jpeg" 3600)
   (`(chop "jpeg") "image/jpeg" 3600)
   (`(chop "txt") "text/octet-stream" 1 T)
   (`(chop "csv") "text/csv; charset=utf-8" 1 T)
   (`(chop "css") "text/css" 86400)
   (`(chop "js") "application/x-javascript" 86400)
   (`(chop "ps") "application/postscript" 1)
   (`(chop "pdf") "application/pdf" 1)
   (`(chop "epub") "application/epub+zip" 86400)
   (`(chop "zip") "application/zip" 1)
   (`(chop "apk") "application/vnd.android.package-archive" 1)
   (`(chop "jar") "application/java-archive" 86400) )

(de mime (S . @)
   (let L (chop S)
      (if (assoc L *Mimes)
         (con @ (rest))
         (push '*Mimes (cons L (rest))) ) ) )

(de mimetype (File Typ)
   (in (list 'file "-b" (if Typ "--mime-type" "--mime") File)
      (line T) ) )

### HTTP-Client ###
(de client (Host Port How . Prg)
   (let? Sock (connect Host Port)
      (prog1
         (out Sock
            (if (atom How)
               (prinl "GET /" How " HTTP/1.0\r")
               (prinl "POST /" (car How) " HTTP/1.0\r")
               (prinl "Content-Length: " (size (cdr How)) "\r") )
            (prinl "User-Agent: PicoLisp\r")
            (prinl "Host: " Host "\r")
            (prinl "Accept-Charset: utf-8\r")
            (prinl "\r")
            (and (pair How) (prin (cdr @)))
            (flush)
            (in Sock (run Prg 1)) )
         (close Sock) ) ) )

# Local Password
(de pw (N)
   (if N
      (out "~/.pil/pw"
         (prinl (in "/dev/urandom" (rd N))) )
      (in "~/.pil/pw"
         (line T) ) ) )

# PicoLisp Shell
(de psh (Pw Tty Term)
   (cond
      ((not Pw) (println *Port) (bye))
      ((<> Pw (pw)) (quit "Bad pw"))
      ((ctty Tty)
         (sys "TERM" Term)
         (or *SesId (off *Run))
         (println *Pid)
         (unless *Dbg
            (on *Dbg)
            (symbols '(pico)
               (and (info "~/.pil/rc") (load @@))
               (load "@lib/lint.l" "@lib/debug.l" "@lib/vip.l" "@lib/sq.l") ) )
         (load "@lib/too.l")
         (off *Err)
         (quit) ) ) )

### HTTP-Server ###
(de -server ()
   (server (format (opt)) (opt)) )

(de server (Port Home Flg)
   (setq
      *Port Port
      *Port1 (or (sys "NAME") Port)
      *Home (cons Home (chop Home))
      Port (port *Port) )
   (gc)
   (loop
      (setq *Sock (listen Port))
      (T Flg
         (task Port
            (when (accept @)
               (task @ (let *SesId NIL (http @))) ) ) )
      (NIL (fork) (close Port))
      (close *Sock) )
   (task *Sock (http @))
   (http *Sock)
   (or *SesId (bye))
   (task *Sock
      (when (accept @)
         (task @ (http @)) ) ) )

(de retire (Min . Prg)
   (when (sys "PORT")
      (task -60000 60000  X (cons Min Min Prg)
         (cond
            (*Adr (off *Adr) (set X (cadr X)))
            ((diff (kids) *Retire) (set X (cadr X)))
            ((=0 (dec X)) (run (cddr X)) (bye)) ) ) ) )

(de baseHRef (Port . @)
   (pass pack
      (or *Gate "http") "://" *Host
      (if *Gate "/" ":")
      (or Port (if *SesId *Port *Port1))
      "/" ) )

(de https @
   (pass pack "https://" *Host "/" *Port "/" *SesId) )

(de ext.html (Sym)
   (pack (ht:Fmt Sym) ".html") )

(de disallowed ()
   (and
      *Allow
      (not (idx *Allow *Url))
      (or
         (sub? ".." *Url)
         (not (find pre? (cdr *Allow) *Url)) ) ) )

(de notAllowed (X)
   (unless (= X "favicon.ico")
      (msg X " [" *Adr "] not allowed") ) )

# Application startup
(de app ()
   (unless *SesId
      (setq
         *SesId (pack (in "/dev/urandom" (rd 7)) "~")
         *Sock (port *HPorts '*Port)
         *Port% (not *Gate) )
      (timeout *Timeout)
      (out 2 (prinl *Pid " = " *Port " " *SesId)) ) )

# Set a cookie
(de cookie @
   (let A (next)
      (if (assoc A "*Cookies")
         (con @ (rest))
         (push '"*Cookies" (cons A (rest))) ) ) )

# Handle HTTP-Transaction
(de http (*HtSock)
   (use (*Post U L @X)
      (off *Post *Port% *ContL *ContLen *Cookies "*Cookies" "*HtSet")
      (catch 'http
         (in *HtSock
            (alarm 1200 (throw 'http))
            (finally (alarm 0)
               (case (till " " T)
                  ("GET" (_htHead))
                  ("POST"
                     (on *Post)
                     (off *MPartLim *MPartEnd)
                     (_htHead)
                     (cond
                        (*MPartLim (_htMultipart))
                        ((=0 *ContLen))
                        ((cond (*ContL (line)) (*ContLen (ht:Read @)))
                           (for L (split @ '&)
                              (when (setq L (split L "="))
                                 (let? S (_htSet (car L) (ht:Pack (cadr L) T))
                                    (and
                                       (cddr L)
                                       (format (car @))
                                       (unless (out (tmp S) (echo @))
                                          (%@ "unlink" NIL (tmp S)) ) ) ) ) ) )
                        (T (throw 'http)) ) )
                  (T
                     (and @ (out *HtSock (httpStat 501 "Not Implemented")))
                     (task (close *HtSock))
                     (off *HtSock)
                     (throw 'http) ) ) )
            (if (<> *ConId *SesId)
               (prog (task (close *HtSock)) (off *HtSock))
               (setq
                  L (split (setq *Uri U) "?")
                  U (car L)
                  L (mapcan
                     '((A)
                        (cond
                           ((cdr (setq A (split A "=")))
                              (nil (_htSet (car A) (htArg (cadr A)))) )
                           ((tail '`(chop ".html") (car A))
                              (cons (pack (car A))) )
                           (T (cons (htArg (car A)))) ) )
                     (split (cadr L) "&") ) )
               (unless (setq *Url (ht:Pack U T))
                  (setq  *Url (car *Home)  U (cdr *Home)) )
               (out *HtSock
                  (cond
                     ((match '("-" @X "." "h" "t" "m" "l") U)
                        (and *SesId (timeout *Timeout))
                        (apply try L 'html> (extern (ht:Pack @X T))) )
                     ((disallowed)
                        (notAllowed *Url)
                        (http404) )
                     ((= "!" (car U))
                        (and *SesId (timeout *Timeout))
                        (apply (val (intern (ht:Pack (cdr U) T))) L) )
                     ((tail '("." "l") U)
                        (and *SesId (timeout *Timeout))
                        (apply script L *Url) )
                     ((=T (car (info *Url)))
                        (if (info (setq *Url (pack *Url "/default")))
                           (apply script L *Url)
                           (http404) ) )
                     ((assoc (stem U ".") *Mimes)
                        (apply httpEcho (cdr @) *Url) )
                     (T (httpEcho *Url "application/octet-stream" 1 T)) ) ) ) ) )
      (and *HtSock (=0 *Http1) (task (close *HtSock))) ) )

(de _htHead ()
   (unless
      (and
         (char)
         (= "/" (char))
         (prog (setq U (till " ")) (char))
         (= "HTTP/1" (till "." T))
         (char)
         (setq *Http1 (format (line T))) )
      (task (close *HtSock))
      (off *HtSock)
      (throw 'http) )
   (setq *Chunked (gt0 *Http1))
   (if (index "~" U)
      (setq
         *ConId (head @ U)
         U (cdr (nth U @))
         *ConId (pack (if (member "/" *ConId) (cdr @) *ConId)) )
      (off *ConId) )
   (while
      (case (lowc (till " \r\n" T))
         ("host:" (setq *Host (cdr (line))))
         ("referer:" (setq *Referer (cdr (line))))
         ("cookie:"
            (setq *Cookies
               (mapcar
                  '((L)
                     (setq L (split L "="))
                     (cons (htArg (clip (car L))) (htArg (cadr L))) )
                  (split (cdr (line)) ";") ) ) )
         ("user-agent:" (setq *Agent (cdr (line))))
         ("content-length:" (setq *ContLen (format (cdr (line)))))
         ("content-type:"
            (if (= " multipart/form-data; boundary" (lowc (till "=\r\n" T)))
               (setq
                  *MPartLim (append '(- -) (cdr (line)))
                  *MPartEnd (append *MPartLim '(- -)) )
               (line) ) )
         ("x-pil:"
            (char)
            (when (till "=\r\n")
               (_htSet @ (ht:Pack (cdr (line)) T))
               T ) )
         (T (if (eol) (char) (line T))) ) )
   (unless *Gate
      (and (member ":" *Host) (con (prior @ *Host))) ) )

# rfc1867 multipart/form-data
(de _htMultipart ()
   (use Var
      (let L (line)
         (while (= *MPartLim L)
            (unless (= "content-disposition: form-data; name=" (lowc (till "\"" T)))
               (line)
               (throw 'http) )
            (char)
            (setq Var (till "\""))
            (char)
            (nond
               ((line)
                  (while (line))
                  (_htSet Var
                     (pack
                        (make
                           (until
                              (or
                                 (= *MPartLim (setq L (line)))
                                 (= *MPartEnd L) )
                              (when (eof)
                                 (throw 'http) )
                              (when (made)
                                 (link "\n") )
                              (link (trim L)) ) ) ) ) )
               ((head '`(chop "; filename=") (setq L @))
                  (while (line)) )
               (NIL
                  (while (line))
                  (setq L (cdr (rot (nth L 13))))
                  (if (_htSet Var (pack (stem L "/" "\\")))
                     (let F (tmp @)
                        (unless (out F (echo (pack "\r\n" *MPartLim)))
                           (%@ "unlink" NIL F) ) )
                     (out "/dev/null" (echo (pack "\r\n" *MPartLim))) )
                  (setq L (if (= "-" (car (line))) *MPartEnd *MPartLim)) ) ) ) ) ) )

(de _htSet (L Val)
   (let "Var" (intern (ht:Pack (car (setq L (split L ":"))) T))
      (cond
         ((and *Allow (not (idx *Allow "Var")))
            (notAllowed "Var")
            (throw 'http) )
         ((cadr L)
            (let? N (format (car (setq L (split @ "."))))
               (case (caadr L)
                  ("x" (setq Val (cons (format Val))))
                  ("y" (setq Val (cons NIL (format Val)))) )
               (nond
                  ((memq "Var" "*HtSet")
                     (push '"*HtSet" "Var")
                     (set "Var" (cons (cons N Val)))
                     Val )
                  ((assoc N (val "Var"))
                     (queue "Var" (cons N Val))
                     Val )
                  (NIL
                     (let X @
                        (cond
                           ((nand (cadr L) (cdr X)) (con X Val))
                           ((car Val) (set (cdr X) @))
                           (T (con (cdr X) (cdr Val))) ) ) ) ) ) )
         (T
            (if (= "*" (caar L))
               (set "Var" Val)
               (put "Var" 'http Val) ) ) ) ) )

(de htArg (Lst)
   (case (car Lst)
      ("$" (intern (ht:Pack (cdr Lst) T)))
      ("+" (format (cdr Lst)))
      ("-" (extern (ht:Pack (cdr Lst) T)))
      ("_" (mapcar htArg (split (cdr Lst) "_")))
      (T (ht:Pack Lst T)) ) )

# Http Transfer Header
(de http1 (Typ Upd File Att)
   (prinl "HTTP/1." *Http1 " 200 OK\r")
   (prinl "Server: PicoLisp\r")
   (prin "Date: ")
   (httpDate (date T) (time T))
   (when Upd
      (prinl "Cache-Control: max-age=" Upd "\r")
      (when (=0 Upd)
         (prinl "Cache-Control: no-store\r") ) )
   (prinl "Content-Type: " (or Typ "text/html; charset=utf-8") "\r")
   (when File
      (prinl
         "Content-Disposition: "
         (if Att "attachment" "inline")
         "; filename=\"" File "\"\r" ) ) )

(de httpCookies ()
   (mapc
      '((L)
         (prin "Set-Cookie: "
            (ht:Fmt (++ L)) "=" (ht:Fmt (++ L))
            "; path=" (or (++ L) "/") )
         (and (++ L) (prin "; expires=" @))
         (and (++ L) (prin "; domain=" @))
         (and (++ L) (prin "; secure"))
         (and (++ L) (prin "; HttpOnly"))
         (prinl) )
      "*Cookies" ) )

(de respond (S)
   (http1 "application/octet-stream" 0)
   (prinl "Content-Length: " (size S) "\r\n\r")
   (prin S) )

(de httpHead (Typ Upd File Att)
   (http1 Typ Upd File Att)
   (and *Chunked (prinl "Transfer-Encoding: chunked\r"))
   (httpCookies)
   (prinl "\r") )

(de httpDate (Dat Tim)
   (let D (date Dat)
      (prinl
         (day Dat *Day) ", "
         (pad 2 (caddr D)) " "
         (get *Mon (cadr D)) " "
         (car D) " "
         (tim$ Tim T) " GMT\r" ) ) )

# Http Echo
(de httpEcho (File Typ Upd Att Name)
   (and *Tmp (pre? *Tmp File) (one Upd))
   (ifn (info File)
      (http404)
      (let I @
         (http1
            (or Typ (mimetype File))
            Upd
            (or Name (stem (chop File) "/"))
            Att )
         (prinl "Content-Length: " (car I) "\r")
         (prin "Last-Modified: ")
         (httpDate (cadr I) (cddr I))
         (prinl "\r")
         (in File (echo)) ) ) )

(de srcUrl (Url)
   (if (or (pre? "http:" Url) (pre? "https:" Url))
      Url
      (baseHRef *Port1 Url) ) )

(de sesId (Url)
   (if
      (or
         (pre? "http:" Url)
         (pre? "https:" Url)
         (pre? "mailto:" Url)
         (pre? "javascript:" Url)
         (pre? "tel:" Url) )
      Url
      (pack *SesId Url) ) )

(de httpStat (N X . @)
   (let B (fin X)
      (if (pair X)
         (setq X (car X))
         (setq B (pack "
" B "
")) )
      (prinl "HTTP/1." *Http1 " " N " " X "\r")
      (prinl "Server: PicoLisp\r")
      (while (args)
         (prinl (next) "\r") )
      (prinl "Content-Type: text/html\r")
      (httpCookies)
      (prinl "Content-Length: " (+ 59 (length N) (length X) (length B)) "\r")
      (prinl "\r")
      (prinl "")
      (prinl "" N " " X "")
      (prinl "" B "")
      (prinl "") ) )

(de noContent ()
   (prinl "HTTP/1.0 204 No Content\r")
   (prinl "\r") )

(de redirect @
   (httpStat 303 "See Other" (pass pack "Location: ")) )

(de forbidden (X)
   (httpStat 403 "No Permission")
   (and X (msg *Pid " No permission: " @))
   (throw 'http) )

(de http404 ()
   (httpStat 404 "Not Found") )
pil21/lib/xhtml.l0000644000000000000000000006342314764056166011001 0ustar  # 11mar25 Software Lab. Alexander Burger

(de xhtml (Path)
   (for X
      (quote
         ("html" . *XhtmlHtml)
         ("table" . *XhtmlTable)
         ("grid" . *XhtmlGrid)
         ("layout" . *XhtmlLayout)
         ("menu" . *XhtmlMenu)
         ("tab" . *XhtmlTab)
         ("input" . *XhtmlInput)
         ("field" . *XhtmlField)
         ("area" . *XhtmlArea)
         ("select" . *XhtmlSelect)
         ("submit" . *XhtmlSubmit) )
      (when (info (pack Path (++ X)))
         (set X
            (in @@
               (make
                  (until (eof)
                     (let? L (clip (line))
                        (while (= " " (peek))
                           (conc L (list "\n") (clip (line))) )
                        (setq L (split (replace L "~" *SesId) "¦"))
                        (link
                           (unless (= L '(("<" ">")))
                              (make
                                 (loop
                                    (link (pack (++ L)))
                                    (NIL L)
                                    (link (any (++ L)))
                                    (NIL L) ) ) ) ) ) ) ) ) ) ) ) )

(private) Lst

(de micro (Lst . PRG)
   (when Lst
      (loop
         (prin (++ Lst))
         (NIL Lst)
         (if (atom (car Lst))
            (ht:Prin (eval (++ Lst)))
            (eval (++ Lst)) )
         (NIL Lst) )
      (prinl) ) )

(xhtml "@lib/xhtml/")

(mapc allow '(*JS *Menu *Tab *ID "!ping"))
(setq *Menu 0  *Tab 1)
(off "*JS")

(private) (Prg Ofs X Attr Cls Var Val Nm JS)

(de htPrin (Prg Ofs)
   (default Ofs 1)
   (for X Prg
      (if (atom X)
         (ht:Prin (eval X Ofs))
         (eval X Ofs) ) ) )

(de htJs ()
   (for X "*JS"
      (prin " " (car X) "=\"")
      (ht:Prin (cdr X))
      (prin "\"") ) )

(de htStyle (Attr)
   (cond
      ((atom Attr)
         (prin " class=\"")
         (ht:Prin Attr)
         (prin "\"") )
      ((and (atom (car Attr)) (atom (cdr Attr)))
         (prin " " (car Attr) "=\"")
         (ht:Prin (cdr Attr))
         (prin "\"") )
      (T (mapc htStyle Attr)) ) )

(de dfltCss (Cls)
   (htStyle
      (cond
         ((not *Style) Cls)
         ((atom *Style) (pack *Style " " Cls))
         ((and (atom (car *Style)) (atom (cdr *Style)))
            (list Cls *Style) )
         ((find atom *Style)
            (replace *Style @ (pack @ " " Cls)) )
         (T (cons Cls *Style)) ) ) )

(de tag (Nm Attr Ofs Prg)
   (prin "<" Nm)
   (and Attr (htStyle @))
   (prin ">")
   (if (atom Prg)
      (ht:Prin (eval Prg Ofs))
      (for X Prg
         (if (atom X)
            (ht:Prin (eval X Ofs))
            (eval X Ofs) ) ) )
   (prin "") )

(de  (Nm Attr . Prg)
   (tag Nm Attr 2 Prg) )

(de  (JS . Prg)
   (let "*JS" (append "*JS" JS)
      (run Prg) ) )

(de style (X S)
   (nond
      (X S)
      (S X)
      ((pair X)
         (cond
            ((atom S) (pack S " " X))
            ((and (atom (car S)) (atom (cdr S)))
               (list X S) )
            ((find atom S)
               (replace S @ (pack @ " " X)) )
            (T (cons X S)) ) )
      ((or (pair (car X)) (pair (cdr X)))
         (cond
            ((atom S) (list S X))
            ((and (atom (car S)) (atom (cdr S)))
               (if (= (car X) (car S))
                  X
                  (list S X) ) )
            (T
               (cons X (delete (assoc (car X) S) S)) ) ) )
      (NIL
         (for Y X
            (setq S (style Y S)) ) ) ) )

(de ") ) ) )
            (and *SesId ( "SesId='" @ "'"))
            (mapc javascript *JS) )
         (micro Body
            (htPrin Prg 3) )
         (micro End) ) ) )

(de css (Css)
   (prinl "") )

(de javascript (JS . @)
   (when JS
      (prinl "") )
   (and (rest) ( @)) )

(de serverSentEvent (Id Var . Prg)
   (allow "!ssEvt")
   (
      "(new EventSource(SesId+'!ssEvt?'+'"
      Id
      "')).onmessage = function(ev) {if (ev.data.charAt(0) == '&') document.title = ev.data.substr(1); else document.getElementById('"
      Id
      "')."
      (if (lst? (car Prg)) "innerHTML" (++ Prg))
      " = ev.data;}" )
   (if (assoc Id *SsEvts)
      (con @ (cons Var (unless (val Var) Prg)))
      (push '*SsEvts (cons Id Var Prg)) ) )

(de ssEvt (Id)
   (when (assoc Id *SsEvts)
      (let ((@Var . Prg) (cdr @))
         (task *HtSock)
         (macro
            (and @Var (task (close @Var)))
            (task (setq @Var *HtSock)
               (in @
                  (unless (char)
                     (task (close @Var))
                     (off @Var) ) ) ) )
         (httpHead "text/event-stream" 0)
         (run Prg) ) ) )

(private) Sock

(de serverSend (Sock . Prg)
   (when Sock
      (out @
         (ht:Out T
            (prin "data: ")
            (output
               (cond
                  ((<> "\n" @@) (prin @@))
                  (@@@ (prin "\ndata: ")) )
               (htPrin Prg 2) )
            (prinl "\n") ) ) ) )

(de ping (Min)
   (timeout (setq *Timeout (* Min `(* 60 1000))))
   (respond) )

(de  (Min)
   ( "onload=ping(" Min ")") )

(de  (Val Max)
   (ifn Val
      (
 '(id . "progress")
         ( "progress" '((value . 0) (max . 99)))
         (serverSentEvent "progress" '*Progress) )
      (wait 1)
      (serverSend *Progress
         (unless (=T Val)
            ( "progress"
               (list
                  (cons 'value Val)
                  (cons 'max Max) ) )
            ( "center"
               (prin  "
" (*/ Val 100 Max) " %") ) ) ) ) ) 

(de 
 (Attr . Prg)
   (tag "div" Attr 2 Prg)
   (prinl) )

(de  (Attr . Prg)
   (tag "span" Attr 2 Prg) )

(de 
 Prg
   (htPrin Prg 2)
   (prinl "
") )

(de -- ()
   (prinl "
") )

(de ---- ()
   (prinl "

") )

(de 
 ()
   (prinl "
") )

(de  (N)
   (do (or N 1) (prin " ")) )

(de  Prg
   (tag "small" NIL 2 Prg) )

(de  Prg
   (tag "big" NIL 2 Prg) )

(de  Prg
   (tag "em" NIL 2 Prg) )

(de  Prg
   (tag "strong" NIL 2 Prg) )

(de 
 (Attr . Prg)
   (tag "h1" Attr 2 Prg)
   (prinl) )

(de 
 (Attr . Prg)
   (tag "h2" Attr 2 Prg)
   (prinl) )

(de 
 (Attr . Prg)
   (tag "h3" Attr 2 Prg)
   (prinl) )

(de 
 (Attr . Prg)
   (tag "h4" Attr 2 Prg)
   (prinl) )

(de 
 (Attr . Prg)
   (tag "h5" Attr 2 Prg)
   (prinl) )

(de 
 (Attr . Prg)
   (tag "h6" Attr 2 Prg)
   (prinl) )

(de 
 (Attr . Prg)
   (tag "p" Attr 2 Prg)
   (prinl) )

(de 
 (Attr . Prg)
   (tag "pre" Attr 2 Prg)
   (prinl) )

(de 
     (Attr . Prg)
   (tag "ol" Attr 2 Prg)
   (prinl) )

(de 
 (Attr . Prg)
   (tag "tr" Attr 2 Prg) )

(de  (Attr . Prg)
   (tag "thead" Attr 2 Prg) )

(de  (Attr . Prg)
   (tag "tbody" Attr 2 Prg) )

(private) (Attr Ttl Head Prg *RowF Beg BegR Row EndR End C H L Y A N)

(de 
 (Attr . Prg)
   (tag "th" Attr 2 Prg) )

(de 
 (Attr . Prg)
   (tag "td" Attr 2 Prg) )

(de 
 (ATTR Ttl Head . Prg)
   (on *RowF)
   (let ((Beg C BegR Row EndR NIL NIL NIL End) *XhtmlTable)
      (micro Beg)
      (when Ttl
         (micro C
            (ht:Prin (eval Ttl 2)) ) )
      (when (find cdr Head)
         (micro BegR)
         (for H Head
            (let ATTR (car H)
               (micro Row
                  (htPrin (cdr H) 3) ) ) )
         (micro EndR) )
      (htPrin Prg 3)
      (micro End) ) )

(de alternating ()
   (onOff *RowF) )

(de  (Attr . Prg)
   (let ((Beg C NIL NIL NIL BegR Row EndR End) *XhtmlTable  H Head)
      (micro BegR)
      (while Prg
         (let (Y (++ Prg)  A (car (++ H))  N 1)
            (while (== '- (car Prg))
               (inc 'N)
               (++ Prg)
               (++ H) )
            (let ATTR
               (style Attr
                  (style
                     (and (> N 1) (cons "colspan" N))
                     (if (== 'align A) '(align (align . right)) A) ) )
               (micro Row
                  (if (atom Y)
                     (ht:Prin (eval Y 2))
                     (eval Y 2) ) ) ) ) )
      (micro EndR) ) )

(private) (Y Lst L E N)

(de  (Y . Lst)
   (let ((Beg BegR Row EndR End) *XhtmlGrid)
      (micro Beg)
      (while Lst
         (micro BegR)
         (use Y
            (let L (and (sym? Y) (chop Y))
               (do (or (num? Y) (length Y))
                  (let
                     (ATTR
                        (cond
                           ((pair Y) (++ Y))
                           ((= "." (++ L)) "align") )
                        E (++ Lst) )
                     (unless (== '- E)
                        (when (== '- (car Lst))
                           (let N 1
                              (for (P Lst (and P (== '- (++ P))))
                                 (inc 'N) )
                              (push 'N "colspan")
                              (setq ATTR (if ATTR (list ATTR N) N)) ) )
                        (micro Row
                           (if (atom E)
                              (ht:Prin (eval E 2))
                              (eval E 2) ) ) ) ) ) ) )
         (micro EndR) )
      (micro End) ) )

(de  Lst
   (
 '(width . "100%") NIL NIL
      ( NIL
         (¦(run PRG)¦
¦(run PRG)¦

 '((width . "33%") (align . left))
            (eval (car Lst) 1) )
         ( '((width . "34%") (align . center))
            (eval (cadr Lst) 1) )
         ( '((width . "33%") (align . right))
            (eval (caddr Lst) 1) ) ) ) )

(de  Lst
   ( '(width . "100%") NIL '((norm) (align))
      ( NIL
         (eval (car Lst) 5)
         (run (cdr Lst) 5) ) ) )

(private) (X Txt Prg)

(de tip (X Txt)
   ( (cons 'title (glue "\n" X)) Txt) )

(de  (X . Prg)
   (let *Style (style (cons 'title (glue "\n" X)) *Style)
      (run Prg) ) )

(private) (Lst P LayX LayY L Args DX DY Cls Style)

# Layout
(de  Lst
   (let
      (Lay *XhtmlLayout
         P (and (=T (car Lst)) (++ Lst))
         LayX 0
         LayY 0 )
      (ifn Lay
         (recur (Lst LayX)
            (use (LayX LayY)
               (for L Lst
                  (let
                     (Args (mapcar eval (cddar L))
                        DX (eval (caar L))
                        DY (eval (cadar L))
                        Cls (unless (sub? ":" (car Args)) (++ Args))
                        Style
                        (cons 'style
                           (glue "; "
                              (cons
                                 "position:absolute"
                                 (pack "top:" LayY (if P "%" "px"))
                                 (pack "left:" LayX (if P "%" "px"))
                                 (cond
                                    ((=0 DX) "min-width:100%")
                                    (DX (pack "width:" DX (if P "%" "px"))) )
                                 (cond
                                    ((=0 DY) "min-height:100%")
                                    (DY (pack "height:" DY (if P "%" "px"))) )
                                 Args ) ) ) )
                     (prog1
                        (if Cls (list Cls Style) Style)  # -> '@'
                        (eval (cadr L)) )
                     (recurse (cddr L) (+ LayX DX))
                     (inc 'LayY DY) ) ) ) )
         (recur (Lst)
            (for L Lst
               (micro (++ Lay)
                  (run (cddadr L)) )
               (recurse (cddr L)) ) ) ) ) )

(private) (Url Str)

(de 
¦(run PRG)¦








pil21/lib/xhtml/html0000644000000000000000000000027714063560703011476 0ustar  


   
   ¦(run PRG)¦

   ¦(run PRG)¦

pil21/lib/xhtml/input0000644000000000000000000000004614063610745011665 0ustar  
pil21/lib/xhtml/layout0000644000000000000000000000000014007706635012033 0ustar  pil21/lib/xhtml/menu0000644000000000000000000000064414063604622011473 0ustar  <>

<>
pil21/lib/xhtml/select0000644000000000000000000000020614063631633012002 0ustar  
¦(run (cdr PRG))¦


pil21/lib/xhtml/submit0000644000000000000000000000004614063364074012032 0ustar  
pil21/lib/xhtml/tab0000644000000000000000000000021214064316126011264 0ustar  

¦(run PRG)¦
¦(run PRG)¦


pil21/lib/xhtml/table0000644000000000000000000000030414163022306011601 0ustar  

¦(run PRG)¦










pil21/lib/form.l0000644000000000000000000017215014763005276010601 0ustar  # 08mar25 Software Lab. Alexander Burger

# *PRG *Top *Gui *Btn *Get *Got *Form *FormIx *FormLst *Evt
# *Lock *Spans *AlwaysAsk

(private) (*Chart *App *Ix *Err *Foc *Post2 *Stat *Cho *TZO)

(allow "@img/" T)
(push1 '*JS (allow "@lib/form.js"))  #! @lib
(mapc allow
   (quote
      *Gui *Get *Got *Form "!jsForm" *Evt *Drop
      *JsHint "!jsHint" jsUp jsDn *JsArgs "!tzOffs" ) )

(default *FormIx 1)

(de *Go.png . "@img/go.png")
(de *No.png . "@img/no.png")

(de *Throbber
   ("+---" "-+--" "--+-" "---+" "--+-" "-+--" .) )

(de tzOffs (Min)
   (setq *TZO (* Min 60))
   (respond) )

(private) (Attr Prg App Lst F L)

# Define GUI form
(de form (Attr . Prg)
   (when (=1 *Form)
      ( "window.addEventListener('pagehide', function(event) {document.forms[0].reset()});") )
   (inc '*Form)
   (let App
      (if *PRG
         (get *FormLst (- *FormIx *Get) *Form)
         (prog1
            (setq *Top (new NIL NIL 'able T 'evt 0))
            ~(as *Dbg
               (when (file)
                  (put *Top '*Dbg
                     (list (cons (cddr @) (pack (car @) (cadr @)))) ) ) )
            (put *Top 'home *Top)
            (and (nth *FormLst (- *FormIx *Get)) (queue @ *Top)) ) )
      (let Lst (get *FormLst (- *FormIx *Get) 1)
         (for (F . L) Lst
            (let *Form (- F (length Lst))
               (cond
                  ((and (== *PRG (car L)) (memq App (; *PRG top)))
                     (apply "form" L) )
                  ((or (== *PRG App) (memq App (; *PRG top)))
                     (if (; L 1 top)
                        (apply "form" L)
                        (put L 1 'top (cons *PRG (; *PRG top)))
                        (let *PRG NIL (apply "form" L)) ) ) ) ) ) )
      ("form" App Attr Prg) ) )

(de "form" (*App Attr Prg)
   (with *App
      (job (: env)
         ( Attr (urlMT *Url *Menu *Tab *ID)
            ( '*Get *Get)
            ( '*Form *Form)
            ( '*Evt (: evt))
            (zero *Ix)
            (if *PRG
               (let gui
                  '(()
                     (with (get *App 'gui (inc '*Ix))
                        (for E *Err
                           (when (== This (car E))
                              (
 'error
                                 (if (atom (cdr E))
                                    (ht:Prin (eval (cdr E) 1))
                                    (eval (cdr E) 1) ) ) ) )
                        (if (: id)
                           (let *Gui (val *App)
                              (show> This (cons '*Gui @)) )
                           (setq *Chart This) )
                        This ) )
                  (and (== *PRG *App) (setq *Top *App))
                  (htPrin Prg) )
               (set *App)
               (let gui
                  '((X . @)
                     (inc '*Ix)
                     (with
                        (cond
                           ((pair X) (pass new X))
                           ((not X) (pass new))
                           ((num? X)
                              (ifn *Chart
                                 (quit "no chart" (rest))
                                 (with *Chart
                                    (let L (last (: gui))
                                       (when (get L X)
                                          (inc (:: rows))
                                          (queue (:: gui) (setq L (need (: cols)))) )
                                       (let Fld (pass new)
                                          (set (nth L X) Fld)
                                          (put Fld 'chart (list This (: rows) X))
                                          (and (; Fld chg) (; Fld able) (=: lock))
                                          (set> Fld
                                             (get
                                                ((: put)
                                                   (get (nth (: data) (: ofs)) (: rows))
                                                   (+ (: ofs) (: rows) -1) )
                                                X )
                                             T )
                                          Fld ) ) ) ) )
                           ((get *App X) (quit "gui conflict" X))
                           (T (put *App X (pass new))) )
                        (queue (:: home gui) This)
                        (unless (: chart) (init> This))
                        (when (: id)
                           (let *Gui (val *App)
                              (show> This (cons '*Gui (: id))) ) )
                        This ) )
                  (htPrin Prg) ) ) )
         (off *Chart)
         (--)
         (and
            (: show)
            (info @)
            (in (: show) (echo)) ) ) ) )

# Disable form
(de disable (Flg)
   (and Flg (=: able)) )

(private) Prg

# Handle form actions
(de action Prg
   (off *Chart *Foc)
   (or *PRG *Post2 (off *Err))
   (catch 'stop
      (nond
         (*Post
            (unless (and *PRG (= *Form (car *Got)) (= *Get (cadr *Got)))
               (pushForm (cons)) )
            (if *Port%
               (let *JS NIL (_doForm))
               (_doForm) )
            (off *PRG *Got) )
         (*PRG
            (with (postForm)
               (ifn (= *Evt (: evt))
                  (noContent)
                  (postGui)
                  (redirect
                     (baseHRef)
                     *SesId
                     (urlMT *Url *Menu *Tab *ID)
                     "&*Evt=+" (inc (:: evt))
                     "&*Got=_+" *Form "_+" *Get ) ) ) )
         (NIL
            (off *PRG)
            (pushForm (cons))
            (_doForm) ) ) ) )

(de pushForm (L)
   (push '*FormLst L)
   (and (nth *FormLst 99) (con @))
   (setq *Get *FormIx)
   (inc '*FormIx) )

(de _doForm ()
   (one *Form)
   (run Prg)
   (setq *Stat
      (cons
         (pair *Err)
         (copy (get *FormLst (- *FormIx *Get))) ) ) )

(de jsForm (Url)
   (if (or *PRG (not *Post))
      (noContent)
      (setq *Url Url  Url (chop Url))
      (let action
         '(Prg
            (off *Err)
            (with (postForm)
               (ifn (= *Evt (: evt))
                  (respond)
                  (catch 'stop
                     (postGui)
                     (httpHead "text/plain; charset=utf-8")
                     (if
                        (and
                           (= (car *Stat) *Err)
                           (= (cdr *Stat) (get *FormLst (- *FormIx *Get))) )
                        (ht:Out *Chunked
                           (prin (setq *Evt (inc (:: evt))) "&")
                           (when (: auto)
                              (prin "i" *Form "-" (: auto 1 id) ":" (: auto -1))
                              (=: auto) )
                           (for S *Spans
                              (prin "&" (car S) "&" (run (cdr S))) )
                           (for This (: gui)
                              (if (: id)
                                 (prin "&i" *Form "-" @ "&" (js> This))
                                 (setq *Chart This) ) ) )
                        (setq *Post2 (cons *Get *Form *PRG))
                        (ht:Out *Chunked (prin T)) ) ) ) )
            (off *PRG) )
         (use @X
            (cond
               ((match '("-" @X "." "h" "t" "m" "l") Url)
                  (try 'html> (extern (ht:Pack @X T))) )
               ((disallowed)
                  (notAllowed *Url)
                  (http404) )
               ((= "!" (car Url))
                  ((intern (cdr Url))) )
               ((tail '("." "l") Url)
                  (load *Url) ) ) ) ) ) )

(de postForm ()
   (when (num? (format *Get))
      (let? Lst (get *FormLst (- *FormIx (setq *Get @)))
         (and
            (setq *Form (format *Form))
            (setq *Evt (format *Evt))
            (setq *PRG
               (cond
                  ((and
                        (= *Get (car *Post2))
                        (= *Form (cadr *Post2)) )
                     (cddr *Post2) )
                  ((off *Post2))
                  ((gt0 *Form) (get Lst *Form))
                  (T (get Lst 1 (+ (length (car Lst)) *Form) 1)) ) )
            (val *PRG)
            *PRG ) ) ) )

(de postGui ()
   (if *Post2
      (off *Gui *Post2)
      (let (*Btn NIL  "Fun")
         (for G *Gui
            (if (=0 (car G))
               (setq "Fun" (cdr G))
               (and (lt0 (car G)) (setq *Btn (cdr G)))
               (con (assoc (car G) (val *PRG)) (cdr G)) ) )
         (off *Gui)
         (and (: lock) (n== @ *Lock) (=: able))
         (job (: env)
            (for This (: gui)
               (cond
                  ((not (: id)) (setq *Chart This))
                  ((chk> This) (error @))
                  ((or (: rid) (: home able))
                     (set> This (val> This) T) ) ) )
            (unless *Err
               (for This (: gui)
                  (cond
                     ((: id))
                     ((chk> (setq *Chart This)) (error @))
                     ((or (: rid) (: home able))
                        (set> This (val> This)) ) ) ) )
            (if (pair *Err)
               (when *Lock
                  (=: lock (with (caar *Err) (tryLock *Lock))) )
               (finally
                  (when *Lock
                     (if (lock @)
                        (=: able (=: lock (off *Lock)))
                        (let *Run NIL
                           (sync)
                           (tell) ) ) )
                  (when "Fun"
                     (when (and *Allow (not (idx *Allow "Fun")))
                        (notAllowed "Fun")
                        (throw 'stop) )
                     (apply (intern "Fun")
                        (mapcar
                           '((X)
                              ((if (= "+" (car (setq X (chop (cdr X))))) format pack)
                                 (cdr X) ) )
                           *JsArgs ) ) )
                  (for This (: gui)
                     (nond
                        ((: id) (setq *Chart This))
                        ((ge0 (: id))
                           (let? A (assoc (: id) (val *PRG))
                              (when (cdr A)
                                 (con A)
                                 (act> This) ) ) ) ) ) )
               (for This (: gui)
                  (or (: id) (setq *Chart This))
                  (upd> This) ) ) ) ) ) )

(de error (Exe)
   (cond
      ((=T Exe) (on *Err))
      ((nT *Err) (queue '*Err (cons This Exe))) ) )

(de url (Url . @)
   (when Url
      (off *PRG)
      (when *Timeout
         (timeout `(* 3600 1000)) )
      (redirect (baseHRef) *SesId Url
         (and (args) "?")
         (pack
            (make
               (loop
                  (let A (next)
                     (and
                        (sym? A)
                        (= `(char '*) (char A))
                        (link A "=")
                        (setq A (next)) )
                     (link (ht:Fmt A)) )
                  (NIL (args))
                  (link "&") ) ) ) )
      (throw 'stop) ) )

(de post Prg
   (run Prg)
   (url *Uri) )

# Active  elements
(de span Args
   (def (car Args)
      (list NIL
         (list '
            (lit (cons 'id (car Args)))
            (cons 'ht:Prin (cdr Args)) ) ) )
   (push '*Spans Args) )

(span expires
   (pack
      `(char 8230)  # Ellipsis
      (let Tim (+ (time T) (/ (cadr (assoc -1 *Run)) 1000))
         (if *TZO
            (tim$ (% (- Tim -86400 @) 86400))
            (
               "lisp(null, 'tzOffs', (new Date()).getTimezoneOffset())" )
            (pack (tim$ (% Tim 86400)) " UTC") ) ) ) )

# Return chart property
(de chart @
   (pass get *Chart) )

# Table extension
(daemon '
   (with *Chart
      (setq ATTR
         (make
            (link
               (cons "chart" (index This (: home chart)))
               '("ontouchstart" . "return tblTouch(event)")
               '("ontouchmove" . "return tblMove(this,event)")
               (and ATTR (link @)) ) ) ) ) )

# REPL form
(private) Str

(de repl (Attr DX DY)
   (default DX 80  DY 25)
   (form Attr
      (=: repl (tmp "repl"))
      (gui 'view '(+Able +FileField)
         '(<> (: file) (: home repl))
         (: repl)
         DX DY )
      (--)
      (gui '(+View +SymField) '(car (symbols)))
      ()
      (gui 'line '(+Focus +Able +Hint1 +TextField)
         '(= (: home view file) (: home repl))
         '*ReplH
         (*/ DX 4 5) )
      (----)
      (gui '(+JS +Able +Button) '(= (: home view file) (: home repl)) "Eval"
         '(let Str (val> (: home line))
            (out (pack "+" (: home repl))
               (if (= `(char "!") (char Str))
                  (err NIL
                     (prinl Str)
                     (flush)
                     (in (list "sh" "-c" (cdr (chop Str)))
                        (echo) ) )
                  (err NIL
                     (prinl (car (symbols)) ": " Str)
                     (flush)
                     (catch '(NIL)
                        (in "/dev/null"
                           (up 99 @@@ "@3")
                           (up 99 @@ "@2")
                           (up 99 @ "@1")
                           (setq  "@3" "@2"  "@2" "@1"  "@1" (run (str Str) 99)) )
                        (println '-> "@1") ) )
                  (when @@
                     (prin "!? ")
                     (println ^)
                     (prinl *Msg) ) ) )
            (push1 '*ReplH Str)
            (clr> (: home line)) ) )
      (gui '(+JS +Button)
         '(if (= (: home view file) (: home repl)) ,"Edit" ,"Done")
         '(file> (: home view)
            (if (= (: home view file) (: home repl))
               (if (val> (: home line))
                  (setq *ReplF (push1 '*ReplH @))
                  (set> (: home line) *ReplF)
                  *ReplF )
               (clr> (: home line))
               (: home repl) ) ) ) ) )

(private) (dlg Attr Env Lst Prg)

# Dialogs
(de dlg (Attr Env Prg)
   (let? L (get *FormLst (- *FormIx *Get))
      (while (and (car L) (n== *PRG (caar @)))
         (pop L) )
      (push L
         (list
            (new NIL NIL  'btn This  'able T  'evt 0  'env Env)
            Attr
            Prg ) )
      (pushForm L) ) )

(de dialog (Env . Prg)
   (dlg 'dialog Env Prg) )

(de alert (Env . Prg)
   (dlg 'alert Env Prg) )

(de note (Str Lst)
   (alert (env '(Str Lst))
      ( 'note Str)
      (--)
      (for S Lst (
 S))
      (okButton) ) )

(de ask (Str . Prg)
   (alert (env '(Str Prg))
      ( 'ask Str)
      (--)
      (yesButton (cons 'prog Prg))
      (noButton) ) )

(de diaform (Lst . Prg)
   (cond
      ((num? (caar Lst))  # Dst
         (gui (gt0 (caar Lst)) '(+ChoButton)
            (cons 'diaform
               (list 'cons
                  (list 'cons (lit (car Lst)) '(field 1))
                  (lit (env (cdr Lst))) )
               Prg ) ) )
      ((and *PRG (not (: diaform)))
         (dlg 'dialog (env Lst) Prg) )
      (T
         (=: env (env Lst))
         (=: diaform T)
         (run Prg 1) ) ) )

(de saveButton (Exe)
   (gui '(+Button) ,"Save" Exe) )

(de closeButton (Lbl Exe)
   (when (; *App top)
      (gui '(+Rid +Close +Button) Lbl Exe) ) )

(de okButton (Exe)
   (when (; *App top)
      (if (=T Exe)
         (gui '(+Force +Close +Button) T "OK")
         (gui '(+Close +Button) "OK" Exe) ) ) )

(de cancelButton ()
   (when (; *App top)
      (gui '(+Force +Close +Button) T ',"Cancel") ) )

(de yesButton (Exe)
   (gui '(+Close +Button) ',"Yes" Exe) )

(de noButton (Exe)
   (gui '(+Close +Button) ',"No" Exe) )

(de choButton (Exe)
   (gui '(+Rid +Tip +Button)
      ,"Find or create an object of the same type"
      ',"Select" Exe ) )


(class +Force)
# force

(dm T (Exe . @)
   (=: force Exe)
   (pass extra) )

(dm chk> ()
   (when
      (and
         (cdr (assoc (: id) (val *PRG)))
         (eval (: force)) )
      (for A (val *PRG)
         (and
            (lt0 (car A))
            (<> (: id) (car A))
            (con A) ) )
      T ) )


(class +Close)

(dm act> ()
   (when (able)
      (and
         (get *FormLst (- *FormIx *Get))
         (pushForm
            (cons
               (filter
                  '((L) (memq (car L) (: home top)))
                  (car @) )
               (cdr @) ) ) )
      (extra)
      (for This (: home top)
         (for This (: gui)
            (or (: id) (setq *Chart This))
            (upd> This) ) ) ) )


# Choose a value
(class +ChoButton +Tiny +Tip +Button)

(dm T (Exe)
   (super  ,"Choose a suitable value" "+" Exe)
   (=: chg T) )


(class +PickButton +Tiny +Tip +Button)

(dm T (Exe)
   (super ,"Adopt this value" "@" Exe) )


(class +DstButton +Set +Able +Close +PickButton)
# msg obj

(dm T (Dst Msg)
   (=: msg (or Msg 'url>))
   (super
      '((Obj) (=: obj Obj))
      '(: obj)
      (when Dst
         (or
            (pair Dst)
            (list 'chgDst (lit Dst) '(: obj)) ) ) ) )

(de chgDst (This Val)
   (set> This (if (: new) (@ Val) Val)) )

(dm js> ()
   (cond
      ((: act) (super))
      ((try (: msg) (: obj) 1 This)
         (pack "@&+" (ht:Fmt (sesId (mkUrl @)))) )
      (T "@") ) )

(dm show> (Var)
   (if (: act)
      (super Var)
      (") )

(de  (X Y . Prg)
   (prin "")
   (htPrin Prg 2)
   (prinl "") )

(de font (X . Prg)
   (ifn Prg
      (cond
         ((num? X) (setq *FontSize X))
         ((sym? X) (setq *FontFamily X))
         (T (setq *FontSize (car X)  *FontFamily (fin X))) )
      (cond
         ((num? X)
            (let *FontSize X
               (run Prg 1) ) )
         ((sym? X)
            (let *FontFamily X
               (run Prg 1) ) )
         (T
            (let (*FontSize (car X)  *FontFamily (fin X))
               (run Prg 1) ) ) ) ) )

(de width (N . Prg)
   (ifn Prg
      (setq *StrokeWidth N)
      (let *StrokeWidth N
         (run Prg 1) ) ) )

(de italic Prg
   (let *FontStyle 'italic
      (run Prg) ) )

(de bold Prg
   (let *FontWeight 'bold
      (run Prg) ) )

(de indent (X . Prg)
   (prinl "")
   (dec '*DX X)
   (prog1
      (run Prg)
      (prinl "") ) )

(de rotate (A . Prg)
   (prinl "")
   (prog1
      (run Prg)
      (prinl "") ) )

(de scale (X Y . Prg)
   (prinl "")
   (prog1
      (run Prg)
      (prinl "") ) )

(de window (X Y *DX *DY . Prg)
   (prinl "")
   (let *Pos 0
      (prog1
         (run Prg)
         (prinl "") ) ) )

(de ps @
   (let A (arg 1)
      (if (memq A (0 NIL T))
         (next)
         (off A) )
      (prin
         "")
   (let H NIL
      (while (args)
         (let X (next)
            (cond
               ((pair X)
                  (casq (++ X)
                     (B  # Bold
                        (prin (if X "" "")) )
                     (I  # Italic
                        (prin (if X "" "")) )
                     (S  # Superscript
                        (prin (if X "" "")) )
                     (U  # Underline
                        (prin (if X "" "")) )
                     (L  # Line through
                        (prin (if X "" "")) )
                     (C  # Color
                        (if X
                           (prin "")
                           (prin "") ) ) ) )
               ((=0 X)  # Newline
                  (prin
                     "\8203\" ) )  # ZERO WIDTH SPACE
               ((=T X)  # Horizontal line
                  (push 'H (- *Pos (/ *FontSize 2)))
                  (prin
                     "\8203\" ) )  # ZERO WIDTH SPACE
               (T (ht:Prin X)) ) ) )
      (prinl "")
      (for Y H
         (polyline "black" 0 Y *DX Y) ) ) )

(de height @
   (let H *FontSize
      (while (args)
         (let X (next)
            (cond
               ((=0 X) (inc 'H *FontSize))  # Newline
               ((=T X) (inc 'H (*/ *FontSize 2 3))) ) ) )  # Horizontal line
      H ) )

(local) (down table hline vline)
(private) (Fmt Prg)

(de down (N)
   (inc '*Pos (or N *FontSize)) )

(de table (Fmt . Prg)
   (let (PosX 0  Max *FontSize)
      (ifn (=T Fmt)
         (mapc
            '((N Exe)
               (when
                  (or
                     (nT (car (pair Exe)))
                     (setq Exe (run (cdr Exe) 2)) )
                  (window PosX *Pos N Max
                     (if (atom Exe)
                        (ps NIL (eval Exe 3))
                        (eval Exe 3) )
                     (inc 'PosX N)
                     (setq Max (max *Pos Max)) ) ) )
            Fmt
            Prg )
         (for
            (N (co 'table (run Prg) (yield))
               N
               (window PosX *Pos N Max
                  (prog1
                     (co 'table T)
                     (inc 'PosX N)
                     (setq Max (max *Pos Max)) ) ) ) )
         (co 'table) )
      (inc '*Pos Max) ) )

(de hline (Y X2 X1)
   (inc 'Y *Pos)
   (polyline "black" (or X2 *DX) Y (or X1 0) Y) )

(de vline (X Y2 Y1)
   (polyline "black" X (or Y2 *DY) X (or Y1 0)) )

(local) brief
(private) (Flg Font Abs Prg)

(de brief (Flg Font Abs . Prg)
   (when Flg
      (polyline "black" 10 265  19 265)         # Faltmarken
      (polyline "black" 10 421  19 421) )
   (polyline "black" 50 106  50 103  53 103)    # Fenstermarken
   (polyline "black" 50 222  50 225  53 225)
   (polyline "black" 288 103  291 103  291 106)
   (polyline "black" 288 225  291 225  291 222)
   (polyline "black" 50 114  291 114)           # Absender
   (window 60 102 220 10
      (font Font (ps 0 Abs)) )
   (window 65 125 210 90
      (run Prg 2) ) )

(local) (svgOut svgPages page page.svg svgPdf pdf)
(private) (Src Dst Prg Prg2)

# Direct SVG display
(de svgOut Prg
   (httpHead "image/svg+xml" 0)
   (ht:Out *Chunked (run Prg)) )

# Multipage SVG
(de svgPages (*DX *DY Dst . Prg)
   (zero *Page)
   (out Dst
      (let page
         '(Prg2
            (prin "<" (inc '*Page) ">")
            ( *DX *DY "pt"
               (run Prg2) ) )
         (run Prg) ) )
   (allow Dst) )

(de page.svg (File N)
   (in File
      (from (pack "<" N ">"))
      (echo (pack "<" (inc N) ">")) ) )

# Convert to PDF
(de svgPdf (Dst . Prg)
   (let Src (tmp "pdf.svg")
      (out Src (run Prg))
      (call "rsvg-convert" "-f" "pdf" "-o" Dst Src) )
   (allow Dst) )

# Multipage PDF
# (pdf "src" "dst")
# (pdf 'dx 'dy "dst" . prg)
(de pdf (*DX *DY Dst . Prg)
   (if Dst
      (let page  # Generate SVG files
         '(Prg2
            (out (tmp "page" (inc '*Page) ".svg")
               ( *DX *DY "pt"
                  (run Prg2) ) ) )
         (zero *Page)
         (run Prg) )
      (in *DX  # Multipage SVG file
         (when (echo (pack "<" (one *Page) ">"))
            (while
               (out (tmp "page" *Page ".svg")
                  (when (echo (pack "<" (inc *Page) ">"))
                     (inc '*Page) ) ) ) ) )
      (setq Dst *DY) )
   (apply call
      (make
         (for I *Page
            (link (tmp "page" I ".svg")) ) )
      "rsvg-convert"
      "--dpi-x" 72
      "--dpi-y" 72
      "-f" "pdf"
      "-o" Dst )
   (allow Dst) )

### Debug ###
`*Dbg

(noLint 'page)
�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������pil21/lib/canvas.l����������������������������������������������������������������������������������0000644�0000000�0000000�00000004777�14502325454�011114� 0����������������������������������������������������������������������������������������������������ustar  ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������# 19sep23 Software Lab. Alexander Burger

(allow "!jsDraw" )
(push1 '*JS (allow "@lib/plio.js") (allow "@lib/canvas.js"))

# Draw   (drawCanvas Id Dly [T])
# Click  (drawCanvas Id Dly 1 X Y)
# Double (drawCanvas Id Dly 2 X Y)
# Start  (drawCanvas Id Dly 0 X Y X2 Y2)
# Move   (drawCanvas Id Dly -1 X Y X2 Y2)
(de jsDraw (Id Dly F X Y X2 Y2)
   (http1 "application/octet-stream" 0)
   (let Lst (drawCanvas Id Dly F X Y X2 Y2)
      (prinl "Content-Length: " (bytes Lst) "\r\n\r")
      (pr Lst) ) )

# Canvas Commands
(for (Opc . L)
   (quote  # In sync with "@lib/canvas.js"
      ### Functions ###
      (csFont Str)
      (csFillText Str X Y)
      (csStrokeLine X1 Y1 X2 Y2)
      (csClearRect X Y DX DY)
      (csStrokeRect X Y DX DY)
      (csFillRect X Y DX DY)
      (csBeginPath)
      (csClosePath)
      (csMoveTo X Y)
      (csLineTo X Y)
      (csBezierCurveTo X1 Y1 X2 Y2 X Y)
      (csQuadraticCurveTo X1 Y1 X2 Y2)
      (csLine X1 Y1 X2 Y2)
      (csRect X Y DX DY)
      (csArc X Y R A B F)
      (csStroke)
      (csFill)
      (csClip)
      (csDef Key DX DY Lst)
      (csDraw Key X Y)
      (csDrawDots DX DY Lst)
      (csDrawImage Img X Y Lst DX DY Key)
      (csTranslate X Y)
      (csRotate A)
      (csScale X Y)
      (csSave)
      (csRestore)
      ### Variables ###
      (csCursor Lst)
      (csFillStyle V)
      (csStrokeStyle V)
      (csGlobalAlpha V)
      (csLineWidth V)
      (csLineCap V)
      (csLineJoin V)
      (csMiterLimit V)
      (csGlobalCompositeOperation V)
      (csDelay N)
      (csPost) )
   (def (car L)
      (list
         (cdr L)
         (list 'link
            (if (cdr L)
               (cons 'list Opc @)
               (list Opc) ) ) ) ) )

(de  (Id DX DY Alt)
   (prin
      "" Alt "" ) )

(de  (Id DX DY Dly Post)
   (unless (str? Id)
      (put Id 'home *Top)
      (setq Id (pack "$" Id)) )
   ( Id DX DY)
   (if Post
      ( "Post = function() {drawCanvas('" Id "', " Dly ")}; Post()")
      ( "drawCanvas('" Id "', " Dly ")") ) )

### Debug ###
`*Dbg

(noLint 'drawCanvas)
�pil21/lib/canvas.js���������������������������������������������������������������������������������0000644�0000000�0000000�00000023147�14743755755�011307� 0����������������������������������������������������������������������������������������������������ustar  ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* 21jan25 Software Lab. Alexander Burger */

function renderCanvas(cvs, lst) {
   var ctx = cvs.getContext("2d");
   var cmd, i, j;

   if (lst) {
      for (i = 0; i < lst.length; ++i) {
         switch ((cmd = lst[i])[0]) {  // Sync with "@lib/canvas.l"
         /*** Functions ***/
         case 1:  // (csFont Str)
            ctx.font = cmd[1];
         case 2:  // (csFillText Str X Y)
            ctx.fillText(cmd[1], cmd[2], cmd[3]);
            break;
         case 3:  // (csStrokeLine X1 Y1 X2 Y2)
            ctx.beginPath();
            ctx.moveTo(cmd[1], cmd[2]);
            ctx.lineTo(cmd[3], cmd[4]);
            ctx.closePath();
            ctx.stroke();
            break;
         case 4:  // (csClearRect X Y DX DY)
            ctx.clearRect(cmd[1], cmd[2], cmd[3], cmd[4]);
            break;
         case 5:  // (csStrokeRect X Y DX DY)
            ctx.strokeRect(cmd[1], cmd[2], cmd[3], cmd[4]);
            break;
         case 6:  // (csFillRect X Y DX DY)
            ctx.fillRect(cmd[1], cmd[2], cmd[3], cmd[4]);
            break;
         case 7:  // (csBeginPath)
            ctx.beginPath();
            break;
         case 8:  // (csClosePath)
            ctx.closePath();
            break;
         case 9:  // (csMoveTo X Y)
            ctx.moveTo(cmd[1], cmd[2]);
            break;
         case 10:  // (csLineTo X Y)
            ctx.lineTo(cmd[1], cmd[2]);
            break;
         case 11:  // (csBezierCurveTo X1 Y1 X2 Y2 X Y)
            ctx.bezierCurveTo(cmd[1], cmd[2], cmd[3], cmd[4], cmd[5], cmd[6]);
            break;
         case 12:  // (csQuadraticCurveTo X1 Y1 X2 Y2)
            ctx.quadraticCurveTo(cmd[1], cmd[2], cmd[3], cmd[4]);
            break;
         case 13:  // (csLine X1 Y1 X2 Y2)
            ctx.moveTo(cmd[1], cmd[2]);
            ctx.lineTo(cmd[3], cmd[4]);
            break;
         case 14:  // (csRect X Y DX DY)
            ctx.rect(cmd[1], cmd[2], cmd[3], cmd[4]);
            break;
         case 15:  // (csArc X Y R A B F)
            ctx.arc(cmd[1], cmd[2], cmd[3], cmd[4], cmd[5], cmd[6]);
            break;
         case 16:  // (csStroke)
            ctx.stroke();
            break;
         case 17:  // (csFill)
            ctx.fill();
            break;
         case 18:  // (csClip)
            ctx.clip();
            break;
         case 19:  // (csDef Key [DX DY Lst])
            if (!cvs.pre)
               cvs.pre = new Array();
            var buf = cvs.pre[cmd[1]] = document.createElement('canvas');
            if (cmd[2]) {
               buf.width = cmd[2];
               buf.height = cmd[3];
               renderCanvas(buf, cmd[4]);
            }
            else {
               buf.width = cvs.width;
               buf.height = cvs.height;
               buf.getContext("2d").drawImage(cvs, 0, 0);
            }
            break;
         case 20:  // (csDraw Key X Y)
            var buf = cvs.pre[cmd[1]];
            ctx.clearRect(cmd[2], cmd[3], buf.width, buf.height);
            ctx.drawImage(buf, cmd[2], cmd[3]);
            break;
         case 21:  // (csDrawDots DX DY Lst)
            if (cmd[3])
               for (j = 0; j < cmd[3].length; j += 2)
                  ctx.fillRect(cmd[3][j], cmd[3][j+1], cmd[1], cmd[2]);
            break;
         case 22:  // (csDrawImage Img X Y Lst DX DY [Key])
            var img;

            if (cmd[7]  &&  (img = (cvs.img || (cvs.img = new Array()))[cmd[7]])) {
               if (img.lst.length > 0)
                  img.lst.push([cmd[2], cmd[3], cmd[4], cmd[5], cmd[6]]);
               else {
                  if (cmd[5])
                     ctx.drawImage(img, cmd[2], cmd[3], cmd[5], cmd[6]);
                  else
                     ctx.drawImage(img, cmd[2], cmd[3]);
                  if (cmd[4])
                     renderCanvas(cvs, cmd[4]);
               }
            }
            else {
               (img = new Image()).src = cmd[1];
               img.lst = [[cmd[2], cmd[3], cmd[4], cmd[5], cmd[6]]];
               (function (img) {
                  img.onload = function() {
                     do {
                        var a = img.lst.shift();
                        if (a[3])
                           ctx.drawImage(img, a[0], a[1], a[3], a[4]);
                        else
                           ctx.drawImage(img, a[0], a[1]);
                        if (a[2])
                           renderCanvas(cvs, a[2]);
                     } while (img.lst.length > 0);
                  } } )(img);
               if (cmd[7])
                  cvs.img[cmd[7]] = img;
            }
            break;
         case 23:  // (csTranslate X Y)
            ctx.translate(cmd[1], cmd[2]);
            break;
         case 24:  // (csRotate A)
            ctx.rotate(cmd[1]);
            break;
         case 25:  // (csScale X Y)
            ctx.scale(cmd[1], cmd[2]);
            break;
         case 26:  // (csSave)
            ctx.save();
            break;
         case 27:  // (csRestore)
            ctx.restore();
            break;
         /*** Variables ***/
         case 28:  // (csCursor Lst)
            cvs.curs = cmd[1];
            break;
         case 29:  // (csFillStyle V)
            ctx.fillStyle = cmd[1];
            break;
         case 30:  // (csStrokeStyle V)
            ctx.strokeStyle = cmd[1];
            break;
         case 31:  // (csGlobalAlpha V)
            ctx.globalAlpha = cmd[1];
            break;
         case 32:  // (csLineWidth V)
            ctx.lineWidth = cmd[1];
            break;
         case 33:  // (csLineCap V)
            ctx.lineCap = cmd[1];
            break;
         case 34:  // (csLineJoin V)
            ctx.lineJoin = cmd[1];
            break;
         case 35:  // (csMiterLimit V)
            ctx.miterLimit = cmd[1];
            break;
         case 36:  // (csGlobalCompositeOperation V)
            ctx.globalCompositeOperation = cmd[1];
            break;
         case 37:  // (csDelay N)
            cvs.dly = cmd[1];
            break;
         case 38:  // (csPost)
            cvs.post = true;
            break;
         }
      }
   }
}

function drawCanvas(id, dly) {
   var req = new XMLHttpRequest();
   var url = document.getElementsByTagName("BASE")[0].href + SesId + "!jsDraw?" + id + "&+" + dly;
   var flg = arguments[2];

   for (var i = 2; i < arguments.length; ++i)
      if (typeof arguments[i] === "number")
         url += "&+" + arguments[i];
      else
         url += "&" + arguments[i];
   try {req.open("POST", url);}
   catch (e) {return true;}
   req.responseType = "arraybuffer";
   req.onload = function() {
      var ele = document.getElementById(id);

      ele.dly = dly;
      renderCanvas(ele, plio(new Uint8Array(req.response)));
      if (ele.post) {
         ele.post = false;
         while (ele = ele.parentNode) {
            if (ele.tagName == "FORM") {
               post(ele, false, null, null);
               break;
            }
         }
      }
      if (!flg) {
         if (ele.auto)
            clearTimeout(ele.auto);
         if (ele.dly == 0)
            drawCanvas(id, 0);
         else if (ele.dly > 0)
            ele.auto = setTimeout(function() {drawCanvas(id, dly)}, ele.dly);
      }
      ele.dly = dly;
   };
   try {req.send(null);}
   catch (e) {
      req.abort();
      return true;
   }
   return false;
}

function doCsDn(cvs, x, y) {
   var r = cvs.getBoundingClientRect();

   cvs.csDn = true;
   cvs.csDnX = x - r.left;
   cvs.csDnY = y - r.top;
   cvs.csMv = false;
   return false;
}

function csMouseDn(cvs, event) {
   return doCsDn(cvs, event.clientX, event.clientY);
}

function csTouchDn(cvs, event) {
   return doCsDn(cvs, event.touches[0].clientX, event.touches[0].clientY);
}

function doCsMv(cvs, x, y) {
   var r = cvs.getBoundingClientRect();

   if (cvs.curs)
      csCursor(cvs, x - r.left, y - r.top);
   if (!cvs.csDn)
      return true;
   if (!cvs.csMv)
      cvs.csMv = [x, y];
   else {
      if (Array.isArray(cvs.csMv)) {
         if (drawCanvas(cvs.id, cvs.dly, 0, cvs.csDnX, cvs.csDnY, cvs.csMv[0] - r.left, cvs.csMv[1] - r.top))
            return true;
         cvs.csMv = true;
      }
      if (drawCanvas(cvs.id, cvs.dly, -1, cvs.csDnX, cvs.csDnY, x - r.left, y - r.top))
         return true;
   }
   return false;
}

function csMouseMv(cvs, event) {
   return doCsMv(cvs, event.clientX, event.clientY);
}

function csTouchMv(cvs, event) {
   if (event.targetTouches.length == 1) {
      event.preventDefault();
      return doCsMv(cvs, event.touches[0].clientX, event.touches[0].clientY);
   }
   return false;
}

function csMouseUp(cvs) {
   cvs.csDn = false;
   if (cvs.clicked) {
      clearTimeout(cvs.clicked);
      cvs.clicked = null;
      return drawCanvas(cvs.id, cvs.dly, 2, cvs.csDnX, cvs.csDnY);
   }
   if (cvs.csMv)
      return drawCanvas(cvs.id, cvs.dly, "$T");
   cvs.clicked = setTimeout(
      function() {
         cvs.clicked = null;
         drawCanvas(cvs.id, cvs.dly, 1, cvs.csDnX, cvs.csDnY);
      },
      200 );
   return false;
}

function csTouchEnd(cvs) {
   cvs.csDn = false;
   if (cvs.csMv)
      return drawCanvas(cvs.id, cvs.dly, "$T");
   return false;
}

function csLeave(cvs) {
   cvs.style.cursor = "";
   cvs.csDn = cvs.csMv = false;
   if (cvs.clicked) {
      clearTimeout(cvs.clicked);
      cvs.clicked = null;
   }
   return drawCanvas(cvs.id, cvs.dly, "$T");
}

function csCursor(cvs, x, y) {
   var a;

   for (var i = 0; i < cvs.curs.length; ++i) {
      if (typeof (a = cvs.curs[i]) === "string") {
         cvs.style.cursor = a;
         return;
      }
      for (var j = 1; j < a.length; j += 4) {
         if (a[j] <= x && x <= a[j+2] && a[j+1] <= y && y <= a[j+3]) {
            cvs.style.cursor = a[0];
            return;
         }
      }
   }
   cvs.style.cursor = "";
}
�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������pil21/lib/plio.js�����������������������������������������������������������������������������������0000644�0000000�0000000�00000003055�14146652227�010756� 0����������������������������������������������������������������������������������������������������ustar  ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* 22nov21 Software Lab. Alexander Burger */

function plio(lst) {
   var NIX = 0;
   var BEG = 1;
   var DOT = 2;
   var END = 3;

   var NUMBER    = 0;
   var INTERN    = 1;
   var TRANSIENT = 2;

   var PlioPos = 1;
   var PlioLst = lst;
   var PlioCnt, PlioMore;

   function byte() {
      if (PlioCnt == 0) {
         if (!PlioMore || (PlioCnt = PlioLst[PlioPos++]) == 0)
            return -1;
         PlioMore = PlioCnt == 255;
      }
      --PlioCnt;
      return PlioLst[PlioPos++];
   }

   function expr(c) {
      if ((c & ~3) !== 0) {  // Atom
         PlioMore = (PlioCnt = c >> 2) === 63;
         if ((c & 3) === NUMBER) {
            c = byte();
            var n = c >> 1;
            var s = c & 1;
            var m = 128;
            while ((c = byte()) >= 0) {
               n += c * m;
               m *= 256;
            }
            return s == 0? n : -n;
         }
         var str = "";  // TRANSIENT
         while ((c = byte()) >= 0) {
            if ((c & 0x80) != 0) {
               if ((c & 0x20) == 0)
                  c &= 0x1F;
               else
                  c = (c & 0xF) << 6 | byte() & 0x3F;
               c = c << 6 | byte() & 0x3F;
            }
            str += String.fromCharCode(c);
         }
         return str;
      }
      if (c !== BEG)  // NIX, DOT or END
         return null;
      var i = 0;
      var lst = new Array();
      lst[0] = expr(PlioLst[PlioPos++]);
      while ((c = PlioLst[PlioPos++]) !== END  &&  c !== DOT)
         lst[++i] = expr(c);
      return lst;
   }

   return expr(PlioLst[0]);
}
�����������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������pil21/lib/android.l���������������������������������������������������������������������������������0000644�0000000�0000000�00000027213�14660553042�011250� 0����������������������������������������������������������������������������������������������������ustar  ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������# 19aug24 Software Lab. Alexander Burger

(ifn (info "UUID")
   (off *Uuid)
   (setq *Uuid (in "UUID" (line T)))
   (for F '("JAVA" "LISP" "RQST" "RPLY" "BOSS")
      (%@ "unlink" 'I F)
      (%@ "mkfifo" 'I F `(oct "600")) )
   (hear (open "BOSS")) )

(symbols 'android 'pico)

# SSL
(and *Uuid (sys "SSL_CERT_FILE" "tls/cert.pem"))

# Android Context
(local) (CONTEXT GUI Config javaExt)

(de CONTEXT . {H@@@40000000000})  # file 32768, obj (hex "100000000")

# (javaExt 'fun 'lst ..)
(de javaExt @
   (setq *Ext
      (sort
         (make
            (link (cons 32768 java))
            (while (next)
               (for N (next)
                  (link (cons N @)) ) ) ) ) ) )

# Java I/O
# (java "cls" 'T ['any ..]) -> obj         New object
# (java 'obj ['n] 'msg ['any ..]) -> any   Send message to object
# (java 'obj "fld" ['any]) -> any          Value of object field
# (java "cls" ['n] 'msg ['any ..]) -> any  Call method in class
# (java "cls" "fld" ['any]) -> any         Value of class field
# (java T "cls" ["cls" ..]) -> obj         Define interface
# (java 'obj) -> [lst ..]                  Reflect object
# (java "cls") -> cls                      Get class
# (java NIL 'obj) -> NIL                   Release reference to object
(local) (*Java *Lisp java1 java null)

(de java1 ()
   (unless *Java
      (setq *Java (open "JAVA")  *Lisp (open "LISP"))
      (let Rply (open "RPLY")
         (task (open "RQST")  Rply Rply
            (ext 32768
               (in @
                  (let (X (rd)  Obj (rd)  Lst (rd))
                     (nond
                        ((num? X)
                           (out Rply
                              (pr
                                 (and (get X Obj) (ext 0 (apply @ Lst))) ) ) )
                        ((get Obj 'catch)
                           (and *Dbg (tty (println Obj X Lst))) )
                        (NIL (ext 0 (apply @ Lst X))) ) ) ) ) )
         (push '*Fork
            '(off *Java *Lisp)
            (list 'mapc 'close (list Rply *Java *Lisp)) ) )
      (javaExt) ) )

(de java @
   (ext 32768
      (out *Java (pr (rest)))
      (in *Lisp
         (for (X (rd) X (rd))
            (and (=0 X) (quit (rd)))  # 0: Exception
            (let (Obj (rd)  Lst (rd))  # Callback
               (out *Java
                  (pr
                     (and (get X Obj) (ext 0 (apply @ Lst))) ) ) ) )
         (rd) ) ) )

(de null . null)

# Android device ID
(local) dev

(de dev ()
   (java "android.provider.Settings$Secure" 'getString
      (java CONTEXT 'getContentResolver)
      "android_id" ) )

# Push-Load
(local) (loadTxt loadUrl overview)

(de loadTxt @
   (java (; CONTEXT GUI) 'runOnUiThread
      (java (; CONTEXT GUI PilView) 0 'loadData
         (pack "" (pass pack) "")
         "text/html; charset=utf-8"
         null ) ) )

(de loadUrl @
   (java (; CONTEXT GUI) 'runOnUiThread
      (java (; CONTEXT GUI PilView) 0 'loadUrl (pass pack)) ) )

(de overview (Flg)
   (java (; CONTEXT GUI Config) 'setUseWideViewPort Flg)
   (java (; CONTEXT GUI Config) 'setLoadWithOverviewMode Flg) )

# Clear WebView history and cache
(local) (clearHistory clearCache)

(de clearHistory ()
   (java CONTEXT 'clearHistory) )

(de clearCache ()
   (java (; CONTEXT GUI) 'runOnUiThread
      (java (; CONTEXT GUI PilView) 0 'clearCache T) ) )

# Get permissions
(local) permit

(de permit (Str)
   (or
      (=0
         (java  "androidx.core.content.ContextCompat"
            'checkSelfPermission
            (; CONTEXT GUI)
            Str ) )
      (java  "androidx.core.app.ActivityCompat"
         'requestPermissions
         (; CONTEXT GUI)
         (list Str)
         0 ) ) )

# Wake lock
(local) (*Wake wake)

(de wake @  # (wake ['flg])
   (default *Wake  # PowerManager.WakeLock
      (java
         (java CONTEXT 'getSystemService "power")  # PowerManager
         'newWakeLock 1 "PilWake" ) )              # PARTIAL_WAKE_LOCK = 1
   (when (args)
      (cond
         ((next) (java *Wake 'acquire))
         ((java *Wake 'isHeld) (java *Wake 'release)) ) )
   (java *Wake 'isHeld) )

# Check if WIFI is active
(local) wifi?

(de wifi? ()
   (and
      (java
         (java CONTEXT 'getSystemService "connectivity")  # ConnectivityManager
         'getActiveNetworkInfo )  # NetworkInfo
      (=1 (java @ 'getType)) ) )  # onnectivityManager.TYPE_WIFI

# Generate file content URI
(local) fileUri

(de fileUri (File)
   (java "androidx.core.content.FileProvider" 'getUriForFile
      CONTEXT "de.software_lab.pilbox.fileprovider"
      (java "java.io.File" T File) ) )

# Update APK
(local) (update? update)

(de update? ()
   (gt0  # (java (java CONTEXT 'getPackageManager) 'canRequestPackageInstalls)
      (java "android.provider.Settings$Secure" 'getInt
         (java CONTEXT 'getContentResolver) "install_non_market_apps" ) ) )

(de update (File)
   (java (; CONTEXT GUI) 'startActivity
      (prog1
         (java "android.content.Intent" T "android.intent.action.INSTALL_PACKAGE")
         (java @ 'setFlags 1)  # Intent.FLAG_GRANT_READ_URI_PERMISSION
         (java @ 'setData (fileUri File)) ) ) )

# Toast
(local) toast

(de toast (X . @)
   (java CONTEXT 'toast (pass pack X))
   X )

# Notification
(local) (*Notify notify)

(de notify (Id Ttl Msg File Url)
   (let N (java CONTEXT 'getSystemService "notification")  # NotificationManager
      (ifn Ttl
         (java N 'cancel Id)
         (unless *Notify
            (java N 'createNotificationChannel
               (java "android.app.NotificationChannel" T "pil" "PilBox" 2) )  # IMPORTANCE_LOW = 2
            (on *Notify) )
         (let B (java "android.app.Notification$Builder" T CONTEXT "pil")
            (java B 'setSmallIcon (java "de.software_lab.pilbox.R$drawable" "notify"))
            (java B 'setContentTitle Ttl)
            (java B 'setContentText (or Msg null))
            (java B 'setAutoCancel T)
            (let Intent (java "android.content.Intent" T CONTEXT (java "de.software_lab.pilbox.PilBoxActivity"))  # Activity class
               (java Intent 'setFlags `(hex "24000000"))  # FLAG_ACTIVITY_SINGLE_TOP | FLAG_ACTIVITY_NEW_TASK
               (when File
                  (java Intent 'setAction "RPC")
                  (java Intent 'putExtra "UUID" *Uuid)
                  (java Intent 'putExtra "SRC" File)
                  (java Intent 'putExtra "ARG" Id)
                  (java Intent 'putExtra "URL" Url) )
               (java B 'setContentIntent
                  (java "android.app.PendingIntent" 'getActivity
                     CONTEXT 0 Intent `(hex "1C000000") ) ) )  # FLAG_ACTIVITY_NEW_TASK | FLAG_UPDATE_CURRENT | FLAG_IMMUTABLE
            (prog1
               (java B 'build)  # Notification
               (java N 'notify Id @) ) ) ) ) )

# Service foreground state
(local) (startForeground stopForeground)

(de startForeground (Ttl Msg Type)
   (java CONTEXT 'startForeground 1
      (notify 1 Ttl Msg)
      ~(as (>= (format (sys "SDK_INT")) 29) Type) ) )

(de stopForeground ()
   (java CONTEXT 'stopForeground T) )

# Start Activity for a result
(local) (*ResultProxy *ProxyResults startActivityForResult good bad)

(de startActivityForResult (Fun Action . @)
   (let Intent (java "android.content.Intent" T Action)
      (catch '("ActivityNotFound")
         (while (args)
            (let S (next)
               (if (str? S)
                  (java Intent 'putExtra S (next))
                  (java Intent S (next) (next)) ) ) )
         (unless *ResultProxy
            (setq *ResultProxy (java T "de.software_lab.pilbox.ResultProxy"))
            (def 'good *ResultProxy
               '((Req Intent)
                  (when (asoq Req *ProxyResults)
                     (del @ '*ProxyResults)
                     ((cdr @) Intent) ) ) )
            (def 'bad *ResultProxy
               '((Req Res)
                  (del (asoq Req *ProxyResults) '*ProxyResults) ) ) )
         (let Req (inc (0))
            (push '*ProxyResults (cons Req Fun))
            (java CONTEXT 'setResultProxy *ResultProxy)
            (java (; CONTEXT GUI) 'startActivityForResult Intent Req) ) ) ) )

# GPS access
(local) (*LocMan *GpsLsn *NetLsn location? gps)

(de location? ()
   (permit "android.permission.ACCESS_FINE_LOCATION") )

(de gps (Flg)
   (if Flg
      (when *LocMan
         (java *LocMan 'removeUpdates *GpsLsn)
         (java *LocMan 'removeUpdates *NetLsn)
         (off *LocMan) )
      (unless *LocMan
         (setq
            *LocMan (java CONTEXT 'getSystemService "location")
            *GpsLsn (java T "android.location.LocationListener")
            *NetLsn (java T "android.location.LocationListener") )
         (java *LocMan 'requestLocationUpdates "gps" (20000 . L) (100 . -1000) *GpsLsn)
         (java *LocMan 'requestLocationUpdates "network" (20000 . L) (100 . -1000) *NetLsn) )
      (and
         (or
            (and
               (java *LocMan 'isProviderEnabled "gps")
               (java *LocMan 'getLastKnownLocation "gps") )
            (and
               (java *LocMan 'isProviderEnabled "network")
               (java *LocMan 'getLastKnownLocation "network") ) )
         (cons
            (+ (java @ 'getLatitude) 90000000)
            (+ (java @ 'getLongitude) 180000000) ) ) ) )

# Camera access
(local) (camera? takePicture)

(de camera? ()
   (and
      (java (java CONTEXT 'getPackageManager) 'hasSystemFeature "android.hardware.camera")
      (permit "android.permission.CAMERA") ) )

## '((Intent)
##    (setq *Picture (tmp "img"))
##    (loadUrl (baseHRef) *SesId "app/camera.l") )
(de takePicture (Dst Fun)
   (out Dst)
   (startActivityForResult Fun
      "android.media.action.IMAGE_CAPTURE"
      "output" (fileUri Dst) ) )

# ZXing QR-Codes
## '((Intent)
##    (java Intent 'getStringExtra "SCAN_RESULT")
##    (java Intent 'getStringExtra "SCAN_RESULT_FORMAT") )
(local) scanQR

(de scanQR (Fun)
   (startActivityForResult Fun
      "com.google.zxing.client.android.SCAN"
      "SCAN_MODE" "QR_CODE_MODE" ) )

# Alarm
(local) (alarm? alarm)

(de alarm? ()
   ~(as (>= (format (sys "SDK_INT")) 31)
      (java (java CONTEXT 'getSystemService "alarm") 'canScheduleExactAlarms) )  # AlarmManager
   ~(as (> 31 (format (sys "SDK_INT"))) T) )

(de alarm (N When File Url)
   (let
      (Intent (java "android.content.Intent" T CONTEXT (java "de.software_lab.pilbox.Receiver"))
         Alarm (java CONTEXT 'getSystemService "alarm") )  # AlarmManager
      (ifn When
         (java Alarm 'cancel
            (java "android.app.PendingIntent" 'getBroadcast
               CONTEXT N Intent `(hex "1C000000") ) )  # FLAG_ACTIVITY_NEW_TASK | FLAG_UPDATE_CURRENT | FLAG_IMMUTABLE
         (java Intent 'putExtra "UUID" *Uuid)
         (java Intent 'putExtra "SRC" File)
         (java Intent 'putExtra "ARG" N)
         (java Intent 'putExtra "URL" Url)
         (java Alarm 'setExactAndAllowWhileIdle
            (if (atom When) 2 0)  # ELAPSED_REALTIME_WAKEUP RTC_WAKEUP
            (cons
               (if (atom When)
                  (+
                     (* 1000 When)
                     (java "android.os.SystemClock" 'elapsedRealtime) )
                  (let
                     (Dat (date (car When))
                        Tim (time (cdr When))
                        C (java "android.icu.util.Calendar" 'getInstance) )
                     (java C 'set
                        (car Dat) (dec (cadr Dat)) (caddr Dat)
                        (car Tim) (cadr Tim) (caddr Tim) )
                     (java C 'getTimeInMillis) ) )
               'L )
            (java "android.app.PendingIntent" 'getBroadcast
               CONTEXT N Intent `(hex "1C000000") ) ) ) ) )  # FLAG_ACTIVITY_NEW_TASK | FLAG_UPDATE_CURRENT | FLAG_IMMUTABLE

# Restart PilBox
(local) restart

(de restart ()
   (loadTxt)  # Blank screen
   (java (java (; CONTEXT GUI) 0 'restart) 'start)
   (wait) )

### Debug ###
`*Dbg

(noLint 'null)
pil21/lib/gis.l0000644000000000000000000000755714262263347010427 0ustar  # 09jul22 Software Lab. Alexander Burger

(symbols 'gis 'pico)

(push1 '*JS (allow "@lib/gis.js"))

(local) (lat lon fmt)

(de lat (Lat F)
   (dec 'Lat 90.0)
   (if F
      (format (*/ Lat 1000 1.0) 3)
      (format Lat `*Scl) ) )

(de lon (Lon F)
   (dec 'Lon 180.0)
   (if F
      (format (*/ Lon 1000 1.0) 3)
      (format Lon `*Scl) ) )

(de fmt (Lat Str Lon F)
   (when (or Lat Lon)
      (pack (lat Lat F) Str (lon Lon F)) ) )

# Short distance, assuming flat earth
(local) distance

(de distance (Lat1 Lon1 Lat2 Lon2)  # [m]
   (let
      (DX (*/ (- Lon2 Lon1) 6371000 pi 180.0)
         DY (*/ (cos (*/ Lat1 pi 180.0)) (- Lat2 Lat1) 6371000 pi `(* 1.0 180.0)) )
      (sqrt (+ (* DX DX) (* DY DY))) ) )

# Latitude Field
(local) +LatField

(class +LatField +Fmt +FixField)

(dm T @
   (pass super
      '((Num) (- Num 90.0))
      '((Lat) (+ Lat 90.0))
      `*Scl ) )

# Longitude Field
(local) +LonField

(class +LonField +Fmt +FixField)

(dm T @
   (pass super
      '((Num) (- Num 180.0))
      '((Lon) (+ Lon 180.0))
      `*Scl ) )

# Clickable position field
(local) +LatLonField

(class +LatLonField +TextField)

(dm T (Msg . @)
   (=: msg Msg)
   (pass super)
   (=: able) )

(dm set> (X Dn)
   (=: obj (car X))
   (=: lt (cadr X))
   (=: ln (cddr X))
   (super (fmt (: lt) ", " (: ln)) Dn) )

(dm js> ()
   (if (try (: msg) (: obj) (: lt) (: ln))
      (pack
         (fmt (: lt) ", " (: ln))
         "&+"
         (ht:Fmt (sesId (mkUrl @))) )
      (super) ) )

(dm val> ()
   (cons (: obj) (: lt) (: ln)) )

(dm show> ("Var")
   (showFld
      (if (try (: msg) (: obj) (: lt) (: ln))
         (
            (fmt (: lt) ", " (: ln))
            (mkUrl @) )
         (super "Var") ) ) )

# OpenLayers / OpenStreetMap
# (val *Osm) -> ((lat1 . lat2) (lon1 . lon2) . zoom)
(local) (*Osm  osmStat osmClick osmDrag  )

(mapc allow '(osmStat osmClick osmDrag osmHover))

(de  (Lat Lon Zoom Click Upd)
   (
 '(map (id . map)))
   (when (val *Osm)
      (setq
         Lat (*/ (+ (caar @) (cdar @)) 2)
         Lon (*/ (+ (caadr @) (cdadr @)) 2)
         Zoom (cddr @) ) )
   (with *Top
      (css "https://cdn.rawgit.com/openlayers/openlayers.github.io/master/en/v5.3.0/css/ol.css")
      (javascript "https://cdn.rawgit.com/openlayers/openlayers.github.io/master/en/v5.3.0/build/ol.js"
         "osm('map', " Lat ", " Lon ", " Zoom ", "
         (if2 Click (and Upd (: able)) 2 1 0 0) ")" )
      (=: osmClick Click) ) )

(de osmStat (Lat1 Lon1 Lat2 Lon2 Zoom)
   (when *Osm
      (set @
         (cons
            (cons Lat1 Lat2)
            (cons Lon1 Lon2)
            Zoom ) ) ) )

(de osmClick (Lat Lon)
   (with *Top
      (and (: osmClick) (@ Lat Lon)) ) )

(de osmDrag (Txt Lat Lon)
   (with *Top
      (and
         (: able)
         (assoc Txt (: osmDrag))
         ((cdr @) Txt Lat Lon) ) ) )

(de osmHover (Txt)
   (with *Top
      (and
         (assoc Txt (: osmHover))
         ((cdr @) Txt) ) ) )

(de  (Lat Lon Img X Y Txt DY Col Url Drag Upd Hover)
   (with *Top
      (
         "poi(" Lat ", " Lon ", '" (sesId Img) "', " X ", " Y ", '"
         (replace (chop Txt) "\\" "\\\\" "'" "\\'")
         "', " DY ", '" Col "', '" (and Url (sesId @)) "', "
         (if2 (and Drag (: able)) Upd 2 1 0 0) ")" )
      (and Drag (push (:: osmDrag) (cons Txt @)))
      (and Hover (push (:: osmHover) (cons Txt @))) ) )

(de  (Col Lat1 Lon1 Lat2 Lon2)
   (with *Top
      (
         "line('" Col "', " Lat1 ", " Lon1 ", " Lat2 ", " Lon2 ")" ) ) )

# Google Maps
(local) (google )

(de google (Ttl Lat Lon Zoom Tar)
   ( Ttl
      (pack "https://www.google.com/maps/@" (fmt Lat "," Lon) "," Zoom "z")
      Tar ) )

(de  (Lat Lon DX DY)
   (prinl
      "" ) )
pil21/lib/gis.js0000644000000000000000000000632314146652253010575 0ustar  /* 22nov21 Software Lab. Alexander Burger */

var Map;
var Sources;

function osm(id, lat, lon, zoom, click) {
   Map = new ol.Map( {
      target: id,
      view: new ol.View( {
         center: ol.proj.fromLonLat([lon/1000000-180, lat/1000000-90]),
         zoom: zoom
      } ),
      layers: [
         new ol.layer.Tile({source: new ol.source.OSM()}),
         new ol.layer.Vector( {
            source: Sources = new ol.source.Vector({features: []})
         } )
      ]
   } );
   Map.form = document.getElementById(id).parentNode;
   while (Map.form  &&  Map.form.tagName != "FORM")
      Map.form = Map.form.parentNode;

   Map.on("pointermove", function (evt) {
      Map.getViewport().style.cursor = "";
      Map.forEachFeatureAtPixel(evt.pixel, function (feature, layer) {
         if (feature.href)
            Map.getViewport().style.cursor = "pointer";
         lisp(Map.form, "osmHover", feature.txt);
      } )
   } );

   Map.on("click", function(evt) {
      Map.forEachFeatureAtPixel(evt.pixel, function (feature, layer) {
         if (feature.href) {
            window.location.href = feature.href;
            return;
         }
      } )
      if (click > 0) {
         var pt = ol.proj.toLonLat(evt.coordinate);
         lisp(Map.form, "osmClick", (pt[1] + 90) * 1000000, (pt[0] + 180) * 1000000);
         if (click > 1)
            window.location.reload(true);
      }
   } );

   Map.on("moveend", function() {
      var view = Map.getView().calculateExtent(Map.getSize());
      var a = ol.proj.toLonLat([view[0], view[1]]);
      var b = ol.proj.toLonLat([view[2], view[3]]);
      lisp(Map.form, "osmStat",
         (a[1] + 90) * 1000000, (a[0] + 180) * 1000000,
         (b[1] + 90) * 1000000, (b[0] + 180) * 1000000,
         Map.getView().getZoom() );
   } );
}

function poi(lat, lon, img, x, y, txt, dy, col, url, drag) {
   var feature = new ol.Feature( {
      geometry: new ol.geom.Point(ol.proj.fromLonLat([lon/1000000-180, lat/1000000-90]))
   } );

   feature.setStyle( [
      new ol.style.Style( {
         image: new ol.style.Icon( {
            src: img,
            anchor: [x, y]
         } ),
         text: new ol.style.Text( {
            text: txt,
            offsetY: dy,
            fill: new ol.style.Fill({color: col})
         } )
      } )
   ] );

   if (drag > 0) {
      Map.addInteraction(new ol.interaction.Translate( {
         features: new ol.Collection([feature])
      } ) );
      feature.on('change', function() {
            var pt = ol.proj.toLonLat(this.getGeometry().getCoordinates());
            lisp(Map.form, "osmDrag", txt, (pt[1] + 90) * 1000000, (pt[0] + 180) * 1000000);
            if (drag > 1)
               window.location.reload(true);
         },
         feature );
   }
   feature.txt = txt;
   feature.href = decodeURIComponent(url);
   Sources.addFeature(feature);
}

function line(col, lat1, lon1, lat2, lon2) {
   var feature = new ol.Feature( {
      geometry: new ol.geom.LineString( [
         ol.proj.fromLonLat([lon1/1000000-180, lat1/1000000-90]),
         ol.proj.fromLonLat([lon2/1000000-180, lat2/1000000-90]) ] )
   } );
   feature.setStyle( [
      new ol.style.Style( {
         stroke: new ol.style.Stroke({color: col})
      } )
   ] );
   Sources.addFeature(feature);
}
pil21/lib/json.l0000644000000000000000000000713414747344127010611 0ustar  # 01feb25 Software Lab. Alexander Burger

(de checkJson (X Item)
   (unless (= X Item)
      (quit "Bad JSON" Item) ) )

(de parseJson (Str Arr)
   (let L (str Str "_")
      (recur ()
         (case (++ L)
            ("{"
               (make
                  (for (X (recurse) (not (= "}" X)) (recurse))
                     (checkJson ":" (recurse))
                     (link (cons (intern X) (recurse)))
                     (T (= "}" (setq X (recurse))))
                     (checkJson "," X) ) ) )
            ("["
               (make
                  (and Arr (link T))  # Array marker
                  (for (X (recurse) (not (= "]" X)) (recurse))
                     (link X)
                     (T (= "]" (setq X (recurse))))
                     (checkJson "," X) ) ) )
            (T
               (let X @
                  (cond
                     ((pair X) (pack X))
                     ((and (= "-" X) (format (car L)))
                        (- (++ L)) )
                     ((and (num? X) (sub? (car L) "Ee"))
                        (and
                           (or (index "," (shift 'L)) (index "}" L))
                           (format (cut (dec @) 'L))
                           ((if (lt0 @) */ *) X (** 10 (abs @))) ) )
                     (T X) ) ) ) ) ) ) )

(de readJson (Arr)
   (case (read "_")
      ("{"
         (make
            (for (X (readJson Arr) (not (= "}" X)) (readJson Arr))
               (checkJson ":" (readJson Arr))
               (link (cons (intern X) (readJson Arr)))
               (T (= "}" (setq X (readJson Arr))))
               (checkJson "," X) ) ) )
      ("["
         (make
            (and Arr (link T))  # Array marker
            (for (X (readJson Arr) (not (= "]" X)) (readJson Arr))
               (link X)
               (T (= "]" (setq X (readJson Arr))))
               (checkJson "," X) ) ) )
      (T
         (let X @
            (cond
               ((pair X) (pack X))
               ((and (= "-" X) (format (peek)))
                  (- (read)) )
               ((and (num? X) (sub? (peek) "Ee"))
                  (when (format (cdr (till ",}")))
                     ((if (lt0 @) */ *) X (** 10 (abs @))) ) )
               (T X) ) ) ) ) )

(de packJson (Item F)
   (pack
      (make
         (recur (Item F)
            (cond
               ((atom Item) (link (if Item (sym @) "{}")))
               ((=T (car Item))
                  (link "[")
                  (map
                     '((X)
                        (recurse (car X))
                        (and (cdr X) (link ", ")) )
                     (cdr Item) )
                  (link "]") )
               ((and (car Item) (atom @) (not F))
                  (link "\"" (sym (car Item)) "\": ")
                  (recurse (cdr Item) T) )
               (T
                  (link "{")
                  (map
                     '((X)
                        (recurse (car X))
                        (and (cdr X) (link ", ")) )
                     Item )
                  (link "}") ) ) ) ) ) )

(de printJson (Item F)
   (cond
      ((atom Item) (if Item (print @) (prin "{}")))
      ((=T (car Item))
         (prin "[")
         (map
            '((X)
               (printJson (car X))
               (and (cdr X) (prin ", ")) )
            (cdr Item) )
         (prin "]") )
      ((and (car Item) (atom @) (not F))
         (prin "\"")
         (print (car Item))
         (prin "\": ")
         (printJson (cdr Item) T) )
      (T
         (prin "{")
         (map
            '((X)
               (printJson (car X))
               (and (cdr X) (prin ", ")) )
            Item )
         (prin "}") ) ) )
pil21/lib/replica.l0000644000000000000000000000252113742526112011240 0ustar  # 17oct20 Software Lab. Alexander Burger

# /bin/picolisp /lib.l @lib/replica.l      [dbs1 ..]
# /bin/ssl  443 '/!replica'    20 [60]

(argv *Arg1 *KeyFile *Journal *Pool *Blob . *Dbs)
(unless (info *KeyFile)
   (bye) )

(pool *Pool (mapcar format *Dbs) *Journal)
(when (lock)
   (bye) )

(load "@lib/net.l" "@lib/misc.l" "@lib/http.l")

(allow "!replica")

(setq
   *Arg1 (format *Arg1)
   *Port (or (format (sys "PORT")) *Arg1)
   *SSLKey (in *KeyFile (line T))
   *Replica (tmp 'replica) )

(de replicate (N)
   (and
      (out *Replica (echo N))
      (= N (car (info *Replica)))
      (= "T" (prin (peek)))
      (flush)
      (char)
      (eof) ) )

(de replica ()
   (when (= (line T) *SSLKey)
      (let? X (line T)
         (if (format X)
            (when (replicate @)                    # Journal
               (protect (journal *Replica)) )
            (let Blob (pack *Blob X)               # Blob
               (call 'mkdir "-p" (dirname Blob))
               (and
                  (format (line T))
                  (replicate @)
                  (protect (call "mv" *Replica Blob)) ) ) ) ) ) )

(retire *Arg1)

# Non-forking server
(let P (port *Port)
   (loop
      (let S (listen P)
         (http S)
         (close S) ) ) )
pil21/lib/xm.l0000644000000000000000000000645214243617724010263 0ustar  # 26may22 Software Lab. Alexander Burger

(local) (xml? xml body attr)
(private) (_xml xmlEsc escXml)

# Check or write header
(de xml? (Flg)
   (if Flg
      (prinl "")
      (skip)
      (prog1
         (head '("<" "?" "x" "m" "l") (till ">"))
         (char) ) ) )

# Generate/Parse XML data
(de xml (Lst N)
   (if Lst
      (let Tag (++ Lst)
         (space (default N 0))
         (prin "<" Tag)
         (for X (++ Lst)
            (prin " " (car X) "=\"")
            (escXml (cdr X))
            (prin "\"") )
         (nond
            (Lst (prinl "/>"))
            ((or (cdr Lst) (pair (car Lst)))
               (prin ">")
               (escXml (car Lst))
               (prinl "") )
            (NIL
               (prinl ">")
               (for X Lst
                  (if (pair X)
                     (xml X (+ 3 N))
                     (space (+ 3 N))
                     (escXml X)
                     (prinl) ) )
               (space N)
               (prinl "") ) ) )
      (skip)
      (unless (= "<" (char))
         (quit "Bad XML") )
      (_xml (till " /<>" T)) ) )

(de _xml (Tok)
   (use X
      (make
         (link (intern Tok))
         (let L
            (make
               (loop
                  (NIL (skip) (quit "XML parse error"))
                  (T (member @ '`(chop "/>")))
                  (NIL (setq X (intern (till "=" T))))
                  (char)
                  (unless (= "\"" (char))
                     (quit "XML parse error" X) )
                  (link (cons X (pack (xmlEsc (till "\"")))))
                  (char) ) )
            (if (= "/" (char))
               (prog (char) (and L (link L)))
               (link L)
               (loop
                  (NIL (skip) (quit "XML parse error" Tok))
                  (T (and (= "<" (setq X (char))) (= "/" (peek)))
                     (char)
                     (unless (= Tok (till " /<>" T))
                        (quit "Unbalanced XML" Tok) )
                     (char) )
                  (if (= "<" X)
                     (and (_xml (till " /<>" T)) (link @))
                     (link
                        (pack (xmlEsc (trim (cons X (till "\n<"))))) ) ) ) ) ) ) ) )

(de xmlEsc (L)
   (use (@X @Z)
      (make
         (while L
            (ifn (match '("&" @X ";" @Z) L)
               (link (++ L))
               (link
                  (cond
                     ((= @X '`(chop "quot")) "\"")
                     ((= @X '`(chop "amp")) "&")
                     ((= @X '`(chop "lt")) "<")
                     ((= @X '`(chop "gt")) ">")
                     ((= @X '`(chop "apos")) "'")
                     ((= "#" (car @X))
                        (char
                           (if (= "x" (cadr @X))
                              (hex (cddr @X))
                              (format (cdr @X)) ) ) )
                     (T @X) ) )
               (setq L @Z) ) ) ) ) )

(de escXml (X)
   (for C (chop X)
      (if (member C '`(chop "\"&<"))
         (prin "&#" (char C) ";")
         (prin C) ) ) )


# Access functions
(de body (Lst . @)
   (while (and (setq Lst (cddr Lst)) (args))
      (setq Lst (asoq (next) Lst)) )
   Lst )

(de attr (Lst Key . @)
   (while (args)
      (setq
         Lst (asoq Key (cddr Lst))
         Key (next) ) )
   (get Lst 2 Key) )
pil21/img/go.png0000644000000000000000000000024010523275701010560 0ustar  PNG


IHDR|lbKGD̿	pHYsDIDATmA07z	 ̻JBrVܪع9ThAckƠVIENDB`pil21/img/no.png0000644000000000000000000000015110523275366010577 0ustar  PNG


IHDR|lbKGD̿	pHYs
IDATc`,K4IENDB`pil21/lib.css0000644000000000000000000001257214146653100010162 0ustar  /* 22nov21 Software Lab. Alexander Burger */

/* Lib */
.left {float: left}
.right {float: right}
.nofloat {float: none}
.clr {clear: both}
.norm {text-align: left}
.align {text-align: right}
.center {text-align: center}
.black {color: black}
.white {color: white}
.red {color: red}
.green {color: green}
.blue {color: blue}
.yellow {color: yellow}
.larger {font-size: larger}
.smaller {font-size: smaller}
.bold {font-weight: bold}
.mono {font-family: monospace}
.wrap {white-space: normal}
.hidden {display: none}

.em1 {width: 1em}
.em2 {width: 2em}
.em3 {width: 3em}
.em5 {width: 5em}
.em7 {width: 7em}
.em10 {width: 10em}
.em15 {width: 15em}
.em20 {width: 20em}
.em25 {width: 25em}
.em30 {width: 30em}
.em40 {width: 40em}
.em50 {width: 50em}
.em60 {width: 60em}
.em70 {width: 70em}
.em80 {width: 80em}
.em90 {width: 90em}
.em100 {width: 100em}
.em120 {width: 120em}
.em150 {width: 150em}

.rel10 {width: 10%}
.rel20 {width: 20%}
.rel25 {width: 25%}
.rel30 {width: 30%}
.rel40 {width: 40%}
.rel50 {width: 50%}
.rel60 {width: 60%}
.rel70 {width: 70%}
.rel75 {width: 75%}
.rel80 {width: 80%}
.rel90 {width: 90%}
.rel96 {width: 96%}
.rel100 {width: 100%}

/* Defaults */
body {
   font-family: Arial, Helvetica, sans-serif;
   background-color: #f0f0f0;
   font-size: small;
   margin: 0;
}

img {
   border: 0;
}

fieldset {
   border-style: none;
}

input, textarea, select {
   border: 0;
   font-size: small;
   background-color: white;
}

caption {
   padding: 0 1em;
   text-align: left;
   margin-top: 2ex;
   background-color: #d0d0d0;
}

td {
   white-space: nowrap;
}

a {
   text-decoration: none;
}

.step a {
   border-radius: 6px;
   background-color: #d0d0d0;
   padding: 2px 3px;
}

a:hover {
   background-color: white;
}

.grid td {
   vertical-align: top;
}

/* Navigation */
.menu {
   padding-top: 2ex;
   background-color: #d0d0d0;
}

.menu ul {
   list-style: none;
   padding: 0;
   margin: 0;
}

.menu .cmd, .act {
   list-style-position: inside;
   list-style-type: circle;
   padding: 0 0 0 2em;
}

.menu .act {
   list-style-type: disc;
}

.menu .sub, .top {
   list-style-position: inside;
   padding: 0 0 0 1em;
}


#expires {
   position: absolute;
   top: 0;
   right: 3px;
   color: red;
}

/* Tabulators */
.tab {
   margin-bottom: 1ex;
}

.tab td {
   padding: 3px 1em;
   border-radius: 6px 6px 0 0;
}

.tab .top {
   font-weight: bold;
   border-top: 1px solid;
   border-left: 1px solid;
   border-right: 1px solid;
}

.tab .sub {
   background-color: #d0d0d0;
   border-bottom: 1px solid;
}

/* Main area */
.main {
   padding: 1ex 0 0 2ex;
}

/* Charts */
.chart {
   width: 100%;
   white-space: nowrap;
}

.chart td {
   background-color: #e0e0e0;
}

.chart td.T, th.T {
   background-color: #d0d0d0;
}

.chart td.nil, th.nil {
   background-color: white;
}

.chart td.body, th.body {
   background-color: #f0f0f0;
}

.btn {
   width: 1em;
}

/* Buttons */
.submit {
   font-weight: bold;
   font-size: smaller;
   background-color: #eee;
   background-image: -moz-linear-gradient(top, #eee, #ccc);
   background-image: -o-linear-gradient(top, #eee, #ccc);
   background-image: -webkit-linear-gradient(top, #eee, #ccc);
   background-image: linear-gradient(top, #eee, #ccc);
   border: 1px solid #707070;
   border-radius: 3px;
   box-shadow: 0 0 1px 1px rgba(255,255,255,.8) inset, 0 1px 0 rgba(0,0,0,.3);
}

.submit:hover {
   background-image: -moz-linear-gradient(top, #fafafa, #ddd);
   background-image: -o-linear-gradient(top, #fafafa, #ddd);
   background-image: -webkit-linear-gradient(top, #fafafa, #ddd);
   background-image: linear-gradient(top, #fafafa, #ddd);
}

.submit[disabled='disabled'] {
   background-image: -moz-linear-gradient(top, #eee, #ccc);
   background-image: -o-linear-gradient(top, #eee, #ccc);
   background-image: -webkit-linear-gradient(top, #eee, #ccc);
   background-image: linear-gradient(top, #eee, #ccc);
}

.edit {
   background-color: #66ff66;
   background-image: -moz-linear-gradient(top, #8f8, #6f6);
   background-image: -o-linear-gradient(top, #8f8, #6f6);
   background-image: -webkit-linear-gradient(top, #8f8, #6f6);
   background-image: linear-gradient(top, #8f8, #6f6);
}

.edit:hover {
   background-color: #88ff88;
   background-image: -moz-linear-gradient(top, #cfc, #afa);
   background-image: -o-linear-gradient(top, #cfc, #afa);
   background-image: -webkit-linear-gradient(top, #cfc, #afa);
   background-image: linear-gradient(top, #cfc, #afa);
}

/* Errors */
.error {
   color: red;
   background-color: yellow;
}

/* Fonts */
.tiny {
   border: 0;
   padding: 0;
   font-size: small;
}

.note, .ask {
   font-weight: bold;
}

/* Alerts */
.alert {
   display: inline;
   padding: 1ex;
   margin: 1ex 0 1ex 5em;
   color: black;
   background-color: yellow;
   border: 1px solid #888;
   border-radius: 6px;
}

.alert input {
   margin-top: 1ex;
}

/* Dialogs */
.dialog {
   padding: 1ex;
   margin: 1ex 5em 1ex 1em;
   border: 1px solid #888;
   border-radius: 6px;
}

/* Hints */
.hint {
   font-size: small;
   background-color: #777;
}

.hints {
   font-size: small;
   color: black;
   padding-left: 3px;
   padding-top: 3px;
   border: 1px solid;
   background-color: white;
}

/* Buttons */
.button {
   width: 80%;
   background-color: lightgrey;
   border: 1px solid black;
   border-radius: 3ex;
   text-align: center;
   display: table;
   padding: 2ex;
   margin: auto;
}

.button2 {
   display: table-cell;
   vertical-align: middle;
   font-weight: bold;
   font-size: larger;
}
pil21/lib/clang.l0000644000000000000000000000061714051172317010707 0ustar  # 19may21 Software Lab. Alexander Burger

(de clang (Nm L . Lst)
   (out (tmp Nm ".c") (here "/**/"))
   (apply call L "clang" "-o" (tmp Nm)
      "-fPIC" "-O" "-w" "-shared" (tmp Nm ".c"))
   (for L Lst
      (def (car L)
         (list
            (cadr L)
            (cons 'native (tmp Nm) (name (caddr L)) (cdddr L)) ) )
      (when (== '@ (fin (cadr L)))
         (push (cdaar L) 'pass) ) ) )
pil21/lib/simul.l0000644000000000000000000003154714744147446011000 0ustar  # 22jan25 Software Lab. Alexander Burger

(symbols 'simul 'pico)

(local) (subsets shuffle samples)
(import pico~permute)

(private) (Lst Fun L)

(de permute (Lst Fun)
   (let L Lst
      (recur (L)
         (if (cdr L)
            (do (length L)
               (recurse (cdr L))
               (rot L) )
            (Fun Lst) ) ) ) )

(de subsets (N Lst)
   (cond
      ((=0 N) '(NIL))
      ((not Lst))
      (T
         (conc
            (mapcar
               '((X) (cons (car Lst) X))
               (subsets (dec N) (cdr Lst)) )
            (subsets N (cdr Lst)) ) ) ) )

(de shuffle (Lst)
   (by '(NIL (rand)) sort Lst) )

(de samples (Cnt Lst)
   (make
      (for (N (length Lst) (n0 Cnt) (++ Lst) (dec N))
         (when (>= Cnt (rand 1 N))
            (link (car Lst))
            (dec 'Cnt) ) ) ) )

# Flooding Algorithm
(local) flood
(private) (Lst Fun Init X)

(de flood (Lst Fun Init)
   (let G (mapcar '((X) (cons X (Fun X))) Lst)
      (for L G
         (for X (cdr L)
            (let A (asoq X G)
               (unless (memq (car L) (cdr A))
                  (con A (cons (car L) (cdr A))) ) ) ) )
      (make
         (recur (Init)
            (for X Init
               (unless (memq X (made))
                  (link X)
                  (recurse (cdr (asoq X G))) ) ) ) ) ) )

(def 'flood 'doc "@doc/refF.html")

# Genetic Algorithm
(local) gen
(private) (Pop Cond Re Mu Se P)

(de gen (Pop Cond Re Mu Se)
   (until (Cond Pop)
      (for (P Pop P (cdr P))
         (set P
            (maxi Se  # Selection
               (make
                  (for (P Pop P)
                     (rot P (rand 1 (length P)))
                     (link  # Recombination + Mutation
                        (Mu (Re (++ P) (++ P))) ) ) ) ) ) ) )
   (maxi Se Pop) )

# Alpha-Beta tree search
(local) game
(private) (*Val Flg Cnt Moves Move Cost Alpha Beta Mov)

(de game (Flg Cnt Moves Move Cost)
   (let (Alpha '(1000000)  Beta -1000000)
      (recur (Flg Cnt Alpha Beta)
         (let? Lst (Moves Flg)
            (if (=0 (dec 'Cnt))
               (loop
                  (Move (caar Lst))
                  (setq *Val (list (Cost Flg) (car Lst)))
                  (Move (cdar Lst))
                  (T (>= Beta (car *Val))
                     (cons Beta (car Lst) (cdr Alpha)) )
                  (when (> (car Alpha) (car *Val))
                     (setq Alpha *Val) )
                  (NIL (shift 'Lst) Alpha) )
               (setq Lst
                  (sort
                     (mapcar
                        '((Mov)
                           (prog2
                              (Move (car Mov))
                              (cons (Cost Flg) Mov)
                              (Move (cdr Mov)) ) )
                        Lst ) ) )
               (loop
                  (Move (cadar Lst))
                  (setq *Val
                     (if (recurse (not Flg) Cnt (cons (- Beta)) (- (car Alpha)))
                        (cons (- (car @)) (cdar Lst) (cdr @))
                        (list (caar Lst) (cdar Lst)) ) )
                  (Move (cddar Lst))
                  (T (>= Beta (car *Val))
                     (cons Beta (cdar Lst) (cdr Alpha)) )
                  (when (> (car Alpha) (car *Val))
                     (setq Alpha *Val) )
                  (NIL (shift 'Lst) Alpha) ) ) ) ) ) )

### Discrete-Event Simulation ###
(local) (*Rt *Keys *Time *Ready *Next des pause event wake)
(private) (Prg X Time Dly n e s)

(zero *Time)  # Current simulation time

(de des Prg
   (while (fifo '*Ready)
      (yield (cdr @) (car @)) )
   (when (idx '*Next NIL)
      (let (X (car @)  (Time . This) X)
         (when *Rt
            (off *Keys)
            (for
               (Dly (*/ (- Time *Time) *Rt)
                  (key (max 1 Dly) 'Dly) )
               (fifo '*Keys @)
               (run Prg) ) )
         (setq *Time Time)
         (loop
            (idx '*Next X (=: n NIL))
            (for S (: e)
               (rid (prop S 's) This) )
            (=: e NIL)
            (yield 0 This)
            (NIL (setq X (lup *Next Time)))
            (setq This (cdr X)) ) ) ) )

# Wait for time and/or events
(de pause @
   (with (co)
      (ifn (args)
         (fifo '*Ready (cons This))
         (let Time T
            (while
               (let E (next)
                  (if (num? E)
                     (setq Time (min E Time))
                     (fifo (prop (push (:: e) E) 's) This) )
                  (args)) )
            (when (num? Time)
               (idx '*Next
                  (=: n (cons (+ Time *Time) This))
                  0 ) ) ) )
      (run (yield)) ) )

# Send event
(de event (This . Prg)
   (while (fifo (:: s))
      (with @
         (when (: n)
            (idx '*Next @ (=: n NIL)) )
         (for S (: e)
            (rid (prop S 's) This) )
         (=: e NIL)
         (fifo '*Ready (cons This Prg)) ) ) )

# Wake up
(de wake (This . Prg)
   (when (: n)
      (idx '*Next @ (=: n NIL)) )
   (for S (: e)
      (rid (prop S 's) This) )
   (=: e NIL)
   (if (asoq This *Ready)
      (con @ Prg)
      (fifo '*Ready (cons This Prg)) ) )

### Grids ###
(local) (grid west east south north)

(de grid (DX DY FX FY)
   (let Grid
      (make
         (for X DX
            (link
               (make
                  (for Y DY
                     (set
                        (link
                           (if (> DX 26)
                              (box)
                              (intern (pack (char (+ X 96)) Y) T) ) )
                        (cons (cons) (cons)) ) ) ) ) ) )
      (let West (and FX (last Grid))
         (for (Lst Grid  Lst)
            (let
               (Col (++ Lst)
                  East (or (car Lst) (and FX (car Grid)))
                  South (and FY (last Col)) )
               (for (L Col  L)
                  (with (++ L)
                     (set (: 0 1) (++ West))  # west
                     (con (: 0 1) (++ East))  # east
                     (set (: 0 -1) South)     # south
                     (con (: 0 -1)            # north
                        (or (car L) (and FY (car Col))) )
                     (setq South This) ) )
               (setq West Col) ) ) )
      Grid ) )

(de west (This)
   (: 0 1 1) )

(de east (This)
   (: 0 1 -1) )

(de south (This)
   (: 0 -1 1) )

(de north (This)
   (: 0 -1 -1) )

(local) (disp border)
(private) (Grid How Fun X Y DX DY N Sp)

(de disp (Grid How Fun X Y DX DY)
   (setq Grid
      (if X
         (mapcar
            '((L) (flip (head DY (nth L Y))))
            (head DX (nth Grid X)) )
         (mapcar reverse Grid) ) )
   (let (N (+ (length (cdar Grid)) (or Y 1))  Sp (length N))
      (border north)
      (while (caar Grid)
         (prin " " (align Sp N) " "
            (and How (if (and (nT How) (west (caar Grid))) " " '|)) )
         (for L Grid
            (prin
               (Fun (car L))
               (and How (if (and (nT How) (east (car L))) " " '|)) ) )
         (prinl)
         (border south)
         (map pop Grid)
         (dec 'N) )
      (unless (> (default X 1) 26)
         (space (inc Sp))
         (for @ Grid
            (prin " " (and How "  ") (char (+ 96 X)))
            (T (> (inc 'X) 26)) )
         (prinl) ) ) )

(de border (Dir)
   (when How
      (space Sp)
      (prin "  +")
      (for L Grid
         (prin (if (and (nT How) (Dir (car L))) "   +" "---+")) )
      (prinl) ) )

### Track network ###
(local) (connectors crossing linkFromTo linkFrom linkTo tracks)
(private) Var

(de connectors ()
   (=: a (list This NIL NIL))  # Connector A
   (=: b (list This NIL NIL))  # Connector B
   (con (cddr (: a)) (: b))
   (con (cddr (: b)) (: a)) )

(de crossing (Sym)
   (with (=: c (box))
      (connectors)
      (linkFromTo Sym) )  )

(de linkFromTo (Sym)
   (if2 (; Sym a 2) (: b 2)
      (set
         (; Sym b -1) (: b)
         (: a -1) (; Sym a) )
      (set
         (; Sym b -1) (: a)
         (: b -1) (; Sym a) )
      (set
         (; Sym a -1) (: b)
         (: a -1) (; Sym b) )
      (set
         (; Sym a -1) (: a)
         (: b -1) (; Sym b) ) ) )

(de linkFrom (Sym Ref)
   (let Con
      (if (; Sym a 2)
         (; Sym a)
         (; Sym b) )
      (if (== Ref (: b 2 1))
         (set
            (cddddr Con) (: a)
            (: b -2) Con )
         (set
            (cddddr Con) (: b)
            (: a -2) Con ) ) ) )

(de linkTo (Sym Ref)
   (let Con (if (: a 2) (: a) (: b))
      (if (== Ref (; Sym b 2 1))
         (set
            (cddddr Con) (; Sym a)
            (; Sym b -2) Con )
         (set
            (cddddr Con) (; Sym b)
            (; Sym a -2) Con ) ) ) )

# Define tracks
(de tracks (Var)
   (def Var  # Layout
      (clip
         (make
            (until (or (eof) (sub? (peek) "#("))
               (link (line)) ) ) ) )
   (for (Y . L) (val Var)  # Init
      (for (X . This) L
         (=: x X)
         (=: y Y)
         (unless (sp? This)
            (connectors) ) ) )
   (for 1st (1 NIL)
      (map
         '(((PU P))
            (map
               '(((Left This Right) (UpL Up UpR))
                  (case This
                     ("|"
                        (cond
                           ((= "|" Up)
                              #  |    \|     |/
                              #  |     |     |
                              (if 1st
                                 (linkFromTo Up)
                                 (when (= "\\" UpL)
                                    # \|
                                    #  |
                                    (linkFrom UpL Up) )
                                 (when (= "/" UpR)
                                    #  |/
                                    #  |
                                    (linkFrom UpR Up) ) ) )
                           ((= "\\" UpL)
                              # \
                              #  |
                              (and 1st (linkFromTo UpL)) )
                           ((= "/" UpR)
                              #   /
                              #  |
                              (and 1st (linkFromTo UpR)) ) )
                        (when 1st
                           # -|
                           (and (= "-" Left) (crossing Left))
                           #  -
                           #  |
                           (and (= "-" Up) (; Up c) (linkFromTo @)) ) )
                     ("/"
                        (cond
                           ((member UpR '("|" "/"))
                              #   |     |     /
                              #  /     /|    /
                              (if2 1st (= "|" Right)
                                 NIL
                                 (linkFromTo UpR)
                                 (linkTo UpR Right) ) )
                           ((= "-" UpR)
                              #   -    --
                              #  /     /
                              (if2 1st (= "-" Up)
                                 NIL
                                 (linkFromTo UpR)
                                 (linkTo UpR Up) ) ) ) )
                     ("-"
                        (cond
                           ((= "-" Left)
                              #       \       /     /
                              # --    --    --    ---
                              (if 1st
                                 (linkFromTo Left)
                                 (when (= "\\" UpL)
                                    # \
                                    # --
                                    (linkFrom UpL Left) ) )
                              (when (= "/" UpR)
                                 #   /      /
                                 # --     ---
                                 (if2 1st (= "-" Right)
                                    NIL
                                    (linkFromTo UpR)
                                    (linkFrom UpR Right) ) ) )
                           ((= "\\" UpL)
                              # \
                              #  -
                              (and 1st (linkFromTo UpL)) ) )
                        (when 1st
                           #  |
                           #  -
                           (and (= "|" Up) (crossing Up))
                           #  |-
                           (and (= "|" Left) (; Left c) (linkFromTo @)) ) )
                     ("\\"
                        (cond
                           ((member UpL '("|" "\\"))
                              # |     |     \
                              #  \    |\     \
                              (if2 1st (= "|" Left)
                                 NIL
                                 (linkFromTo UpL)
                                 (linkTo UpL Left) ) )
                           ((= "-" UpL)
                              # -     --
                              #  \     \
                              (if2 1st (= "-" Up)
                                 NIL
                                 (linkFromTo UpL)
                                 (linkTo UpL Up) ) ) ) ) ) )
               (cons NIL P)
               (cons NIL PU) ) )
         (cons NIL (val Var)) ) ) )
pil21/lib/frac.l0000644000000000000000000000324213662020231010525 0ustar  # 22may20 Software Lab. Alexander Burger

(symbols 'frac 'pico)

(local) (gcd lcm f)

(de gcd (A B)
   (until (=0 B)
      (let M (% A B)
         (setq A B B M) ) )
   (abs A) )

(de lcm (A B)
   (*/ A B (gcd A B)) )

(de f (N D)
   (and (=0 D) (quit "frac/0" N))
   (if (=0 N)
      (cons 0 1)
      (let G (gcd N D)
         (if (gt0 N)
            (cons (/ N G) (/ D G))
            (cons (- (/ N G)) (- (/ D G))) ) ) ) )

(local) (fabs 1/f f+ f- f* f/ f** fcmp)

(de fabs (A)
   (cons (abs (car A)) (cdr A)) )

(de 1/f (A)
   (and (=0 (car A)) (quit "frac/0" A))
   (if (gt0 (car A))
      (cons (cdr A) (car A))
      (cons (- (cdr A)) (- (car A))) ) )

(de f+ (A B)
   (let D (lcm (cdr A) (cdr B))
      (let N
         (+
            (* (/ D (cdr A)) (car A))
            (* (/ D (cdr B)) (car B)) )
         (if (=0 N)
            (cons 0 1)
            (let G (gcd N D)
               (cons (/ N G) (/ D G)) ) ) ) ) )

(de f- (A B)
   (if B
      (f+ A (f- B))
      (cons (- (car A)) (cdr A)) ) )

(de f* (A B)
   (let (G (gcd (car A) (cdr B))  H (gcd (car B) (cdr A)))
      (cons
         (* (/ (car A) G) (/ (car B) H))
         (* (/ (cdr A) H) (/ (cdr B) G)) ) ) )

(de f/ (A B)
   (f* A (1/f B)) )

(de f** (A N)
   (if (ge0 N)
      (cons (** (car A) N) (** (cdr A) N))
      (cons (** (cdr A) (- N)) (** (car A) (- N))) ) )

(de fcmp (A B)
   (if (gt0 (* (car A) (car B)))
      (let Q (f/ A B)
         (*
            (if (gt0 (car A)) 1 -1)
            (- (car Q) (cdr Q))) )
      (- (car A) (car B)) ) )

(local) (f< f<= f> f>=)

(de f< (A B)
   (lt0 (fcmp A B)) )

(de f<= (A B)
   (ge0 (fcmp B A)) )

(de f> (A B)
   (gt0 (fcmp A B)) )

(de f>= (A B)
   (ge0 (fcmp A B)) )
pil21/vip0000755000000000000000000000010013730611270007406 0ustar  #!/bin/sh
exec ${0%/*}/bin/picolisp ${0%/*}/lib.l @bin/vip "$@"
pil21/bin/vip0000755000000000000000000000161014757536072010205 0ustar  #!/usr/bin/picolisp /usr/lib/picolisp/lib.l
# 26feb25abu

(unless *Dbg
   (load "@lib/vip.l") )

(stack 1024)

(bye
   (if
      (vip~vi  ## [+ | +[]]   [+[]]  ..
         (make
            (while (opt)
               (let (S @  L (chop S))
                  (cond
                     ((pre? "+" S)
                        (link
                           (ifn (get (any (cdr L)) '*Dbg 1)
                              (cons
                                 (cond
                                    ((= "+" S) T)
                                    ((format S) @)
                                    (T (cdr L)) )
                                 (opt) )
                              (symbols (cddr @))
                              (cons (car @) (cadr @)) ) ) )
                     ((pre? "-" S) (load S))
                     (T (link S)) ) ) ) ) )
      0
      1 ) )
pil21/lib/vip.l0000644000000000000000000020251614756056705010441 0ustar  # 21feb25 Software Lab. Alexander Burger

(symbols 'vip 'pico)

(sysdefs "unistd")

(load "@lib/term.l")

(local) (*Ns *Shell *CmdWin *StatNm *Chr *Complete *Repeat *Change *Count *Cnt
*Search *Clip *TagStack *Spell *CmdMap *Keys *KeyMap *KeyMap-g *KeyMap-q *F7 *F8
*F9 *F10 *F11 *F12 *@ *@@)

(def '*Shell (or (sys "SHELL") "sh"))

### VIP Editor ###
(local) (*Buffers +Buffer mkLoc fName prName rplFile fileBuffer rdLines delim
delimNs markup min1 undo redo evCmd dirty> load> save> syms> view> status delwin
cursor addLine chgLine unmark redraw repaint scLeft scRight goto chgwin eqwin
getch getch2 reload scratch syms pushTag tag done change jmp@@ cnt@@ goCol
goLeft goRight goUp goDown goAbs goFind word lword tword end lend getWord
_forward goForward _backward goBackward goPFore goPBack shift shiftY indent cutX
cutN paste join tglCase insChar incNum overwrite _bs insMode cmdMode cmdPipe
evRpt move chgRight jmpMark wordFun moveSearch patMatch parMatch spell pipeN
nextBuf shell shFile prCmd cmd _map map+ map+g map+q reset posChar getText
s-expr command vipA vipZ vi)


(class +Buffer)
# text file cmd symbols key undo redo dirt
# posX posY lastX lastY subd flat fmt syms 

(dm T (File Y)
   (and (=: file File) (queue '*Buffers This))
   (=: symbols (symbols))
   (=: posX 1)
   (=: posY (or Y 1))
   (=: lastX (=: lastY 1))
   (=: fmt 72) )

(de mkLoc (File)
   (let P (conc (chop (pwd)) '("/"))
      (when (head P File)
         (setq File (cdr (nth File (length P)))) ) )
   (if (pat? (car File))
      (cons (name ".") (name "/") File)
      File ) )

(de fName (File)
   (let? F (chop (setq File (path File)))
      (use R
         (pack
            (mkLoc
               (if (info File)
                  (if (=0 (%@ "realpath" 'N File '(R (`PATH_MAX C . `PATH_MAX))))
                     F R )
                  (let L (rot (split F "/"))
                     (if
                        (and
                           (cdr L)
                           (n0 (%@ "realpath" 'N (glue "/" @) '(R (`PATH_MAX C . `PATH_MAX)))) )
                        (conc R (list "/") (car L))
                        F ) ) ) ) ) ) ) )

(de prName (File)
   (if (pre? (sys "HOME") File)
      (pack "~/" (cddr (nth (chop File) (length (sys "HOME")))))
      File ) )

(de rplFile (File)
   (pack
      (replace (chop File) "%"
         (if (== This *CmdWin)
            (: next buffer file)
            (: buffer file) ) ) ) )

(de fileBuffer (File Y)
   (let F (fName File)
      (prog1
         (or
            (find '((This) (= F (: file))) *Buffers)
            (new '(+Buffer) F Y) )
         (put @ 'subd (<> "/" (last (chop File)))) ) ) )

(de rdLines ()
   (make (until (eof) (link (line)))) )

(de delim (C)
   (member C
      '`(cons NIL (chop " \t\n\r\"'(),[]`")) ) )

(de delimNs (C)
   (or (delim C) (= "~" C)) )

(de markup (Lst)
   (let (S 'text  N 1)
      (for L Lst
         (let P NIL
            (while L
               (let? C (++ L)
                  (state 'S
                     (text (and (= "\"" C) 'string)
                        (set C 0) )
                     (text
                        (and
                           (= "#" C)
                           (delim P)
                           (if L 'comment 'text) )
                        (set C N)
                        (when (= "{" (car L))
                           (set (++ L) (inc 'N)) ) )
                     (text 'text
                        (or
                           (set (setq P C)
                              (and (sp? C) (not L)) )
                           (when (= "\\" C)
                              (let? C (++ L)
                                 (set C (and (sp? C) (not L))) ) ) ) )
                     (string (and (= "\"" C) 'text)
                        (set (setq P C) 0) )
                     (string (and (= "\\" C) (not L) 'skip)
                        (set C T) )
                     (string 'string
                        (set C T)
                        (and (= "\\" C) L (++ L) (set @ T)) )
                     (skip (and (sp? C) 'skip)
                        (set C) )
                     (skip (and (= "\"" C) 'text)
                        (set (setq P C) 0) )
                     (skip 'string
                        (set C T) )
                     (comment
                        (cond
                           ((=1 (set (setq P C) N))
                              (if L
                                 'comment
                                 (and (sp? C) (not L) (set P T))
                                 'text ) )
                           ((and
                                 (= "}" C)
                                 (= "#" (car L))
                                 (=1 (set (++ L) (dec 'N))) )
                              'text )
                           (T
                              (and
                                 (= "#" C)
                                 (= "{" (car L))
                                 (set (++ L) (inc 'N)) )
                              'comment ) ) ) ) ) ) ) ) ) )

(de min1 (A B)
   (max 1 (min A B)) )

(dm dirty> (Win)
   (<> (: undo) (: dirt)) )

(dm load> (Win)
   (markup
      (=: text
         (let? File (: file)
            (let? I (info File)
               (if (=T (car I))
                  (mapcar
                     '((X)
                        (let (S (cdddr X)  F (caddr X))
                           (conc
                              (mkLoc F)
                              (cond
                                 ((=T S) (chop "/  "))
                                 ((not S)
                                    (conc
                                       (chop " -> ")
                                       (in (list "readlink" F) (line))
                                       (chop "  ") ) )
                                 (T
                                    (conc
                                       (chop " (")
                                       (chop (/ (+ S 1023) 1024))
                                       (chop ")  ") ) ) )
                              (chop (dat$ (- (car X)) "-"))
                              (chop " ")
                              (chop (tim$ (- (cadr X)) T)) ) ) )
                     (sort
                        (make
                           (unless (= "/" (last (setq File (chop File))))
                              (conc File (chop "/")) )
                           (recur (File)
                              (for F (dir File T)
                                 (unless (member F '("." ".."))
                                    (let? I (info (setq F (append File (chop F))) 0)
                                       (if (and (=T (car I)) (: subd))
                                          (recurse (conc F (chop "/")))
                                          (link
                                             (cons
                                                (- (cadr I))
                                                (- (cddr I))
                                                F
                                                (car I) ) ) ) ) ) ) ) ) ) )
                  (gc (+ 4 (*/ (car I) 32768)))  # 2 cells / char
                  (if (sys "CCRYPT" (: key))
                     (in (list "ccrypt" "-c" "-ECCRYPT" File)
                        (rdLines) )
                     (in File (rdLines)) ) ) ) ) ) )
   (=: symbols (symbols))
   (=: undo (=: redo (=: dirt)))
   (=: posX
      (min1
         (: posX)
         (length
            (get
               (: text)
               (=: posY (min1 (: posY) (length (: text)))) ) ) ) )
   (let? L
      (nth
         (find
            '((L) (head '`(chop "# VIP ") L))
            (head 3 (: text)) )
         7 )
      (evCmd
         (symbols '(vip pico)
            (if (= "(" (car L))
               (run (str (pack L)))
               (setq L (split L " "))
               (apply script
                  (str (glue " " (cdr L)))
                  (path (car L)) ) ) ) ) ) )

(dm save> (Win)
   (when (: file)
      (unless (=T (car (info @)))
         (if (sys "CCRYPT" (: key))
            (pipe
               (out '("ccrypt" "-e" "-ECCRYPT")
                  (mapc prinl (: text)) )
               (out (: file) (echo)) )
            (out (: file) (mapc prinl (: text))) ) )
      (=: dirt (: undo))
      (for (This *CmdWin (setq This (: next)))
         (status) )
      (when (: syms)
         (and (find ext? @ T) (pico~dbSync))
         (in (: file)
            (while (and (setq "*X" (read)) (atom @))
               (unless (= (val "*X") (setq "*V" (read)))
                  (set "*X" "*V") )
               (until (= '(=======) (setq "*K" (read)))
                  (unless (= (get "*X" "*K") (setq "*V" (read)))
                     (put "*X" "*K" "*V") ) ) ) )
         (when (find ext? (: syms) T)
            (commit 'pico~upd)
            (syms> This (: syms)) ) ) )
   (on *StatNm) )

(dm syms> ("Lst")
   (out (: file)
      (for "S" (=: syms "Lst")
         (if
            (and
               (ext? "S" T)
               (not (rank (car (id "S" T)) *Ext))
               (lock "S") )
            (prinl "# " "S" " locked")
            (printsp "S")
            (fish
               '(("X")
                  (if (circ? "X")
                     "skip"
                     (and
                        (str? "X")
                        (or
                           (and (val "X") (n== @ "X"))
                           (getl "X") )
                        (intern "X" 'priv) )
                     NIL ) )
               (cons (val "S") (getl "S"))
               "skip" )
            (pretty (val "S"))
            (prinl)
            (for "X" (sort (getl "S"))
               (space 3)
               (if (atom "X")
                  (print "X" T)
                  (printsp (cdr "X"))
                  (pretty (setq "X" (car "X")) -3) )
               (remark "X")
               (prinl) ) )
         (prinl)
         (println '(=======))
         (prinl) ) ) )

(dm view> (Win)
   (beep) )


(local) (*Window +Window)

(class +Window)
# buffer top lines winX winY posX posY prev next last mark sc

(dm T (Buffer Top Lines WinX WinY PosX PosY Prev Mark)
   (=: buffer Buffer)
   (=: top Top)
   (=: lines Lines)
   (when (=: prev Prev)
      (when (=: next (: prev next))
         (=: next prev This) )
      (=: prev next This) )
   (=: winX WinX)
   (=: winY WinY)
   (=: posX PosX)
   (=: posY PosY)
   (=: mark Mark)
   (=: sc 0) )

(dm view> ()
   (view> (: buffer) This) )

(de delwin ()
   (when (=: prev next (: next))
      (=: next prev (: prev)) ) )

(de cursor ()
   (cup
      (+ (: top) (- (: posY) (: winY) -1))
      (- (: posX) (: winX) -1) ) )

(de addLine (Y L N)
   (cup (+ (: top) Y) 1)
   (clreol)
   (for C (nth L (: winX))
      (T (lt0 (dec 'N)))
      (cond
         ((: buffer flat))
         ((=T (val C))
            (cond
               ((= "^?" C)
                  (setq C "?")
                  (attr RED T) )
               ((>= "^_" C "^A")
                  (setq C (char (+ 64 (char C))))
                  (attr RED T) )
               (T (attr NIL T)) ) )
         ((= "^?" C)
            (setq C "?")
            (attr RED) )
         ((>= "^_" C "^A")
            (setq C (char (+ 64 (char C))))
            (attr RED) )
         ((gt0 (val C))
            (attr CYAN) )
         (T (attr)) )
      (prin C) )
   (attr) )

(de chgLine (L)
   (addLine (- (: posY) (: winY) -1) L *Columns)
   (cursor) )

(de unmark ()
   (when (: mark)
      (out @ (println (: posX) (: posY)))
      (=: mark) ) )

(de status ()
   (unless (== This *CmdWin)
      (cup (+ (: top) (: lines) 1) 1)
      (let
         (N (length (: buffer text))
            A (pack
               (index (: buffer) *Buffers)
               "/"
               (length *Buffers)
               (if (dirty> (: buffer) This) " * " " ") )
            F (or (: buffer cmd) (prName (: buffer file)))
            Z (pack
               (and (: mark) (cons @ " "))
               (casq (: buffer symbols 1)
                  (pico)
                  (T (cons @ " ")) )
               (: posX) "," (: posY) "/" N " "
               (if (gt0 (dec N))
                  (*/ 100 (dec (: posY)) @)
                  0 )
               "%" ) )
         (attr REVERS)
         (let N (- *Columns (length (prin A)))
            (cond
               ((ge0 (- N (length F) (length Z)))
                  (prin F (need @ " ") Z) )
               ((onOff *StatNm) (prin (tail N (chop F))))
               (T (prin (need (- N (length Z)) " ") Z)) ) )
         (attr)
         (flush) ) ) )

(de redraw ()
   (hideCsr)
   (let L (nth (: buffer text) (: winY))
      (for Y (: lines)
         (addLine Y (++ L) *Columns) ) )
   (showCsr)
   (status) )

(de repaint ()
   (for (This *CmdWin This (: next))
      (redraw) ) )

(de scLeft ()
   (and
      (if (=1 (: winX))
         (> (: posX) 1)
         (>= (- (: posX) (dec (:: winX))) *Columns) )
      (dec (:: posX)) ) )

(de scRight ()
   (cond
      ((> (: posX) (: winX))
         (inc (:: winX)) )
      ((cdr (nth (: buffer text) (: posY) (: posX)))
         (inc (:: posX))
         (inc (:: winX)) )
      (T
         (for (Y . L) (cdr (nth (: buffer text) (: posY)))
            (T (cdr (nth L (: posX)))
               (inc (:: posY) Y) )
            (T (= Y (: lines))) ) ) ) )

(de goto (X Y F)
   (=: buffer posX (=: posX X))
   (setq X
      (cond
         ((and F
               (>= (inc (: posY)) Y (dec (: posY)))
               (>= (+ (: winX) *Columns -1) X (: winX)) )
            (: winX) )
         ((>= (*/ *Columns 3 4) X) 1)
         (T (- X (/ *Columns 2))) ) )
   (=: buffer posY (=: posY Y))
   (setq Y
      (min1
         (- Y (/ (: lines) 2))
         (- (length (: buffer text)) (: lines) -1) ) )
   (if (and F (= X (: winX)) (= Y (: winY)))
      (status)
      (=: winX X)
      (=: winY Y)
      (redraw) ) )

(de chgwin (Lines Top)
   (=: lines Lines)
   (and Top (=: top @))
   (=: winY
      (min1
         (- (: posY) (/ (: lines) 2))
         (- (length (: buffer text)) (: lines) -1) ) )
   (redraw) )

(de eqwin ()
   (let
      (H (dec *Lines)
         D (*/ H
            (let N 0
               (for (This *CmdWin (: next) @)
                  (inc 'N) ) ) ) )
      (with *CmdWin (chgwin 1 H))
      (when (>= D 3)
         (for (This *CmdWin (setq This (: next)))
            (if (: next)
               (chgwin (dec D) (dec 'H D))
               (chgwin (dec H) 0) ) ) )
      (cursor) ) )

(de getch ()
   (symbols *Ns
      (if (= "\e" (setq *Chr (or (++ *Keys) (key))))
         (when (or (++ *Keys) (key 120))
            (loop
               (setq *Chr (pack *Chr @))
               (T (member *Chr '("\e[A" "\e[B" "\e[C" "\e[D")) *Chr)
               (NIL (or (++ *Keys) (key 120)) *Chr) ) )
         *Chr ) ) )

(de getch2 (C)
   (if (= "^V" C)
      (or (++ *Keys) (symbols *Ns (key)))
      C ) )

(de reload (File Y X)
   (unless (== This *CmdWin)
      (when File
         (let B (fileBuffer File)
            (unless (== B (: buffer))
               (unmark)
               (=: last (: buffer))
               (=: buffer B) ) ) )
      (load> (: buffer) This)
      (off *StatNm)
      (goto
         (or X (: buffer posX))
         (or Y (: buffer posY)) )
      (repaint) ) )

(de scratch (File Lst Y)
   (out (setq File (fName File))
      (mapc prinl Lst) )
   (if (find '((This) (= File (: file))) *Buffers)
      (with @
         (markup
            (=: text Lst)
            (=: undo (=: redo (=: dirt))) ) )
      (unmark)
      (=: last (: buffer))
      (put
         (=: buffer (new '(+Buffer) File Y))
         'text
         Lst )
      (markup (: buffer text))
      (goto 1 (: buffer posY)) )
   (repaint) )

(de pushTag (File)
   (push '*TagStack (: posX) (: posY) File (symbols)) )

(de tag (S C)
   (ifn
      (if C
         (or
            (get C '*Dbg -1 S)
            (meta C '*Dbg -1 S) )
         (get S '*Dbg 1) )
      (beep)
      (pushTag (: buffer file))
      (symbols (cddr @))
      (reload (cadr @) (car @) 1) ) )

(de done (Flg)
   (and Flg
      (dirty> (: buffer) This)
      (save> (: buffer) This) )
   (unmark)
   (nond
      ((; *CmdWin next next)
         (throw 'done Flg) )
      ((n== This *CmdWin))
      ((== This (; *CmdWin next))
         (delwin)
         (let (N (: lines)  Top (: top))
            (with (setq *Window (: prev))
               (chgwin (+ 1 N (: lines)) Top) ) ) )
      (NIL
         (delwin)
         (let N (: lines)
            (with (setq *Window (: next))
               (chgwin (+ 1 N (: lines))) ) ) ) ) )

(de change Prg
   (let
      (Pos (nth (: buffer text) (: posY))
         Env
         (env
            'PosX1 (: posX)  'PosY1 (: posY)
            'OldA (car Pos)  'OldD (cdr Pos)
            'NewD (: buffer text)
            '(Pos PosX2 PosY2 NewA) ) )
      (let? Res
         (job Env
            (prog1
               (run Prg)
               (setq
                  PosX2 (: posX)  PosY2 (: posY)
                  NewA (if Pos (car @) (: buffer text)) )
               (and Pos (setq NewD (cdr @))) ) )
         (=: buffer redo NIL)
         (push (:: buffer undo)
            (cons Env
               '(ifn Pos
                  (=: buffer text NewD)
                  (set Pos OldA)
                  (con Pos OldD) )
               '(ifn Pos
                  (=: buffer text NewA)
                  (set Pos NewA)
                  (con Pos NewD) ) ) )
         (markup (: buffer text))
         (goto (: posX) (: posY))
         (repaint)
         Res ) ) )

(de undo ()
   (ifn (pop (:: buffer undo))
      (beep)
      (let U @
         (push (:: buffer redo) U)
         (bind (car U)
            (eval (cadr U))
            (markup (: buffer text))
            (goto PosX1 PosY1)
            (repaint) ) ) ) )

(de redo ()
   (ifn (pop (:: buffer redo))
      (beep)
      (let R @
         (push (:: buffer undo) R)
         (bind (car R)
            (eval (cddr R))
            (markup (: buffer text))
            (goto PosX2 PosY2)
            (repaint) ) ) ) )

(de jmp@@ (Y)
   (=: buffer lastX (: posX))
   (=: buffer lastY (: posY))
   (setq *@@ Y) )

(de cnt@@ ()
   (- *@@ (: posY) -1) )

(de goCol (N)
   (setq *@@ (: posY))
   N )

(de goLeft (N)
   (goCol (max 1 (- (: posX) N))) )

(de goRight (N I)
   (goCol
      (min1
         (or (=T N) (+ (: posX) N))
         (+
            (or I 0)
            (length (get (: buffer text) (: posY))) ) ) ) )

(de goUp (N)
   (setq *@@ (max 1 (- (: posY) N)))
   (min1 (: posX) (length (get (: buffer text) *@@))) )

(de goDown (N I)
   (setq *@@
      (min1
         (or (=T N) (+ (: posY) N))
         (+ (or I 0) (length (: buffer text))) ) )
   (min1 (: posX) (length (get (: buffer text) *@@))) )

(de goAbs (X Y I)
   (jmp@@
      (min1 Y
         (+ (or I 0) (length (: buffer text))) ) )
   (min1 X (length (get (: buffer text) *@@))) )

(de goFind (C D N I)
   (setq *@@ (: posY))
   (let (Lst (get (: buffer text) (: posY))  L (nth Lst (: posX)))
      (do N (setq L (member C (cdr L))))
      (if L
         (+ D (or I 0) (offset L Lst))
         (beep) ) ) )

(de word (L C)
   (and
      (delim C)
      (or
         (sub? (car L) "\"()[]")
         (not (delim (car L))) ) ) )

(de lword (L C)
   (and (sp? C) (not (sp? (car L))) ) )

(de tword (L)
   (and
      (sp? (car L))
      (not (sp? (cadr L))) ) )

(de end (L)
   (and (not (delim (car L))) (delim (cadr L))) )

(de lend (L)
   (and (not (sp? (car L))) (sp? (cadr L))) )

(de getWord (Flg)
   (make
      (let Lst (get (: buffer text) (: posY))
         (unless Flg
            (for C (nth Lst (: posX))
               (T (delim C))
               (link C) ) )
         (for
            (L (nth Lst (dec (: posX)))
               (not (delim (car L)))
               (prior L Lst) )
            (yoke (car L)) ) ) ) )

(de _forward (Lst C)
   (for ((X . L) Lst  L  (cdr L))
      (T (and (Fun L C) (=0 (dec 'N)))
         (jmp@@ Y)
         (+ (or I 0) X) )
      (setq C (car L))
      NIL ) )

(de goForward (Fun N I)
   (let (Y (: posY)  Pos (nth (: buffer text) Y)  L (nth (++ Pos) (: posX)))
      (if (_forward (cdr L) (car L))
         (+ (: posX) @)
         (loop
            (NIL Pos (beep))
            (inc 'Y)
            (T (_forward (++ Pos)) @) ) ) ) )

(de _backward (Lst L)
   (use P
      (loop
         (NIL L)
         (setq P (prior L Lst))
         (T (and (Fun L (car P)) (=0 (dec 'N)))
            (jmp@@ Y)
            (offset L Lst) )
         (setq L P)
         NIL ) ) )

(de goBackward (Fun N)
   (let (Y (: posY)  Pos (nth (: buffer text) Y))
      (or
         (_backward
            (car Pos)
            (nth (car Pos) (dec (: posX))) )
         (loop
            (NIL (setq Pos (prior Pos (: buffer text)))
               (beep) )
            (dec 'Y)
            (T (_backward (car Pos) (tail 1 (car Pos))) @ ) ) ) ) )

(de goPFore (Cnt D I)
   (let (Y (: posY)  Pos (nth (: buffer text) Y))
      (loop
         (NIL (cdr Pos)
            (jmp@@ Y)
            (max 1 (+ (or I 0) (length (car Pos)))) )
         (inc 'Y)
         (T
            (and
               (car Pos)
               (not (cadr Pos))
               (=0 (dec 'Cnt)) )
            (jmp@@ (+ Y D))
            1 )
         (++ Pos) ) ) )

(de goPBack (Cnt)
   (let (Y (: posY)  Pos (nth (: buffer text) Y))
      (loop
         (NIL (setq Pos (prior Pos (: buffer text))))
         (dec 'Y)
         (T
            (and
               (not (car Pos))
               (cadr Pos)
               (=0 (dec 'Cnt)) ) ) )
      (jmp@@ Y)
      1 ) )

(de shift (N Flg)
   (change
      (let? P Pos
         (do N
            (when (car P)
               (if Flg
                  (do 3 (push P (name " ")))
                  (do 3
                     (NIL (sp? (caar P)))
                     (pop P) ) ) )
            (NIL (cdr P))
            (setq P (con P (cons (car @) (cdr @)))) )
         (=: posX 1) ) ) )

(de shiftY (X Flg)
   (shift (cnt@@) Flg) )

(de indent ()
   (change
      (let? P Pos
         (when (clip (car P))
            (let (N (*/ (offset @ (trim (car P))) 3)  Sup N)
               (set P @)
               (loop
                  (do (* N 3) (push P (name " ")))
                  (for C (car P)
                     (unless (val C)
                        (case C
                           ("(" (inc 'N))
                           (")" (dec 'N))
                           ("[" (push 'Sup N) (inc 'N))
                           ("]" (setq N (++ Sup))) ) ) )
                  (while (val (caadr P))
                     (++ P) )
                  (NIL (clip (cadr P)) T)
                  (setq P (con P (cons @ (cddr P)))) ) ) ) ) ) )

(de cutX (X Flg)
   (when X
      (let Y *@@
         (unless (> (list Y X) (list (: posY) (: posX)))
            (xchg 'X (:: posX)  'Y (:: posY)) )
         (change
            (when Pos
               (let (L (car Pos)  DX (: posX))
                  (and
                     (set *Clip
                        (make
                           (if Flg
                              (set Pos (cut (dec DX) 'L))
                              (setq L (nth L DX)) )
                           (while (>= (dec 'Y) (: posY))
                              (link L)
                              (setq L (cadr Pos))
                              (if Flg
                                 (con Pos (cddr Pos))
                                 (++ Pos) )
                              (one DX) )
                           (link (cut (- X DX) 'L))
                           (when Flg
                              (set Pos (conc (car Pos) L))
                              (=: posX (min1 (: posX) (length (car Pos)))) )
                           (setq *@@ (unless L 1)) ) )
                     Flg ) ) ) ) ) ) )

(de cutN (N)
   (change
      (when Pos
         (off *@@)
         (set *Clip
            (cons T
               (if (setq Pos (prior Pos (: buffer text)))
                  (make
                     (setq OldA (car @)  OldD (cdr @))
                     (do N
                        (link (cadr Pos))
                        (NIL (con Pos (cddr Pos))
                           (one *@@)
                           (dec (:: posY)) ) )
                     (=: posX 1) )
                  (cut N (:: buffer text)) ) ) ) ) ) )

(de paste (Lst Flg)
   (change
      (let P (or Pos (=: buffer text (cons)))
         (ifn (=T (car Lst))
            (let L (car P)
               (cond
                  ((=0 Flg) (setq PosX1 (=: posX 1)))
                  ((=1 Flg)
                     (and
                        (get (: buffer text) (: posY) 1)
                        (get (: buffer text) (: posY) (inc (:: posX)))
                        (inc 'PosX1) ) )
                  (Flg
                     (=: posX
                        (max 1
                           (inc (length (get (: buffer text) (: posY)))) ) ) ) )
               (set P
                  (conc (cut (dec (: posX)) 'L) (mapcar name (++ Lst))) )
               (for S Lst
                  (setq P (con P (cons (mapcar name S) (cdr P))))
                  (inc (:: posY)) )
               (=: posX (max 1 (length (car P))))
               (set P (append (car P) L)) )
            (=: posX 1)
            (ifn Flg
               (for L (cdr Lst)
                  (con P (cons (car P) (cdr P)))
                  (set P (mapcar name L))
                  (setq P (cdr P)) )
               (inc (:: posY))
               (for L (cdr Lst)
                  (setq P (con P (cons (mapcar name L) (cdr P)))) ) ) )
         T ) ) )

(de join (Cnt)
   (change
      (do Cnt
         (NIL (cdr Pos))
         (set Pos
            (append
               (car Pos)
               (cons (name " ") (clip (cadr Pos))) ) )
         (con Pos (cddr Pos)) )
      T ) )

(de tglCase (Cnt)
   (change
      (let? C (get Pos 1 (: posX))
         (do Cnt
            (set Pos
               (place (: posX) (car Pos)
                  ((if (upp? C) lowc uppc) C) ) )
            (NIL (setq C (get Pos 1 (inc (: posX)))))
            (inc (:: posX)) )
         T ) ) )

(de insChar (C Cnt)
   (change
      (when (car Pos)
         (do Cnt
            (set Pos (place (: posX) (car Pos) (name C)))
            (NIL (get Pos 1 (inc (:: posX)))) )
         (dec (:: posX)) ) ) )

(de incNum (Cnt)
   (change
      (let (I (: posX)  L (car Pos)  S (get L I))
         (ifn (format S)
            (set Pos
               (place (: posX) L (char (+ Cnt (char S)))) )
            (while
               (and
                  (gt0 (dec 'I))
                  (format (get L @)) )
               (setq S (pack @ S)) )
            (inc (:: posX)
               (-
                  (length
                     (set Pos
                        (conc
                           (head I L)
                           (need
                              (if (= `(char "0") (char S)) (length S) 1)
                              (chop (max 0 (+ Cnt (format S))))
                              (name "0") )
                           (tail (- (: posX)) L) ) ) )
                  (length L) ) ) ) ) ) )

(de overwrite (Lst)
   (change
      (let
         (P (or Pos (=: buffer text (cons)))
            L (conc (cut (dec (: posX)) P) (car Lst)) )
         (set P
            (append L
               (cdr (nth (car P) (length (++ Lst)))) ) )
         (=: posX (max 1 (length L))) ) ) )

(de _bs ()
   (++ Chg)
   (dec (:: posX))
   (unless Rpl
      (set P (remove (: posX) (car P))) ) )

(de insMode (Flg Win Rpl . @)
   (change
      (let (P (or Pos (=: buffer text (cons)))  Chg)
         (cond
            ((=0 Flg)
               (con P (cons (car P) (cdr P)))
               (set P)
               (goto 1 (: posY)) )
            ((=1 Flg))
            (Flg
               (setq P (con P (cons NIL (cdr P))))
               (goto 1 (inc (: posY)))
               (setq Chg (0)) ) )
         (cursor)
         (off *Complete)
         (while
            (case (or (next) (getch))
               (NIL)
               (("\n" "\r")
                  (cond
                     (Rpl (beep) T)
                     ((== This *CmdWin)
                        (nil (command (or Win This) (car P))) )
                     (T
                        (push 'Chg 0)
                        (con P
                           (cons (nth (car P) (: posX)) (cdr P)) )
                        (set P (head (dec (: posX)) (car P)))
                        (setq P (cdr P))
                        (goto 1 (inc (: posY)))
                        (cursor)
                        T ) ) )
               (("\b" "^?")  # [BACKSPACE]
                  (when (and Chg (n0 (car Chg)))
                     (_bs)
                     (chgLine (car P))
                     (off *Complete) )
                  T )
               (T
                  (let (S (list @)  L (get (: buffer text) (: posY)))
                     (cond
                        ((<> @ "\t") (off *Complete))
                        ((and
                              (== This *CmdWin)
                              (member L '(("/") ("?") ("&") (":") (":" " "))) )
                           (setq S
                              (chop
                                 (car
                                    (rot
                                       (setq *Complete
                                          (uniq
                                             (conc
                                                (and (cdr L) (history))
                                                (extract
                                                   '((B)
                                                      (when (head L B)
                                                         (pack ((if (cdr L) cddr cdr) B)) ) )
                                                   (: buffer text) ) ) ) ) ) ) ) ) )
                        ((or Rpl (nor *Complete (setq S (pack (getWord T)))))
                           (setq S
                              (make
                                 (do (- 3 (% (dec (: posX)) 3))
                                    (link (name " ")) ) ) ) )
                        (T
                           (default *Complete
                              (cons S
                                 (if
                                    (or
                                       (n== This *CmdWin)
                                       (<> ":" (car L))
                                       (find sp? L) )
                                    (flip
                                       (all* S
                                          (when (== This *CmdWin)
                                             (pick
                                                '((P F) (and (head P L) F))
                                                '`(mapcar chop '(":ta " ":tag " ":v " ":e " ":E " ":r " ":w "))
                                                '(T T T 0 0 0 0) ) ) ) )
                                    (extract
                                       '((Cmd)
                                          (when (head (cdr L) (setq Cmd (chop Cmd)))
                                             (if (pre? ":" S)
                                                (cons (name ":") Cmd)
                                                Cmd ) ) )
                                       (conc
                                          (mapcar car *CmdMap)
                                          '("cp" "bak" "kab" "ls" "key" "tag" "bx" "bd" "map") ) ) ) ) )
                           (do (length (car *Complete)) (_bs))
                           (setq S (chop (car (rot *Complete)))) ) )
                     (when (= "^V" (car S))
                        (set S (or (next) (getch2 "^V"))) )
                     (for C S
                        (push 'Chg C)
                        (set P
                           ((if (and Rpl (car P)) place insert)
                              (: posX)
                              (car P)
                              C ) )
                        (inc (:: posX)) )
                     (goto (: posX) (: posY) T) )
                  (chgLine (car P))
                  T ) ) )
         (=: posX (max 1 (dec (: posX))))
         (cond
            ((=0 Flg) (push 'Chg 0))
            ((=1 Flg) (and (> PosX1 1) (dec 'PosX1))) )
         (split (reverse Chg) 0) ) ) )

(de cmdMode @
   (let Win (if (== This *CmdWin) (: next) This)
      (with *CmdWin
         (pass insMode (: buffer text) Win NIL) ) ) )

(de cmdPipe (N)
   (apply cmdMode (chop (pack ":" N "!"))) )

(de evRpt (Exe)
   (eval (setq *Repeat Exe) 1) )

(de move @
   (let M (conc (rest) (1))
      (case *Change
         (NIL (and (eval (rest)) (goto @ *@@ T)))
         ("!" (eval (rest)) (cmdPipe (cnt@@)))  # External filter
         (">" (evRpt (list 'shiftY M T)))  # Shift right
         ("<" (evRpt (list 'shiftY M)))  # Shift left
         ("c"  # Change
            (when (cutX (eval M) T)
               (and *@@
                  (get (: buffer text) (: posY) 1)
                  (inc (:: posX)) )
               (let L (insMode *@@)
                  (setq *Repeat
                     (list 'prog
                        (list 'cutX M T)
                        (list 'paste (lit L) '*@@)) ) ) ) )
         ("d" (evRpt (list 'cutX M T)))  # Delete
         ("y" (cutX (eval M)))  # Yank
         (T (beep)) ) ) )

(de chgRight (X)
   (setq *Change "c")
   (move 'goRight X) )

(de jmpMark (C D X)
   (cond
      ((= C D)
         (move 'goAbs
            (or X (: buffer lastX))
            (: buffer lastY) ) )
      ((get (: buffer) (intern C 'vip))
         (move 'goAbs (default X (car @)) (cdr @)) ) ) )

(de wordFun (@W)
   (setq *Search
      (let @N (inc (length @W))
         (curry (@W @N) (L C)
            (and
               (delimNs C)
               (head '@W L)
               (delimNs (get L @N)) ) ) ) ) )

(de moveSearch (Fun1 Fun2)
   (move Fun1 (lit Fun2) *Cnt) )

(de patMatch (Fun @Pat)
   (moveSearch Fun
      (setq *Search
         (ifn (= "\\" (car @Pat))
            (let @Lst 'L
               (when (= "~" (car @Pat))
                  (setq
                     @Pat (mapcar lowc (cdr @Pat))
                     @Lst '(mapcar lowc L) ) )
               (if
                  (nor
                     (= "\^" (car @Pat))
                     (= "$" (last @Pat))
                     (find pat? @Pat) )
                  (curry (@Pat @Lst) (L)
                     (head '@Pat @Lst) )
                  (setq @Pat
                     (if (= "$" (last @Pat))
                        (head -1 @Pat)
                        (append @Pat '(@)) ) )
                  (ifn (= "\^" (car @Pat))
                     (curry (@Pat @Lst) (L)
                        (match '@Pat @Lst) )
                     (++ @Pat)
                     (curry (@Pat @Lst) (L C)
                        (unless C (match '@Pat @Lst)) ) ) ) )
            (++ @Pat)
            (curry (@Pat) (L)
               (head '@Pat L) ) ) ) ) )

(de parMatch (Fun1 @Par1 @Sup1 @ParO @ParC @SupO @SupC)
   (moveSearch Fun1
      (let (Par @Par1  Sup @Sup1)
         (curry (Par Sup @Par1 @Sup1 @ParO @ParC @SupO @SupC) (L C)
            (unless (caar L)
               (and
                  (case (car L)
                     (@ParO (nil (inc 'Par)))
                     (@ParC (or (not C) (= (dec 'Par) 0 Sup)))
                     (@SupO (nil (push 'Sup Par) (zero Par)))
                     (@SupC
                        (or
                           (not C)
                           (= (setq Par (++ Sup)) 0 Sup) ) ) )
                  (setq Par @Par1  Sup @Sup1) ) ) ) ) ) )

(de *Spell
   "hunspell" "-l" "-d" "en_US,de_DE" )

(de spell ()
   (let? @W
      (pipe
         (out *Spell
            (let Pos (nth (: buffer text) (: posY))
               (prinl
                  (seek
                     '((L) (not (fold (car L))))
                     (nth (++ Pos) (: posX)) ) )
               (mapc prinl Pos) ) )
         (line) )
      (let @N (inc (length @W))
         (moveSearch 'goForward
            (setq *Search
               (curry (@W @N) (L C)
                  (and
                     (not (fold C))
                     (head '@W L)
                     (not (fold (get L @N))) ) ) ) ) ) ) )

(de pipeN (Cnt Line)
   (evRpt
      (fill
         '(when (cdr (cutN Cnt))
            (pipe (out (list *Shell "-c" Line) (mapc prinl @))
               (paste (cons T (rdLines)) *@@) ) )
         '(Line Cnt) ) ) )

(de nextBuf (B)
   (let? M (member (: buffer) *Buffers)
      (when (flg? B)
         (setq B
            (car
               (if B
                  (or (prior M *Buffers) (tail 1 *Buffers))
                  (or (cdr M) *Buffers) ) ) ) )
      (unmark)
      (unless (== B (: buffer))
         (=: last (: buffer))
         (=: buffer B)
         (unless (: buffer text)
            (load> (: buffer) This) ) )
      (off *StatNm)
      (goto (: buffer posX) (: buffer posY)) ) )

(de shell (S)
   (vipZ)
   (do *Columns (prin "#"))
   (call *Shell "-c" S)
   (prin "[====] ")
   (flush)
   (getch)
   (prinl)
   (vipA)
   (repaint) )

(de shFile (S)
   (when (: buffer file)
      (shell (text S @ *Cnt)) ) )

(de prCmd (L)
   (with *CmdWin
      (paste (cons T L) (: buffer text))
      (inc (:: posY) (dec (length L))) ) )

(de evCmd Prg
   (out (tmp "repl")
      (err NIL
         (catch '(NIL)
            (setq *@ (run Prg 1)  *Msg)
            (print '-> *@)
            (remark *@)
            (prinl) ) )
      (when @@
         (prin "!? ")
         (println ^)
         (prinl *Msg) ) )
   (in (tmp "repl")
      (prCmd (rdLines)) ) )

(de cmd (Cmd . Fun)
   (if (assoc Cmd *CmdMap)
      (con @ Fun)
      (push '*CmdMap (cons Cmd Fun)) ) )

(de _map (@Map @C @S)
   (macro
      (push1 '@Map '(@C (setq *Keys (chop @S)))) ) )

(de map+ (C . X)
   (if (str? (car X))
      (_map '*KeyMap C @)
      (push1 '*KeyMap (cons C X)) ) )

(de map+g (C . X)
   (if (str? (car X))
      (_map '*KeyMap-g C @)
      (push1 '*KeyMap-g (cons C X)) ) )

(de map+q (C . X)
   (if (str? (car X))
      (_map '*KeyMap-q C @)
      (push1 '*KeyMap-q (cons C X)) ) )

(de posChar ()
   (get (: buffer text) (: posY) (: posX)) )

(de getText Prg
   (let (*Change "y"  *Clip (box))
      (run Prg 1)
      (glue "\n" (val *Clip)) ) )

(de s-expr ()
   (any
      (getText
         (case (posChar)
            ("\"" (move 'goFind "\"" 0 1))
            ("(" (parMatch 'goForward 1 0 "(" ")" "[" "]"))
            ("[" (parMatch 'goForward 0 (0 . 0) "(" ")" "[" "]"))
            (T (move 'goForward 'end 1)) ) ) ) )

(de reset ()
   (off *Count *Change)
   (setq *Clip '\"\") )

(private) (Lst Ns L C S X)

### Commands ###
(de command (This Line)
   (case (++ Line)
      ("/" (patMatch 'goForward Line))  # Search forward
      ("?" (patMatch 'goBackward Line))  # Search backward
      ("&" (moveSearch 'goForward (wordFun Line)))  # Search word
      (":"
         (let Cnt 0
            (while (format (car Line))
               (setq Cnt (+ @ (* 10 Cnt)))
               (++ Line) )
            (let C (++ Line)
               (when (>= "z" C "a")
                  (until (sp? (car Line))
                     (setq C (pack C (++ Line))) ) )
               (let L (pack (clip Line))
                  (if (assoc C *CmdMap)
                     ((cdr @) L Line Cnt)
                     (case C
                        (" "  # Eval
                           (setq @ *@)
                           (evCmd (run (str L))) )
                        ("$"  # Shell command
                           (cond
                              (L
                                 (scratch (tmp "cmd" (inc (0)))
                                    (in (list *Shell "-c" (setq L (rplFile L)))
                                       (rdLines) ) )
                                 (=: buffer cmd L) )
                              ((: buffer cmd)
                                 (scratch (: buffer file)
                                    (in (list *Shell "-c" @)
                                       (rdLines) ) ) ) ) )
                        ("!"  # External filter
                           (when L
                              (if (=0 Cnt)
                                 (shell (rplFile L))
                                 (pipeN Cnt L) ) ) )
                        ("cp"  # Copy to system clipboard
                           (out '("copy")  # System dependent script
                              (let V (val *Clip)
                                 (if (=T (car V))
                                    (mapc prinl (cdr V))
                                    (map
                                       '(((S . L)) (prin S (and L "\n")))
                                       V ) ) ) ) )
                        ("bak" (shFile "mv @1 @1- && cp -p @1- @1"))  # Backup to -
                        ("kab"  # Restore from -
                           (shFile "mv @1- @1 && cp -p @1 @1-")
                           (reload) )
                        ("ls"  # List buffers
                           (prCmd
                              (make
                                 (for (I . This) *Buffers
                                    (link
                                       (chop (pack ":" I " " (prName (: file)))) ) ) ) ) )
                        ("key" (=: buffer key L) (reload))
                        ("m"
                           (when (info (=: mark (path (rplFile L))))
                              (in (: mark) (move 'goAbs (read) (read))) ) )
                        ("n" (nextBuf))  # Next buffer
                        ("N" (nextBuf T))  # Previous buffer
                        ("tag" (apply tag (str L)))
                        ("v" (reload (syms (str L)) 1 1))
                        ("e" (reload (rplFile L)))  # (Edit) Reload buffer
                        ("E"  # (Edit) Toggle subdir recursion and reload buffer
                           (=: buffer subd (not (: buffer subd)))
                           (reload (rplFile L)) )
                        ("r"  # Read file contents
                           (let F (path (rplFile L))
                              (when (info F)
                                 (in F (paste (cons T (rdLines)) 1)) ) ) )
                        ("w"  # (Write) Save buffer
                           (if L
                              (out (path (rplFile @))
                                 (mapc prinl (: buffer text)) )
                              (save> (: buffer) This) ) )
                        ("l"  # (load) Save and load
                           (when (: buffer file)
                              (when (dirty> (: buffer) This)
                                 (save> (: buffer) This) )
                              (evCmd (load (: buffer file))) ) )
                        (("x" "wq") (done T))  # (Exit) Save buffer and close window
                        ("q" (done))  # (Quit) Close window
                        ("bx"  # Buffer exchange
                           (let X (memq (: buffer) *Buffers)
                              (if (cdr X)
                                 (xchg X @)
                                 (beep) ) ) )
                        ("bd"  # Buffer delete
                           (when (cdr *Buffers)
                              (let? Buf (if (=0 Cnt) (: buffer) (get *Buffers Cnt))
                                 (for (This *CmdWin (setq This (: next)))
                                    (cond
                                       ((== Buf (: last))
                                          (=: last) )
                                       ((== Buf (: buffer))
                                          (nextBuf (: last))
                                          (=: last) ) ) )
                                 (del Buf '*Buffers)
                                 (=: last) ) ) )
                        ("map"  # Add/remove key mappings
                           (++ Line)
                           (let C (++ Line)
                              (until (sp? (car Line))
                                 (setq C (pack C (++ Line))) )
                              (if Line
                                 (push '*KeyMap
                                    (list C
                                       (list 'setq '*Keys
                                          (lit (mapcar name (cdr Line))) ) ) )
                                 (del (assoc C *KeyMap) '*KeyMap) ) ) )
                        (T
                           (if (get *Buffers Cnt)
                              (nextBuf @)
                              (beep) ) ) ) ) ) ) )
         (with *CmdWin
            (redraw) ) )
      (T (beep)) ) )

(de syms (Lst)
   (prog1
      (tmp "syms")
      (syms> (fileBuffer @) Lst) ) )

(de vipA ()
   (screen2)
   (raw T) )

(de vipZ ()
   (raw NIL)
   (screen1) )

### VIP Entry Point ###
(de vi (Lst Ns)  # (file (pat . file) (99 . file) (T . file) (sym [sym ..])
   (getSize)
   (and Lst (co 'vip))
   (co 'vip
      (setq *Ns (symbols))
      (and Ns (symbols @))
      (off *Buffers)
      (when (=0 (%@ "isatty" 'I 0))
         (with (fileBuffer (tmp "stdin"))
            (out (: file) (in 0 (echo))) )
         (ctty "/dev/tty") )
      (for X Lst
         (cond
            ((not X))
            ((atom X) (fileBuffer X))  # Path name
            ((pair (car X))  # Pattern
               (wordFun @)
               (fileBuffer (cdr X)) )
            ((or (num? (car X)) (=T (car X)))  # Line number
               (fileBuffer (cdr X) @) )
            (T (syms X)) ) )  # List of symbols
      (unless *Buffers
         (fileBuffer (tmp "empty")) )
      (vipA)
      (let
         (*Winch '((getSize) (eqwin) (flush))
            *TStp1 '((vipZ))
            *TStp2 '((vipA) (repaint) (cursor) (flush)) )
         (reset)
         (setq *CmdWin
            (new '(+Window) (new '(+Buffer)) (dec *Lines) 1 1 1 1 1) )
         (with (car *Buffers)
            (load> This)
            (setq *Window
               (new '(+Window) This
                  0 (- *Lines 2)
                  1
                  (min1
                     (- (: posY) (/ (- *Lines 2) 2))
                     (- (length (: text)) *Lines -3) )
                  1 (: posY)
                  *CmdWin ) ) )
         (with *Window (redraw))
         (finally (prog (rollback) (vipZ))
            (catch 'done
               (loop
                  (setq *Cnt (max 1 (format *Count)))
                  (with *Window
                     (=: posX
                        (min1 (: posX)
                           (length
                              (get (: buffer text)
                                 (=: posY
                                    (min1 (: posY) (length (: buffer text))) ) ) ) ) )
                     (symbols (: buffer symbols))
                     (when
                        (or
                           (> (: winX) (: posX))
                           (> (: winY) (: posY)) )
                        (=: winX (min1 (: posX) (: winX)))
                        (=: winY (min1 (: posY) (: winY)))
                        (redraw) )
                     (cursor)
                     (case (getch)
                        ("0"
                           (if *Count
                              (queue '*Count "0")
                              (move 'goAbs 1 (: posY))  # Go to beginning of line
                              (off *Change) ) )
                        (("1" "2" "3" "4" "5" "6" "7" "8" "9")  # ["Count" prefix]
                           (queue '*Count *Chr) )
                        ("\"" (setq *Clip (intern (pack '"\"" (getch)) 'vip)))  # "Register" prefix
                        (("!" "<" ">" "c" "d" "y")  # ["Change" prefix]
                           (cond
                              ((= *Chr *Change)
                                 (case *Chr
                                    ("!" (cmdPipe *Cnt))  # [!!] External filter
                                    (">" (evRpt (list 'shift *Cnt T)))  # [>>] Shift line(s) right
                                    ("<" (evRpt (list 'shift *Cnt)))  # [<<] Shift line(s) left
                                    ("c" (=: posX 1) (chgRight T))  # [cc] Change whole line
                                    ("d" (evRpt (list 'cutN *Cnt)))  # [dd] Delete line(s)
                                    ("y"  # [yy] Yank line(s)
                                       (set *Clip
                                          (cons T
                                             (head *Cnt (nth (: buffer text) (: posY))) ) ) ) )
                                 (reset) )
                              (*Change (off *Change))
                              (T (setq *Change *Chr)) ) )
                        (T
                           (if (assoc *Chr *KeyMap)
                              (run (cdr @))
                              (case *Chr
                                 ("\e")
                                 (("\n" "\r")
                                    (if (== This *CmdWin)
                                       (command (: next) (get (: buffer text) (: posY)))
                                       (goto 1 (inc (: posY)) T)  # Go to next line
                                       (do (: sc) (scRight))
                                       (redraw) ) )
                                 ("." (if *Repeat (eval @) (beep)))  # Repeat last change
                                 (("j" "\e[B") (move 'goDown *Cnt))  # [DOWN] Move down
                                 (("^F" "\e[6~") (move 'goDown (: lines)))  # [PGDOWN] Page down
                                 (("k" "\e[A") (move 'goUp *Cnt))  # [UP] Move up
                                 (("^B" "\e[5~") (move 'goUp (: lines)))  # [PGUP] Page up
                                 ("h" (move 'goLeft *Cnt))  # Move left
                                 ("l" (move 'goRight *Cnt))  # Move right
                                 ("\e[D" (do 2 (scLeft)) (redraw))  # [LEFT] Scroll left
                                 ("\e[C" (do 2 (scRight)) (redraw))  # [RIGHT] Scroll right
                                 ("z" (do 3 (scRight)) (redraw))  # Scroll right 3 columns
                                 ("Z" (do 3 (scLeft)) (redraw))  # Scroll left 3 columns
                                 ("|" (move 'goCol *Cnt))  # Go to column
                                 ("$" (move 'goRight T))  # Go to end of line
                                 (("\e[1~" "\e[H") (move 'goAbs 1 1))  # [HOME] Go to beginning of text
                                 (("\e[4~" "\e[F") (move 'goAbs 1 T))  # [END] Go to end of text
                                 ("G" (move 'goAbs 1 (or (format *Count) T)))  # [G] Go to end of text or line number
                                 ("f" (and (getch2 (getch)) (move 'goFind @ 0 *Cnt)))  # Find character
                                 ("t" (and (getch2 (getch)) (move 'goFind @ -1 *Cnt)))  # Till character
                                 ("\t" (move 'goForward 'tword *Cnt))  # TAB word forward
                                 ("w" (move 'goForward 'word *Cnt))  # Word forward
                                 ("W" (move 'goForward 'lword *Cnt))  # Long word forward
                                 ("b" (move 'goBackward 'word *Cnt))  # Word backward
                                 ("B" (move 'goBackward 'lword *Cnt))  # Long word backward
                                 ("e" (move 'goForward 'end *Cnt))  # End of word
                                 ("E" (move 'goForward 'lend *Cnt))  # End of long word
                                 ("{" (move 'goPBack *Cnt))  # Paragraph(s) backward
                                 ("}" (move 'goPFore *Cnt 0))  # Paragraph(s) forward
                                 ("'" (jmpMark (getch) "'" 1))  # Jump to mark line
                                 ("`" (jmpMark (getch) "`")) # Jump to mark position
                                 ("~" (evRpt (list 'tglCase *Cnt)))  # Toggle case
                                 ((":" " ") (cmdMode (name ":")))  # Command
                                 ("/" (cmdMode (name "/")))  # Search forward
                                 ("?" (cmdMode (name "?")))  # Search backward
                                 ("&" (cmdMode (name "&")))  # Search word
                                 ("n"  # Search next
                                    (if *Search
                                       (move 'goForward (lit @) *Cnt)
                                       (beep) ) )
                                 ("N"  # Search previous
                                    (if *Search
                                       (move 'goBackward (lit @) *Cnt)
                                       (beep) ) )
                                 ("*"  # Search word under cursor
                                    (and (getWord) (moveSearch 'goForward (wordFun @))) )
                                 ("#"  # Search word under cursor backward
                                    (and (getWord) (moveSearch 'goBackward (wordFun @))) )
                                 ("%"  # Matching parenthesis
                                    (case (posChar)
                                       ("(" (parMatch 'goForward 1 0 "(" ")" "[" "]"))
                                       ("[" (parMatch 'goForward 0 (0 . 0) "(" ")" "[" "]"))
                                       (")" (parMatch 'goBackward 1 0 ")" "(" "]" "["))
                                       ("]" (parMatch 'goBackward 0 (0 . 0) ")" "(" "]" "["))
                                       (T (beep)) ) )
                                 ("i"  # Insert
                                    (when (insMode)
                                       (setq *Repeat (list 'paste (lit @))) ) )
                                 ("I"  # Insert at beginning of line
                                    (goto 1 (: posY))
                                    (when (insMode)
                                       (setq *Repeat (list 'paste (lit @) 0)) ) )
                                 ("a"  # Append
                                    (when (get (: buffer text) (: posY) 1)
                                       (inc (:: posX)) )
                                    (when (insMode 1)
                                       (setq *Repeat (list 'paste (lit @) 1)) ) )
                                 ("A"  # Append to end of line
                                    (goto
                                       (inc (length (get (: buffer text) (: posY))))
                                       (: posY)
                                       T )
                                    (when (insMode 1)
                                       (setq *Repeat (list 'paste (lit @) T)) ) )
                                 ("o"  # Open new line below current line
                                    (setq *Repeat (list 'paste (lit (insMode T)) T)) )
                                 ("O"  # Open new line above current line
                                    (setq *Repeat (list 'paste (lit (insMode 0)) 0)) )
                                 ("x" (setq *Change "d") (move 'goRight *Cnt))  # Delete characters
                                 ("X" (setq *Change "d") (move 'goLeft *Cnt))  # Delete characters left
                                 ("D" (setq *Change "d") (move 'goRight T))  # Delete rest of line
                                 ("p" (evRpt (list 'paste (lit (val *Clip)) 1)))  # Paste after current position
                                 ("P" (evRpt (list 'paste (lit (val *Clip)))))  # Paste before current position
                                 ("J" (evRpt (list 'join *Cnt)))  # Join lines
                                 ("m"  # Set mark
                                    (put (: buffer) (intern (getch) 'vip)
                                       (cons (: posX) (: posY)) ) )
                                 ("M" (=: sc (dec (: winX))))  # Mark horizontal scroll position
                                 ("r"  # Replace character(s)
                                    (and (getch2 (getch)) (evRpt (list 'insChar @ *Cnt))) )
                                 ("R"  # Replace
                                    (when (insMode NIL NIL T)
                                       (setq *Repeat (list 'overwrite (lit @))) ) )
                                 ("s" (chgRight 1))  # Substitute character
                                 ("C" (chgRight T))  # Change rest of line
                                 ("S" (=: posX 1) (chgRight T))  # Change whole line
                                 ("," (evRpt '(indent)))  # Fix indentation
                                 ("^A" (evRpt (list 'incNum *Cnt)))
                                 ("^X" (evRpt (list 'incNum (- *Cnt))))
                                 ("u" (undo))  # Undo
                                 ("^R" (redo))  # Redo
                                 ("^E" (evCmd (eval (s-expr))))  # Evaluate expression
                                 ("g"  # ["Go" prefix]
                                    (if (assoc (getch) *KeyMap-g)
                                       (run (cdr @))
                                       (case *Chr
                                          ("f"  # [gf] Edit file under cursor
                                             (pushTag (: buffer file))
                                             (reload (pack (getWord))) )
                                          ("w"  # [gw] Web page
                                             (scratch (tmp "web" (inc (0)))
                                                (in (list "w3m" "-cols" *Columns (getWord))
                                                   (rdLines) ) ) )
                                          ("h"  # [gh] HTTP code
                                             (scratch (tmp "http" (inc (0)))
                                                (in (list "w3m" "-dump_both" (getWord))
                                                   (rdLines) ) ) )
                                          ("b"  # [gb] Browser
                                             (vipZ)
                                             (call (or (sys "BROWSER") "w3m") (getWord))
                                             (vipA)
                                             (repaint) )
                                          ("g" (move 'goAbs 1 (or (format *Count) 1)))  # [gg] Go to beginning of text
                                          ("s" (spell))
                                          (T (beep)) ) ) )
                                 ("+"  # Increase window size
                                    (loop
                                       (NIL (setq This (: prev))
                                          (for (This (; *Window next) This (: next))
                                             (T (> (: lines) 1)
                                                (with *Window
                                                   (chgwin (inc (: lines)) (dec (: top)))
                                                   (for (This (: next) (=1 (: lines)) (: next))
                                                      (chgwin 1 (dec (: top))) ) )
                                                (chgwin (dec (: lines))) ) ) )
                                       (T (> (: lines) 1)
                                          (with *Window
                                             (chgwin (inc (: lines)))
                                             (for (This (: prev) (=1 (: lines)) (: prev))
                                                (chgwin 1 (inc (: top))) ) )
                                          (chgwin (dec (: lines)) (inc (: top))) ) ) )
                                 ("-"  # Decrease window size
                                    (cond
                                       ((=1 ( : lines)))
                                       ((: prev)
                                          (chgwin (dec (: lines)))
                                          (with (: prev)
                                             (chgwin (inc (: lines)) (dec (: top))) ) )
                                       (T
                                          (chgwin (dec (: lines)) (inc (: top)))
                                          (with (: next)
                                             (chgwin (inc (: lines))) ) ) ) )
                                 ("=" (eqwin))  # Set all windows to equal size
                                 ("K"  # Edit symbol
                                    (let S (any (getWord))
                                       (ifn (: buffer syms)
                                          (tag S)
                                          (pushTag @)
                                          (syms> (: buffer) (cons S @))
                                          (reload (: buffer file) 1 1) ) ) )
                                 ("^]"  # Edit symbol definition
                                    (tag (any (getWord))) )
                                 (("Q" "^T")  # Pop tag stack
                                    (ifn *TagStack
                                       (beep)
                                       (symbols (++ *TagStack))
                                       (if (atom (car *TagStack))
                                          (reload (++ *TagStack) (++ *TagStack) (++ *TagStack))
                                          (syms> (: buffer) (++ *TagStack))
                                          (reload (: buffer file) (++ *TagStack) (++ *TagStack)) ) ) )
                                 (("\eOP" "\e[[A")  # [F1] Highlight on/off
                                    (=: buffer flat (not (: buffer flat)))
                                    (repaint) )
                                 (("\eOQ" "\e[[B")  # [F2] Show chages to -
                                    (shFile
                                       (if (sys "CCRYPT" (: buffer key))
                                          "diff -Bb <(ccrypt -c -ECCRYPT @1-) <(ccrypt -c -ECCRYPT @1)"
                                          "diff -Bb @1- @1" ) ) )
                                 (("\eOR" "\e[[C")  # [F3] Custom dif
                                    (shFile "dif @1 @2") )
                                 (("\eOS" "\e[[D")  # [F4] Format paragraph
                                    (and *Count (=: buffer fmt @))
                                    (goPFore 1 -1)
                                    (pipeN (cnt@@) (pack "fmt -" (: buffer fmt))) )
                                 (("\e[15~" "\e[[E")  # [F5] Previous buffer
                                    (nextBuf T) )
                                 ("\e[17~"  # [F6] Next buffer
                                    (nextBuf) )
                                 ("\e[18~" (run *F7))  # [F7] Custom key
                                 ("\e[19~" (run *F8))  # [F8] Custom key
                                 ("\e[20~" (run *F9))  # [F9] Custom key
                                 ("\e[21~" (run *F10))  # [F10] Custom key
                                 ("\e[23~" (run *F11))  # [F11] Custom key
                                 ("\e[24~" (run *F12))  # [F12] Custom key
                                 ("\\"  # Select or toggle buffer
                                    (nextBuf
                                       (if *Count
                                          (get *Buffers (format @))
                                          (or (: last) (car *Buffers)) ) ) )
                                 (("q" "^W")  # ["Window" prefix]
                                    (if (assoc (getch) *KeyMap-q)
                                       (run (cdr @))
                                       (case *Chr
                                          ("s"  # [qs] Split window
                                             (unless (== This *CmdWin)
                                                (let (Old (inc (: lines))  New (/ Old 2))
                                                   (with
                                                      (new '(+Window) (: buffer)
                                                         (+ (: top) New) (- Old New 1)
                                                         (: winX) (: winY)
                                                         (: posX) (: posY)
                                                         (: prev)
                                                         (: mark) )
                                                      (goto (: posX) (: posY)) )
                                                   (=: mark)
                                                   (chgwin (dec New)) ) ) )
                                          ("x"  # [qx] Exchange windows
                                             (and
                                                (; *CmdWin next next)
                                                (n== This *CmdWin)
                                                (let W (if (== (: prev) *CmdWin) (: next) (: prev))
                                                   (for P '(buffer winX winY posX posY last mark sc)
                                                      (xchg (prop This P) (prop W P)) )
                                                   (goto (: posX) (: posY))
                                                   (with W
                                                      (goto (: posX) (: posY)) ) ) ) )
                                          ("k" (and (: next) (setq *Window @)))  # [qk] Above window
                                          ("j" (and (: prev) (setq *Window @)))  # [qj] Below window
                                          ("q" (done))  # [qq] (Quit) Close window
                                          ("z" (run *TStp1) (yield) (run *TStp2))  # [qz] Suspend
                                          (T (beep)) ) ) )
                                 ("v" (view> This))  # View hook
                                 (T (beep)) ) )
                           (reset) ) ) ) ) ) ) ) ) )

(and (info "~/.pil/viprc") (load @@))

### Debug ###
`*Dbg

(de pico~vi (X C)
   (setq C
      (if C
         (or
            (get C '*Dbg -1 X)
            (meta C '*Dbg -1 X) )
         (get X '*Dbg 1) ) )
   (and
      (vi
         (list
            (cond
               ((pair X) @)
               (C (cons (car @) (cadr @)))
               (T X) ) )
         (cddr C) )
      X ) )

(de pico~v Lst
   (cond
      (Lst (vi (list @)))
      ((asoq 'vip (stack)) (vi)) ) )
pil21/lib/vip/load.l0000644000000000000000000000054614726066632011354 0ustar  # 10dec24 Software Lab. Alexander Burger

# View output of 'load'ing the file
(let? *Class (isa '+Buffer This)
   (dm view> (Win)
      (=: view T)
      (with Win
         (scratch (tmp "xml")
            (pipe (load (: buffer file))
               (rdLines) ) ) ) )
   (dm save> (Win)
      (super Win)
      (when (: view)
         (view> This Win) ) ) )
pil21/lib/vip/html.l0000644000000000000000000000106714517462775011406 0ustar  # 29oct23 Software Lab. Alexander Burger

# View HTML buffers
(let? *Class (isa '+Buffer This)
   (dm view> (Win)
      (=: view T)
      (with Win
         (let
            (Y (- (: posY) 13)
               N (- (length (: buffer text)) 15) )
            (scratch (tmp "html")
               (in (list "w3m" "-cols" *Columns (: buffer file))
                  (rdLines) ) )
            (unless (: buffer view)
               (goto 1 (*/ Y (length (: buffer text)) N)) ) ) ) )
   (dm save> (Win)
      (super Win)
      (when (: view)
         (view> This Win) ) ) )
pil21/lib/vip/draw.l0000644000000000000000000002152514514276602011365 0ustar  # 19oct23 Software Lab. Alexander Burger

(symbols 'vip~draw 'vip 'pico)

(local) (*DX *DY *PX *PY *Draw *Boxes)

(zero *DX *DY)

# Drawing primitives
(local) (point hline vline go up down left right rect label)

(de point (X Y C)
   (inc 'X *DX)
   (inc 'Y *DY)
   (let P
      (or
         (nth *Draw Y)
         (nth (setq *Draw (need (- Y) *Draw)) Y) )
      (set
         (or
            (nth (car P) X)
            (nth
               (set P (need (- X) (car P) (name " ")))
               X ) )
         (name C) ) ) )

(de hline (C X Y X2 A)
   (point X Y C)
   (if (> X2 X)
      (do (- X2 X)
         (point (inc 'X) Y "-") )
      (do (- X X2)
         (point (dec 'X) Y "-") ) )
   (and A (point X Y A)) )

(de vline (C X Y Y2 A)
   (point X Y C)
   (if (> Y2 Y)
      (do (- Y2 Y)
         (point X (inc 'Y) "|") )
      (do (- Y Y2)
         (point X (dec 'Y) "|") ) )
   (and A (point X Y A)) )

(de go (X Y C)
   (point (setq *PX X) (setq *PY Y) C) )

(de up (N C)
   (vline "|" *PX (dec *PY) (dec '*PY N) C) )

(de down (N C)
   (vline "|" *PX (inc *PY) (inc '*PY N) C) )

(de left (N C)
   (hline "-" (dec *PX) *PY (dec '*PX N) C) )

(de right (N C)
   (hline "-" (inc *PX) *PY (inc '*PX N) C) )

(de rect (X Y X2 Y2)
   (hline "+" X Y (dec X2))
   (vline "+" X2 Y (dec Y2))
   (hline "+" X2 Y2 (inc X))
   (vline "+" X Y2 (inc Y)) )

(de label (X Y Txt)
   (for C (chop Txt)
      (point X Y C)
      (inc 'X) ) )

# Box
(local) (+Box mx> my> hv>)

(class +Box)
# id x y x2 y2 dx dy h v

(dm mx> ()
   (*/ (+ (: x) (: x2)) 2) )

(dm my> ()
   (*/ (+ (: y) (: y2)) 2) )

(dm hv> ()
   (for L (: h)
      (loop
         (apply hline (++ L))
         (NIL L)
         (apply vline (++ L))
         (NIL L) ) )
   (for L (: v)
      (loop
         (apply vline (++ L))
         (NIL L)
         (apply hline (++ L))
         (NIL L) ) ) )


# Draw box
(local) (block box)
(private) (X Y DX DY Txt Prg)

(de block (X Y . Prg)
   (let (*DX (dec X)  *DY (dec Y))
      (run Prg) ) )

(de box (X Y DX DY Txt . Prg)
   (with
      (new '(+Box)
         'id (if (atom Txt) Txt (car Txt))
         'x (inc 'X *DX)
         'y (inc 'Y *DY)
         'x2 (+ X DX)
         'y2 (+ Y DY)
         'dx DX
         'dy DY )
      (queue '*Boxes This)
      (let (*DX 0  *DY 0)
         (rect (: x) (: y) (: x2) (: y2))
         (when (fin Txt)
            (label
               (+ (: x) (*/ (- (: dx) (length @)) 2))
               (+ (: y) (*/ (: dy) 2))
               @ ) ) )
      (let (*DX X  *DY Y)
         (run Prg) ) ) )

# Draw arrow
(local) arrow

(de arrow (Id1 Id2)
   (with
      (if (num? Id1)
         (get *Boxes Id1)
         (find '((This) (= Id1 (: id))) *Boxes) )
      (let? B
         (if (num? Id2)
            (get *Boxes Id2)
            (find '((This) (= Id2 (: id))) *Boxes) )
         (let (X (mx> This)  Y (my> This)  X2 (mx> B)  Y2 (my> B))
            (cond
               ((> (; B y) (: y2))  # Above
                  (cond
                     ((or
                           (>= 3 (- (; B y) (: y2)))
                           (>= (inc X2) X (dec X2)) )
                        (push (:: v)
                           (list
                              (list "+" X (: y2) (dec (; B y)) "v") ) ) )
                     ((> (; B y) (+ 4 (: y2)))
                        (push (:: v)
                           (let M (/ (+ (: y2) (; B y)) 2)
                              (list
                                 (list "+" X (: y2) (dec M))
                                 (list "+" X M X2)
                                 (list "+" X2 M (dec (; B y)) "v") ) ) ) )
                     ((> (; B x) (+ 2 X))  # Left
                        (push (:: v)
                           (list
                              (list "+" X (: y2) (dec Y2))
                              (list "+" X Y2 (dec (; B x)) ">") ) ) )
                     ((> X (+ 2 (; B x2)))  # Right
                        (push (:: v)
                           (list
                              (list "+" X (: y2) (dec Y2))
                              (list "+" X Y2 (inc (; B x2)) "<") ) ) ) ) )
               ((> (: y) (; B y2))  # Below
                  (cond
                     ((or
                           (>= 3 (- (: y) (; B y2)))
                           (>= (inc X2) X (dec X2)) )
                        (push (:: v)
                           (list
                              (list "+" X (: y) (inc (; B y2)) "\^") ) ) )
                     ((> (: y) (+ 4 (; B y2)))
                        (push (:: v)
                           (let M (*/ (+ (: y) (; B y2)) 2)
                              (list
                                 (list "+" X (: y) (inc M))
                                 (list "+" X M X2)
                                 (list "+" X2 M (inc (; B y2)) "\^") ) ) ) )
                     ((> (; B x) (+ 2 X))  # Left
                        (push (:: v)
                           (list
                              (list "+" X (: y) (inc Y2))
                              (list "+" X Y2 (dec (; B x)) ">") ) ) )
                     ((> X (+ 2 (; B x2)))  # Right
                        (push (:: v)
                           (list
                              (list "+" X (: y) (inc Y2))
                              (list "+" X Y2 (inc (; B x2)) "<") ) ) ) ) )
               (T  # Besides
                  (cond
                     ((> (; B x) (: x2))  # Left
                        (push (:: h)
                           (if (= Y Y2)
                              (list
                                 (list "+" (: x2) Y (dec (; B x)) ">") )
                              (let M (*/ (+ (: x2) (; B x)) 2)
                                 (list
                                    (list "+" (: x2) Y (dec M))
                                    (list "+" M Y Y2)
                                    (list "+" M Y2 (dec (; B x)) ">") ) ) ) ) )
                     ((> (: x) (; B x2))  # Right
                        (push (:: h)
                           (if (= Y Y2)
                              (list
                                 (list "+" (: x) Y (inc (; B x2)) "<") )
                              (let M (*/ (+ (: x) (; B x2)) 2)
                                 (list
                                    (list "+" (: x) Y (inc M))
                                    (list "+" M Y Y2)
                                    (list "+" M Y2 (inc (; B x2)) "<") ) ) ) ) ]

# Draw cell structures
(local) (cell cells)

(de cell (X Y Car Cdr)
   (let A (max 6 (+ 3 (length (setq Car (sym Car)))))
      (box X Y A 2
         (cons
            (pack (+ X *DX) "/" (+ Y *DY))
            Car )
         (let B 6
            (setq Cdr
               (cond
                  ((pair Cdr) "  ---")
                  (Cdr
                     (prog1
                        (sym @)
                        (setq B (max 6 (+ 3 (length @)))) ) )
                  (T "/") ) )
            (box A 0 B 2
               (cons (pack X "/" Y "+") Cdr) )
            (+ A B) ) ) ) )

(de cells (X Y Any)
   (let Pos (list X)
      (recur (Any Y Pos)
         (let (Y2 (+ Y *DY)  Last)
            (while (pair Any)
               (use D
                  (if (atom (car Any))
                     (setq D (cell (car Pos) Y (++ Any) Any))
                     (ifn (cdr Pos)
                        (con Pos (list (car Pos)))
                        (let (P @  M (car Pos))
                           (for (A (car Any) (pair A) (car A))
                              (setq M (max M (++ P))) )
                           (map
                              '((L) (set L (max M (car L))))
                              Pos ) ) )
                     (setq D
                        (cell (car Pos) Y '| (cdr Any)) )
                     (recurse (++ Any) (+ Y 5) (cdr Pos))
                     (let X2 (+ (car Pos) *DX)
                        (arrow
                           (pack X2 "/" Y2)
                           (pack X2 "/" (+ Y2 5)) ) ) )
                  (let X2 (+ (car Pos) *DX)
                     (when Last
                        (arrow @ (pack X2 "/" Y2)) )
                     (setq Last (pack X2 "/" Y2 "+")) )
                  (inc Pos (+ 6 D)) ) ) ) ) ) )

# Override +Buffer methods in object
(let? *Class (isa '+Buffer This)
   (dm view> (Win)
      (=: view T)
      (off *Draw *Boxes)
      (symbols '(vip~draw vip pico)
         (evCmd (load (fName (: file)))) )
      (mapc 'hv> *Boxes)
      (with Win
         (scratch (tmp "draw") *Draw) ) )
   (dm save> (Win)
      (super Win)
      (when (: view)
         (view> This Win) ) ) )

### Debug ###
`*Dbg

(de pico~cells @
   (off *Draw *Boxes)
   (let Y 1
      (while (args)
         (let V (next)
            (cond
               ((pair V)
                  (cells 1 Y V)
                  (setq Y (+ 3 (length *Draw))) )
               (V
                  (label 1 Y V)
                  (inc 'Y) ) ) ) ) )
   (mapc 'hv> *Boxes)
   (out (tmp "cells") (mapc prinl *Draw))
   (pico~vi (tmp "cells")) )
pil21/lib/bash_completion0000644000000000000000000000073413772601174012546 0ustar  # Bash completion for picolisp + pil
# Alexander Burger 

_pil()
{
    local -a ARGS
    local IFS=$'\n'

    for A in "${COMP_WORDS[@]:1:$((COMP_CWORD-1))}"
    do
        test "${A:0:1}" = "-" || ARGS[${#ARGS[@]}]="${A//\\ / }"
    done
    COMPREPLY=($(${COMP_WORDS[0]} ${ARGS[@]} /usr/lib/picolisp/lib/complete.l "${COMP_WORDS[$COMP_CWORD]}" -bye + 2>&1))
    return 0
} &&
complete -o nospace  -F _pil  picolisp  &&
complete -o nospace  -F _pil  pil
pil21/lib/complete.l0000644000000000000000000000163213772601131011431 0ustar  # 29dec20 Software Lab. Alexander Burger

(if (opt)
   (let "Lst" (chop @)
      (if (= "-" (car "Lst"))
         (let "Pre" (++ "Lst")
            (when (member (car "Lst") '("\"" "'"))
               (setq "Pre" (++ "Lst")) )
            (let "Str" (pack "Lst")
               (for "Sym" (all)
                  (and
                     (pre? "Str" "Sym")
                     (getd "Sym")
                     (prinl "Pre" "Sym" (and (= "-" "Pre") " ")) ) ) ) )
         (let ("Path" (rot (split "Lst" "/"))  "Str" (pack (car "Path")))
            (setq "Path" (and (cdr "Path") (pack (glue "/" @) "/")))
            (for "Sym" (dir "Path" T)
               (when (pre? "Str" "Sym")
                  (prinl "Path"
                     (replace (chop "Sym") " " "\\ ")
                     (if (=T (car (info (pack "Path" "Sym"))))
                        "/"
                        " " ) ) ) ) ) ) )
   (prinl '+) )
pil21/bin/pil0000755000000000000000000000021613754160503010160 0ustar  #!/usr/bin/picolisp /usr/lib/picolisp/lib.l
(load "@lib/net.l" "@lib/misc.l" "@lib/btree.l" "@lib/db.l" "@lib/pilog.l")

`*Dbg
(docs "@doc/")
pil21/bin/psh0000755000000000000000000000061514654344007010174 0ustar  #!/usr/bin/pil
# 06aug24 Software Lab. Alexander Burger

(load "@lib/net.l" "@lib/misc.l" "@lib/http.l")

(let Arg (opt)
   (client "localhost"
      (or
         (format Arg)
         (client "localhost" 80 (pack Arg "/!psh") (read)) )
      (pack (opt) "!psh?"
         (pw) "&"
         (in '("tty") (line T)) "&"
         (sys "TERM") )
      (ctty (read))
      (line)
      (line) ) )
(bye)
pil21/bin/pty0000755000000000000000000000253414642043326010215 0ustar  #!/usr/bin/pil
# 05jul24abu
# Pseudo Terminal (PilBox)
# pty [host] [flg]

(load "@lib/term.l")

(setq
   *Host (or (opt) "localhost")
   *Port 8081 )  # Sync with ~/Port in PilBox

(unless (setq *Sock (connect *Host (inc *Port)))
   (bye) )

(out *Sock
   (in "~/.pty" (echo))  # Sync with ~/.pty in PilBox
   (prinl) )
(in *Sock (rd 2))  # Skip "\r\n"

(finish (prinl))

(de sendCmd @
   (udp *Host `(inc *Port)
      (cons (in "~/.pty" (line T)) (rest)) ) )

(unless (opt)
   (task (port (+ *Port 2))
      (let? S (accept @)
         (catch '(NIL)
            (in S
               (when (= (rd) (in "~/.pty" (line T)))
                  (let Z (tmp "pty.zip")
                     (casq (rd)
                        (+
                           (apply call (rd) "zip" "-r" Z)
                           (in Z (out S (echo))) )
                        (-
                           (out Z (echo))
                           (call "unzip" "-o" Z) ) ) ) ) )
            (off *Msg) )
         (close S)
         (and *Msg (prinl @)) ) ) )

(when (getTerm)
   (sendCmd
      (cons 'setTerm (sys "TERM") @)
      '(off *Err) )
   (de *Winch
      (sendCmd (cons 'setTerm (sys "TERM") (getTerm))) ) )

(raw T)
(call "stty" "intr" NIL)

(task *Sock
   (in @
      (ifn (rd 1)
         (bye)
         (wr @)
         (flush) ) ) )

(loop
   (and (key) (out *Sock (prin @))) )
pil21/bin/watchdog0000755000000000000000000000444514416047277011214 0ustar  #!/usr/bin/pil
# 13apr23 Software Lab. Alexander Burger
# Use: bin/watchdog      ..

(load "@lib/misc.l")

# *MailHost *MailPort *MailFrom *MailTo *Watch

(argv *MailHost *MailPort *MailFrom .  *MailTo)
(setq *MailPort (format *MailPort))

(unless (call 'test "-p" "fifo/beat")
   (call 'mkdir "-p" "fifo")
   (call 'rm "-f" "fifo/beat")
   (call 'mkfifo "fifo/beat") )

(finish (call 'rm "fifo/beat"))

(de *Err
   (prin (stamp))
   (space)
   (println *Watch) )

(task (open "fifo/beat")
   (in @
      (let X (rd)
         (cond
            ((not X) (bye))
            ((num? X)
               (let? W (assoc X *Watch)
                  (when (caddr W)
                     (msg (car W) " " (stamp) " bye") )
                  (del W '*Watch) ) )
            ((atom X)  # bin/picolisp -"out 'fifo/beat (pr '$(tty))" -bye
               (let D (+ (* 86400 (date T)) (time T))
                  (out X
                     (for W *Watch
                        (prinl
                           (align 7 (car W))
                           " "
                           (- (cadr W) D)
                           " "
                           (or (caddr W) "o")
                           " "
                           (cdddr W) ) ) ) ) )
            ((assoc (car X) *Watch)    # X = (Pid Tim . Any)
               (let W @                # W = (Pid Tim Flg . Any)
                  (when (caddr W)
                     (msg (car W) " " (stamp) " resumed") )
                  (set (cdr W) (cadr X))
                  (set (cddr W))
                  (con (cddr W) (or (cddr X) (cdddr W))) ) )
            (T (push '*Watch (list (car X) (cadr X) NIL (cddr X)))) ) ) ) )

(task -54321 54321
   (let D (+ (* 86400 (date T)) (time T))
      (for W *Watch
         (cond
            ((>= (cadr W) D))
            ((caddr W)
               (msg (car W) " " (stamp)
                  (if (kill (car W) 15) " killed" " gone") )
               (del W '*Watch) )
            (T
               (inc (cdr W) 3600)
               (set (cddr W) T)
               (let Sub (pack "Timeout " (car W) " " (cdddr W))
                  (msg (car W) " " (stamp))
                  (unless (mail *MailHost *MailPort *MailFrom *MailTo Sub)
                     (msg (cons Sub *MailTo) " mail failed " (stamp)) ) ) ) ) ) ) )

(wait)
pil21/loc/AE.l0000644000000000000000000000047513137355730010127 0ustar  (setq
   *Sep0 "."
   *Sep3 ","
   *CtryCode "971"
   *NatTrunkPrf '("0")
   *DateFmt '(@Y "-" @M "-" @D)
   *DayFmt '("Monday" "Tuesday" "Wednesday" "Thursday" "Friday" "Saturday" "Sunday")
   *MonFmt '("January" "February" "March" "April" "May" "June" "July" "August" "September" "October" "November" "December") )
pil21/loc/AR.l0000644000000000000000000000047513137355704010145 0ustar  (setq
   *Sep0 ","
   *Sep3 "."
   *CtryCode "54"
   *NatTrunkPrf '("0")
   *DateFmt '(@D "-" @M "-" @Y)
   *DayFmt '("Lunes" "Martes" "Miércoles" "Jueves" "Viernes" "Sábado" "Domingo")
   *MonFmt '("Enero" "Febrero" "Marzo" "Abril" "Mayo" "Junio" "Julio" "Agosto" "Septiembre" "Octubre" "Noviembre" "Diciembre") )
pil21/loc/CH.l0000644000000000000000000000047513137355607010137 0ustar  (setq
   *Sep0 "."
   *Sep3 "'"
   *CtryCode "41"
   *NatTrunkPrf '("0")
   *DateFmt '(@D "." @M "." @Y)
   *DayFmt '("Montag" "Dienstag" "Mittwoch" "Donnerstag" "Freitag" "Samstag" "Sonntag")
   *MonFmt '("Januar" "Februar" "März" "April" "Mai" "Juni" "Juli" "August" "September" "Oktober" "November" "Dezember") )
pil21/loc/CKB.l0000644000000000000000000000074314167100305010225 0ustar  (setq
   *Sep0 "."
   *Sep3 ","
   *CtryCode "964"
   *NatTrunkPrf '("0" "0")
   *DateFmt '(@Y "/" @M "/" @D)
   *DayFmt '("دووشەممە" "سێشەممە" "چوارشەممە" "پێنجشەممە" "هەینی" "شەممە" "یەکشەممە")
   *MonFmt '("کانوونی دووەم" "شوبات" "ئازار" "نیسان" "ئایار" "حوزەیران" "تەمموز" "ئاب" "ئەیلوول" "تشرینی یەکەم" "تشرینی دووەم" "کانوونی یەکەم") )
pil21/loc/CN.l0000644000000000000000000000002411757153615010134 0ustar  (load "@loc/NIL.l")
pil21/loc/DE.l0000644000000000000000000000047513137355672010137 0ustar  (setq
   *Sep0 ","
   *Sep3 "."
   *CtryCode "49"
   *NatTrunkPrf '("0")
   *DateFmt '(@D "." @M "." @Y)
   *DayFmt '("Montag" "Dienstag" "Mittwoch" "Donnerstag" "Freitag" "Samstag" "Sonntag")
   *MonFmt '("Januar" "Februar" "März" "April" "Mai" "Juni" "Juli" "August" "September" "Oktober" "November" "Dezember") )
pil21/loc/ES.l0000644000000000000000000000047113137355633010147 0ustar  (setq
   *Sep0 ","
   *Sep3 "."
   *CtryCode "34"
   *NatTrunkPrf NIL
   *DateFmt '(@D "/" @M "/" @Y)
   *DayFmt '("Lunes" "Martes" "Miércoles" "Jueves" "Viernes" "Sábado" "Domingo")
   *MonFmt '("Enero" "Febrero" "Marzo" "Abril" "Mayo" "Junio" "Julio" "Agosto" "Setiembre" "Octubre" "Noviembre" "Diciembre") )
pil21/loc/FR.l0000644000000000000000000000047113137355743010151 0ustar  (setq
   *Sep0 ","
   *Sep3 "."
   *CtryCode "33"
   *NatTrunkPrf '("0")
   *DateFmt '(@D "/" @M "/" @Y)
   *DayFmt '("Lundi" "Mardi" "Mercredi" "Jeudi" "Vendredi" "Samedi" "Dimanche")
   *MonFmt '("Janvier" "Février" "Mars" "Avril" "Mai" "Juin" "Juillet" "Août" "Septembre" "Octobre" "Novembre" "Décembre") )
pil21/loc/GB.l0000644000000000000000000000047413137355575010140 0ustar  (setq
   *Sep0 "."
   *Sep3 ","
   *CtryCode "44"
   *NatTrunkPrf '("0")
   *DateFmt '(@D "/" @M "/" @Y)
   *DayFmt '("Monday" "Tuesday" "Wednesday" "Thursday" "Friday" "Saturday" "Sunday")
   *MonFmt '("January" "February" "March" "April" "May" "June" "July" "August" "September" "October" "November" "December") )
pil21/loc/GR.l0000644000000000000000000000075313137355641010152 0ustar  (setq
   *Sep0 ","
   *Sep3 "."
   *CtryCode "30"
   *NatTrunkPrf NIL
   *DateFmt '(@D "/" @M "/" @Y)
   *DayFmt '("Δευτέρα" "Τρίτη" "Τετάρτη" "Πέμπτη" "Παρασκευή" "Σάββατο" "Κυριακή")
   *MonFmt '("Ιανουάριος" "Φεβρουάριος" "Μάρτιος" "Απρίλιος" "Μάϊος" "Ιούνιος" "Ιούλιος" "Αύγουστος" "Σεπτέμβριος" "Οκρώβριος" "Νοέμβριος" "Δεκέμβριος") )
pil21/loc/HR.l0000644000000000000000000000002411757153615010145 0ustar  (load "@loc/NIL.l")
pil21/loc/IT.l0000644000000000000000000000002411757153615010150 0ustar  (load "@loc/NIL.l")
pil21/loc/JP.l0000644000000000000000000000051513137355620010144 0ustar  (setq
   *Sep0 "."
   *Sep3 ","
   *CtryCode "81"
   *NatTrunkPrf '("0")
   *DateFmt '(@Y "/" @M "/" @D)
   *DayFmt '("月曜日" "火曜日" "水曜日" "木曜日" "金曜日" "土曜日" "日曜日")
   *MonFmt '("一月" "二月" "三月" "四月" "五月" "六月" "七月" "八月" "九月" "十月" "十一月" "十二月") )
pil21/loc/NIL.l0000644000000000000000000000051213137351564010255 0ustar  (setq  # Default locale
   *Sep0 "."
   *Sep3 ","
   *CtryCode NIL
   *NatTrunkPrf NIL
   *DateFmt '(@Y "-" @M "-" @D)
   *DayFmt '("Monday" "Tuesday" "Wednesday" "Thursday" "Friday" "Saturday" "Sunday")
   *MonFmt '("January" "February" "March" "April" "May" "June" "July" "August" "September" "October" "November" "December") )
pil21/loc/NO.l0000644000000000000000000000046213137355715010155 0ustar  (setq
   *Sep0 ","
   *Sep3 "."
   *CtryCode "47"
   *NatTrunkPrf NIL
   *DateFmt '(@D "." @M "." @Y)
   *DayFmt '("mandag" "tirsdag" "onsdag" "torsdag" "fredag" "lørdag" "søndag")
   *MonFmt '("januar" "februar" "mars" "april" "mai" "juni" "juli" "august" "september" "oktober" "november" "desember") )
pil21/loc/RU.l0000644000000000000000000000066714024317314010163 0ustar  (setq
   *Sep0 ","
   *Sep3 " "
   *CtryCode "7"
   *NatTrunkPrf '("8")
   *DateFmt '(@D "." @M "." @Y)
   *DayFmt '("Понедельник" "Вторник" "Среда" "Четверг" "Пятница" "Суббота" "Воскресенье")
   *MonFmt '("Январь" "Февраль" "Март" "Апрель" "Май" "Июнь" "Июль" "Август" "Сентябрь" "Октябрь" "Ноябрь" "Декабрь") )
pil21/loc/SE.l0000644000000000000000000000047013137355647010153 0ustar  (setq
   *Sep0 ","
   *Sep3 " "
   *CtryCode "46"
   *NatTrunkPrf '("0")
   *DateFmt '(@D "." @M "." @Y)
   *DayFmt '("Måndag" "Tisdag" "Onsdag" "Torsdag" "Fredag" "Lördag" "Söndag")
   *MonFmt '("Januari" "Februari" "Mars" "April" "Maj" "juni" "Juli" "Augusti" "September" "Oktober" "November" "December") )
pil21/loc/TR.l0000644000000000000000000000002411757153615010161 0ustar  (load "@loc/NIL.l")
pil21/loc/UA.l0000644000000000000000000000071414021204474010132 0ustar  (setq
   *Sep0 ","
   *Sep3 " "
   *CtryCode "380"
   *NatTrunkPrf '("0")
   *DateFmt '(@D "." @M "." @Y)
   *DayFmt '("Понеділок" "Вівторок" "Середа" "Четвер" "П’ятниця" "Субота" "Неділя")
   *MonFmt '("Січень" "Лютий" "Березень" "Квітень" "Травень" "Червень" "Липень" "Серпень" "Вересень" "Жовтень" "Листопад" "Грудень") )
pil21/loc/UK.l0000777000000000000000000000000014022146610010602 2GB.lustar  pil21/loc/US.l0000644000000000000000000000047313137355660010171 0ustar  (setq
   *Sep0 "."
   *Sep3 ","
   *CtryCode "1"
   *NatTrunkPrf '("1")
   *DateFmt '(@M "/" @D "/" @Y)
   *DayFmt '("Monday" "Tuesday" "Wednesday" "Thursday" "Friday" "Saturday" "Sunday")
   *MonFmt '("January" "February" "March" "April" "May" "June" "July" "August" "September" "October" "November" "December") )
pil21/loc/ar0000644000000000000000000000006614146652776010021 0ustar  # 22nov21 Software Lab. Alexander Burger

T "@loc/es"
pil21/loc/ca0000644000000000000000000000564313151027476007774 0ustar  # 28aug17abu
# Arnau Figueras

"Language" "Idioma"

# lib/db.l
"Boolean input expected" "S'espera l'ingrés de dades tipus booleà"
"Numeric input expected" "S'espera l'ingrés de dades tipus numèric"
"Symbolic type expected" "Se esperan datos del tipo simbólico"
"String type expected" "S'esperen dades del tipus simbòlic"
"Type error" "Error de teclejat"
"Not unique" "No únic"
"Input required" "Es requereix ingrés de dades"

# lib/form.l
"Cancel" "Cancel·lar"
"Yes" "Sí"
"No" "No"
"Select" "Seleccionar"
"Delete row?" "¿Borrar fila?"
"Show" "Mostrar"
"Bad date format" "El format de la data no és vàlid"
"Bad time format" "El format de l’hora no és vàlid"
"Bad phone number format" "El format del número de telèfon no és vàlid"
"male" "home"
"female" "dona"
"New" "nou"
"Edit" "Editar"
"Save" "Guardar"
"Done" "Acabar"
"Currently edited by '@2' (@1)" "Actualmente editat per '@2' (@1)"
"Search" "Buscar"
"Reset" "Buidar/Netejar"
"New/Copy" "Nou/Copiar"
"Restore" "Restaurar"
"Restore @1?" "¿Restaurar @1?"
"Delete" "Esborrar"
"Delete @1?" "¿Esborrar @1?"
"Data not found" "No s’han trobat dades"
"Undo" "Desfer"
"Undo: '@1'" "Desfer: '@1'"
"Redo" "Rehacer"
"Redo: '@1'" "Desfer: '@1'"

# General
"login" "Entrar al sistema"
"logout" "Sortir del sistema"
"' logged in" "' ha ingressat al sistema"
"Name" "Nom"
"Login Name" "Nom d’usuari"
"Full Name" "Nom complet"
"Password" "Contrasenya"
"Permission denied" "Permís denegat"
"Permissions" "Permisos"
"Role" "Rol"
"Role Administration" "Administració de rols"
"Roles" "Rols"
"User" "Usuari"
"User Administration" "Administració d’usuaris"
"Users" "Usuaris"
"Settings" "Configuració"
"Phone" "Telèfon"

# Tooltips
"Open submenu" "Obrir submenú"
"Close submenu" "Tancar submenú"
"Next object of the same type" "Següent objecte del mateix tipus"
"Find or create an object of the same type" "Buscar o crear objecte del mateix tipus"
"Choose a suitable value" "Tria un valor adequat"
"Adopt this value" "Selecciona aquest valor"
"Go to first line" "Anar a la primera línia"
"Scroll up one page" "Pujar una pàgina"
"Scroll up one line" "Pujar una línia"
"Scroll down one line" "Baixar una línia"
"Scroll down one page" "Baixar una pàgina"
"Go to last line" "Anar a l’última línia"
"Insert empty row" "Insertar línia buida"
"Delete row" "Esborrar línia"
"Shift row up" "Moure línia amunt"
"Clear all input fields" "Esborrar tots els camps"
"Release exclusive write access for this object" "Alliberar accés exclusiu d’escriptura per a aquest objecte"
"Gain exclusive write access for this object" "Reclamar accés exclusiu d’escriptura per a aquest objecte"
"Start search" "Inicia la cerca"
"Create new object" "Crear nou objecte"
"Create a new copy of this object" "Crear nova còpia d'aquest objecte"
"Mark this object as \"not deleted\"" "Marcar aquest objecte com \"no esborrat\""
"Mark this object as \"deleted\"" "Marcar aquest objecte com \"esborrat\""
"Update" "Actualitzar"
pil21/loc/ch0000644000000000000000000000006614146652733010002 0ustar  # 22nov21 Software Lab. Alexander Burger

T "@loc/de"
pil21/loc/ckb0000644000000000000000000000753314167225662010155 0ustar  # 10jan22
# Hunar Omar 

"Language" "زمان"

# lib/db.l
"Boolean input expected" "چاوەڕوانی تێچەی ڕاست یان هەڵە کرا"
"Numeric input expected" "چاوەڕوانی تێچەی ژمارەیی کرا"
"Symbolic type expected" "چاوەڕوانی تێچەی هێمایی کرا"
"String type expected" "چاوەڕوانی جۆرێکی نووسینی کرا"
"Type error" "هەڵە لە جۆردا"
"Not unique" "بێهاوتا نییە"
"Input required" "تێچەیەک پێویستە"

# lib/form.l
"Cancel" "وازهێنان"
"Yes" "بەڵێ"
"No" "نەخێر"
"Select" "دیاریکردن"
"Delete row?" "ڕیز بسڕدرێتەوە؟"
"Show" "پیشاندان"
"Bad date format" "شێوازی بەروار هەڵەیە"
"Bad time format" "شێوازی کات هەڵەیە"
"Bad phone number format" "شێوازی ژمارەی تەلەفۆن هەڵەیە"
"male" "نێر"
"female" "مێ"
"New" "نوێ"
"Edit" "دەستکاری"
"Save" "هەڵگرتن"
"Done" "تەواو"
"Currently edited by '@2' (@1)" "وا دەستکاری دەکرێت لەلایەن '@2' (@1)"
"Search" "گەڕان"
"Reset" "دامەزراندنەوە"
"New/Copy" "نوێ/لەبەرگرتنەوە"
"Restore" "گەڕاندنەوە"
"Restore @1?" "@1 بگەڕێندرێتەوە؟"
"Delete" "سڕینەوە"
"Delete @1?" "@1 بسڕدرێتەوە؟"
"Data not found" "زانیاری نەدۆزرایەوە"
"Undo" "گەڕانەوە"
"Undo: '@1'" "گەڕانەوە: '@1'"
"Redo" "نەگەڕانەوە"
"Redo: '@1'" "نەگەڕانەوە: '@1'"

# General
"login" "چوونەژوورەوە"
"logout" "چوونەدەرەوە"
"' logged in" "' چووە ژوورەوە"
"Name" "ناو"
"Login Name" "ناوی چوونەژوورەوە"
"Full Name" "ناوی تەواو"
"Password" "تێپەڕەوشە"
"Permission denied" "مۆڵەت ڕەتکرایەوە"
"Permissions" "مۆڵەتەکان"
"Role" "پلە"
"Role Administration" "بەڕێوبەرایەتی پلە"
"Roles" "پلەکان"
"User" "بەکارهێنەر"
"User Administration" "بەڕێوبەرایەتی بەکارهێنەر"
"Users" "بەکارهێنەران"
"Settings" "ڕێکخستن"
"Phone" "تەلەفۆن"

# Tooltips
"Open submenu" "کردنەوەی پێڕستی دووەمی"
"Close submenu" "داخستنی پێڕستی دووەمی"
"Next object of the same type" "تەنی دواتری هەمان جۆر"
"Find or create an object of the same type" "دۆزینەوە یان دروستکردنی تەنێکی نوێ لە هەمان جۆر"
"Choose a suitable value" "نرخێکی گونجاو هەڵبژێرە"
"Adopt this value" "هەڵگرتنەوەی ئەم نرخە"
"Go to first line" "بڕۆ بۆ یەکەم دێڕ"
"Scroll up one page" "پەڕەیەک بۆ سەرەوە"
"Scroll up one line" "دێڕێک بۆ سەرەوە"
"Scroll down one line" "دێڕێک بۆ خوارەوە"
"Scroll down one page" "پەڕەیەک بۆ خوارەوە"
"Go to last line" "ڕۆیشتن بۆ کۆتا دێڕ"
"Insert empty row" "زیادکردنی ڕیزێکی بەتاڵ"
"Delete row" "سڕینەوەی ڕیز"
"Shift row up" "ڕیز ببە بەرەو سەر"
"Clear all input fields" "سڕینەوەی هەموو خانە تێچەکان"
"Release exclusive write access for this object" "لەدەستدانی مافی تایبەتیی نووسین بۆ ئەم تەنە"
"Gain exclusive write access for this object" "دەستکەوتنی مافی تایبەتیی نووسین بۆ ئەم تەنە"
"Start search" "دەستکردن بە گەڕان"
"Create new object" "دروستکردنی تەنێکی نوێ"
"Create a new copy of this object" "درووستکردنی لەبەرگیراوەیەکی نوێ بۆ ئەم تەنە"
"Mark this object as \"not deleted\"" "ئەم تەنە وەک \"نەسڕاوە\" دیاریبکە"
"Mark this object as \"deleted\"" "ئەم تەنە وەک \"سڕاوە\" دیاریبکە"
"Update" "نوێکردنەوە"
pil21/loc/cn0000644000000000000000000000005214146653020007771 0ustar  # 22nov21 Software Lab. Alexander Burger

pil21/loc/de0000644000000000000000000000564714146652663010014 0ustar  # 22nov21 Software Lab. Alexander Burger

"Language" "Sprache"

# lib/db.l
"Boolean input expected" "Boolean-Type erwartet"
"Numeric input expected" "Zahleneingabe erforderlich"
"Symbolic type expected" "Symbol-Type erwartet"
"String type expected" "String-Type erwartet"
"Type error" "Typ-Fehler"
"Not unique" "Nicht eindeutig"
"Input required" "Eingabe erforderlich"

# lib/form.l
"Cancel" "Abbruch"
"Yes" "Ja"
"No" "Nein"
"Select" "Auswahl"
"Delete row?" "Zeile löschen?"
"Show" "Anzeigen"
"Bad date format" "Falsches Datums-Format"
"Bad time format" "Falsches Uhrzeit-Format"
"Bad phone number format" "Falsches Telefonnummern-Format"
"male" "männlich"
"female" "weiblich"
"New" "Neu"
"Edit" "Bearbeiten"
"Save" "Speichern"
"Done" "Fertig"
"Currently edited by '@2' (@1)" "Zur Zeit von '@2' (@1) bearbeitet"
"Search" "Suchen"
"Reset" "Zurücksetzen"
"New/Copy" "Neu/Muster"
"Restore" "Wiederherstellen"
"Restore @1?" "@1 wiederherstellen?"
"Delete" "Löschen"
"Delete @1?" "@1 löschen?"
"Data not found" "Daten nicht gefunden"
"Undo" "Rückgängig"
"Undo: '@1'" "Rückgängig: '@1'"
"Redo" "Wiederherstellen"
"Redo: '@1'" "Wiederherstellen: '@1'"

# General
"login" "anmelden"
"logout" "abmelden"
"' logged in" "' ist angemeldet"
"Name" "Name"
"Login Name" "Login-Name"
"Full Name" "Vollständiger Name"
"Password" "Passwort"
"Permission denied" "Keine Berechtigung"
"Permissions" "Berechtigungen"
"Role" "Rolle"
"Role Administration" "Rollenverwaltung"
"Roles" "Rollen"
"User" "Benutzer"
"User Administration" "Benutzerverwaltung"
"Users" "Benutzer"
"Settings" "Einstellungen"
"Phone" "Telefon"

# Tooltips
"Open submenu" "Untermenü öffnen"
"Close submenu" "Untermenü schließen"
"Next object of the same type" "Nächstes Objekt vom gleichen Typ"
"Find or create an object of the same type" "Ein Objekt vom gleichen Typ suchen oder neu anlegen"
"Choose a suitable value" "Einen passenden Wert auswählen"
"Adopt this value" "Diesen Wert übernehmen"
"Go to first line" "Zur ersten Zeile gehen"
"Scroll up one page" "Eine Seite nach oben scrollen"
"Scroll up one line" "Eine Zeile nach oben scrollen"
"Scroll down one line" "Eine Zeile nach unten scrollen"
"Scroll down one page" "Eine Seite nach unten scrollen"
"Go to last line" "Zur letzten Zeile gehen"
"Insert empty row" "Leerzeile einfügen"
"Delete row" "Zeile löschen"
"Shift row up" "Zeile nach oben schieben"
"Clear all input fields" "Alle Eingabefelder löschen"
"Release exclusive write access for this object" "Exklusiven Schreibzugriff auf dieses Objekt freigeben"
"Gain exclusive write access for this object" "Exklusiven Schreibzugriff auf dieses Objekt erhalten"
"Start search" "Suche starten"
"Create new object" "Neues Objekt anlegen"
"Create a new copy of this object" "Eine neue Kopie dieses Objektes anlegen"
"Mark this object as \"not deleted\"" "Dieses Objekt als \"nicht gelöscht\" markieren"
"Mark this object as \"deleted\"" "Dieses Objekt als \"gelöscht\" markieren"
"Update" "Aktualisieren"
pil21/loc/el0000644000000000000000000001017713151030351007771 0ustar  # 23aug2016
# Drakopoulos A. 

"Language" "Γλώσσα"

# lib/db.l
"Boolean input expected" "Αναμένονται δεδομένα λογικού τύπου"
"Numeric input expected" "Αναμένονται δεδομένα αριθμητικού τύπου"
"Symbolic type expected" "Αναμένονται δεδομένα συμβολικού τύπου"
"String type expected" "Αναμένονται δεδομένα αλφαριθμητικού τύπου"
"Type error" "Σφάλμα τύπου"
"Not unique" "Δεν είναι μοναδικό"
"Input required" "Απαιτείται είσοδος δεδομένων"

# lib/form.l
"Cancel" "Άκυρο"
"Yes" "Ναί"
"No" "Όχι"
"Select" "Επιλέξτε"
"Delete row?" "Διαγραφή σειράς;"
"Show" "Εμφάνισε"
"Bad date format" "Η μορφοποίηση τής ημερομηνίας δεν είναι έγκυρη"
"Bad time format" "Η μορφοποίηση τής ώρας δεν είναι έγκυρη"
"Bad phone number format" "Η μορφοποίηση τού αριθμού τηλεφώνου δεν είναι έγκυρη"
"male" "άντρας"
"female" "γυναίκα"
"New" "Νέο"
"Edit" "Διόρθωση"
"Save" "Αποθήκευση"
"Done" "Τερματισμός"
"Currently edited by '@2' (@1)" "Πρόσφατα διορθωμένο από '@2' (@1)"
"Search" "Αναζήτηση"
"Reset" "Καθάρισε"
"New/Copy" "Νέο/Αντιγραφή"
"Restore" "Επαναφορά"
"Restore @1?" "Επανάφερε @1?"
"Delete" "Διαγραφή"
"Delete @1?" "Διαγραφή @1?"
"Data not found" "Δεν βρέθηκαν δεδομένα"

# General
"login" "Είσοδος στο σύστημα"
"logout" "Έξοδος από το σύστημα"
"' logged in" "' είσοδος στο σύστημα"
"Name" "Όνομα"
"Password" "Συνθηματικό"
"Permission denied" "Άδεια απορρίφθηκε"
"Permissions" "Άδειες"
"Role" "Ρόλος"
"Roles" "Ρόλοι"
"User" "Χρήστης"
"Users" "Χρήστες"
"Settings" "Ρυθμίσεις"

# Tooltips
"Open submenu" "Άνοιξε υπομενού"
"Close submenu" "Κλείσε υπομενού"
"Next object of the same type" "Επόμενο αντικείμενο τού ίδιου τύπου"
"Find or create an object of the same type" "Βρές ή δημιούργησε ένα αντικείμενο τού ίδιου τύπου"
"Choose a suitable value" "Διάλεξε μια κατάλληλη τιμή"
"Adopt this value" "Αποδέξου αυτή την τιμή"
"Go to first line" "Πήγαινε στην πρώτη γραμμή"
"Scroll up one page" "Πήγαινε πρός τα πάνω μια σελίδα"
"Scroll up one line" "Πήγαινε προς τα πάνω μια γραμμή"
"Scroll down one line" "Πήγαινε προς τα κάτω μια γραμμή"
"Scroll down one page" "Πήγαινε προς τα κάτω μια σελίδα"
"Go to last line" "Πήγαινε στην τελευταία γραμμή"
"Insert empty row" "Τοποθέτησε κενή γραμμή"
"Delete row" "Διάγραψε γραμμή"
"Shift row up" "Μετακίνησε γραμμή προς τα πάνω"
"Clear all input fields" "Καθάρισε όλα τα πεδία εισαγωγής"
"Release exclusive write access for this object" "Απελευθέρωσε την αποκλειστική πρόσβαση εγγραφής για αυτό το αντικείμενο"
"Gain exclusive write access for this object" "Απόκτησε αποκλειστική πρόσβαση εγγραφής για αυτό το αντικείμενο"
"Start search" "Ξεκίνα αναζήτηση"
"Create new object" "Δημιούργησε νέο αντικείμενο"
"Create a new copy of this object" "Δημιούργησε νέο αντίγραφο αυτού τού αντικειμένου"
"Mark this object as \"not deleted\"" "Σημάδεψε αυτό το αντικείμενο σαν \"μη διεγραμμένο\""
"Mark this object as \"deleted\"" "Σημάδεψε αυτό το αντικείμενο σαν \"διεγραμμένο\""
"Update" "Ενημέρωσε"
pil21/loc/es0000644000000000000000000000572013151027200007775 0ustar  # 28aug17abu
# Armadillo 
# Manuel Cano 

"Language" "Idioma"

# lib/db.l
"Boolean input expected" "Se espera el ingreso de datos tipo buliano"
"Numeric input expected" "Se espera el ingreso de datos tipo numérico"
"Symbolic type expected" "Se esperan datos del tipo simbólico"
"String type expected" "Se esperan datos del tipo String"
"Type error" "Error de tipado"
"Not unique" "No único"
"Input required" "Se require ingreso de datos"

# lib/form.l
"Cancel" "Cancelar"
"Yes" "Sí"
"No" "No"
"Select" "Seleccionar"
"Delete row?" "¿Borrar fila?"
"Show" "Mostrar"
"Bad date format" "El formato de la fecha no es válido"
"Bad time format" "El formato de la hora no es válido"
"Bad phone number format" "El formato del número telefónico no es válido"
"male" "hombre"
"female" "mujer"
"New" "Nuevo"
"Edit" "Editar"
"Save" "Guardar"
"Done" "Terminar"
"Currently edited by '@2' (@1)" "Actualmente editado por '@2' (@1)"
"Search" "Buscar"
"Reset" "Vaciar/Limpiar"
"New/Copy" "Nuevo/Copiar"
"Restore" "Restaurar"
"Restore @1?" "¿Restaurar @1?"
"Delete" "Borrar"
"Delete @1?" "¿Borrar @1?"
"Data not found" "No se encontraron datos"
"Undo" "Deshacer"
"Undo: '@1'" "Deshacer: '@1'"
"Redo" "Rehacer"
"Redo: '@1'" "Rehacer: '@1'"

# General
"login" "Ingresar al Sistema"
"logout" "Salir del Sistema"
"' logged in" "' ingresó al sistema"
"Name" "Nombre"
"Login Name" "Nombre de usuario"
"Full Name" "Nombre Completo"
"Password" "Contraseña"
"Permission denied" "Permiso denegado"
"Permissions" "Permisos"
"Role" "Rol"
"Role Administration" "Administración de roles"
"Roles" "Roles"
"User" "Usuario"
"User Administration" "Administración de usuarios"
"Users" "Usuarios"
"Settings" "Configuración"
"Phone" "Teléfono"

# Tooltips
"Open submenu" "Abrir submenu"
"Close submenu" "Cerrar submenu"
"Next object of the same type" "Siguiente objeto del mismo tipo"
"Find or create an object of the same type" "Buscar o crear objeto del mismo tipo"
"Choose a suitable value" "Elija un valor adecuado"
"Adopt this value" "Seleccione este valor"
"Go to first line" "Ir a la primera línea"
"Scroll up one page" "Subir una página"
"Scroll up one line" "Subir una línea"
"Scroll down one line" "Bajar una línea"
"Scroll down one page" "Bajar una página"
"Go to last line" "Ir a la última línea"
"Insert empty row" "Insertar línea vacia"
"Delete row" "Borrar línea"
"Shift row up" "Mover línea arriba"
"Clear all input fields" "Borrar todos los campos"
"Release exclusive write access for this object" "Liberar acceso exclusido en escritura para este objeto"
"Gain exclusive write access for this object" "Reclamar acceso exclusivo en escritura para este objeto"
"Start search" "Iniciar búsqueda"
"Create new object" "Crear nuevo objeto"
"Create a new copy of this object" "Crear nueva copia de este objeto"
"Mark this object as \"not deleted\"" "Marcar este objeto como \"no borrado\""
"Mark this object as \"deleted\"" "Marcar este objeto como \"borrado\""
"Update" "Actualizar"
pil21/loc/fr0000644000000000000000000000572513151030321010000 0ustar  # 28aug17abu
# Raman Gopalan 

"Language" "Langue"

# lib/db.l
"Boolean input expected" "Type booléen attendu"
"Numeric input expected" "Type numérique attendu"
"Symbolic type expected" "Type symbole attendu"
"String type expected" "Type chaîne de caractères attendu"
"Type error" "Erreur de type"
"Not unique" "Non unique"
"Input required" "Saisie requise"

# lib/form.l
"Cancel" "Annuler"
"Yes" "Oui"
"No" "Non"
"Select" "Sélectionner"
"Delete row?" "Supprimer la ligne?"
"Show" "Montrer"
"Bad date format" "Mauvais format de date"
"Bad time format" "Mauvais format d'heure"
"Bad phone number format" "Mauvais format de numéro de téléphone"
"male" "mâle"
"female" "femelle"
"New" "Nouveau"
"Edit" "Modifier"
"Save" "Enregistrer"
"Done" "Terminé"
"Currently edited by '@2' (@1)" "Actuellement modifié par '@2' (@1)"
"Search" "Chercher"
"Reset" "Réinitialiser"
"New/Copy" "Nouveau/Copie"
"Restore" "Restaurer"
"Restore @1?" "Restaurer @1?"
"Delete" "Supprimer"
"Delete @1?" "Supprimer @1?"
"Data not found" "Données introuvables"
"Undo" "Annuler"
"Undo: '@1'" "Annuler: '@1'"
"Redo" "Refaire"
"Redo: '@1'" "Refaire: '@1'"

# General
"login" "se connecter"
"logout" "se déconnecter"
"' logged in" "' connecté"
"Name" "Nom"
"Login Name" "Identifiant"
"Full Name" "Nom complet"
"Password" "Mot de passe"
"Permission denied" "Permission refusée"
"Permissions" "Autorisations"
"Role" "Rôle"
"Role Administration" "Gestion des rôles"
"Roles" "Rôles"
"User" "Utilisateur"
"User Administration" "Gestion des utilisateurs"
"Users" "Utilisateurs"
"Settings" "Paramètres"
"Phone" "Téléphone"

# Tooltips
"Open submenu" "Ouvrir le sous-menu"
"Close submenu" "Fermer le sous-menu"
"Next object of the same type" "Objet suivant du même type"
"Find or create an object of the same type" "Trouver ou créer un objet du même type"
"Choose a suitable value" "Choisissez une valeur appropriée"
"Adopt this value" "Adopter cette valeur"
"Go to first line" "Aller à la première ligne"
"Scroll up one page" "Défiler d'une page vers le haut"
"Scroll up one line" "Défiler d'une ligne vers le haut"
"Scroll down one line" "Défiler d'une ligne vers le bas"
"Scroll down one page" "Défiler d'une page vers le bas"
"Go to last line" "Aller à la dernière ligne"
"Insert empty row" "Insérer une ligne vide"
"Delete row" "Supprimer la ligne"
"Shift row up" "Déplacer la ligne vers le haut"
"Clear all input fields" "Effacer tous les champs de saisie"
"Release exclusive write access for this object" "Libérer l'accès en écriture exclusif pour cet objet"
"Gain exclusive write access for this object" "Obtenir un accès en écriture exclusif pour cet objet"
"Start search" "Lancer la recherche"
"Create new object" "Créer un nouvel objet"
"Create a new copy of this object" "Créer une nouvelle copie de cet objet"
"Mark this object as \"not deleted\"" "Marquer cet objet comme \"non supprimé\""
"Mark this object as \"deleted\"" "Marquer cet objet comme \"supprimé\""
"Update" "Mettre à jour"
pil21/loc/gr0000777000000000000000000000000014022147246010325 2elustar  pil21/loc/hr0000644000000000000000000000005214146652642010013 0ustar  # 22nov21 Software Lab. Alexander Burger

pil21/loc/it0000644000000000000000000000005214146652753010021 0ustar  # 22nov21 Software Lab. Alexander Burger

pil21/loc/ja0000644000000000000000000000577214146652711010007 0ustar  # 22nov21 Software Lab. Alexander Burger

"Language" "言語"

# lib/db.l
"Boolean input expected" "Booleanタイプが必要"
"Numeric input expected" "数値入力が必要"
"Symbolic type expected" "Symbolicタイプが必要"
"String type expected" "Stringタイプが必要"
"Type error" "タイプエラー"
"Not unique" "重複"
"Input required" "入力が必要"

# lib/form.l
"Cancel" "キャンセル"
"Yes" "はい"
"No" "いいえ"
"Select" "選択"
"Delete row?" "行を消しますか？"
"Show" "表示"
"Bad date format" "日付が違います"
"Bad time format" "時刻が違います"
"Bad phone number format" "電話番号が違います"
"male" "男性"
"female" "女性"
"New" "作成"
"Edit" "編集"
"Save" "保存"
"Done" "終了"
"Currently edited by '@2' (@1)" "現在'@2'(@1)が編集中です"
"Search" "検索"
"Reset" "リセット"
"New/Copy" "作成/コピー"
"Restore" "もとへ戻す"
"Restore @1?" "@1もとへ戻しますか？"
"Delete" "消去"
"Delete @1?" "@1を消しますか？"
"Data not found" "データが見つかりません"
"Undo" "元に戻す"
"Undo: '@1'" "元に戻す: '@1'"
"Redo" "やり直す"
"Redo: '@1'" "やり直す: '@1'"

# General
"login" "ログイン"
"logout" "ログアウト"
"' logged in" "' ログインしました"
"Name" "名前"
"Login Name" "ログイン名"
"Full Name" "フルネーム"
"Password" "パスワード"
"Permission denied" "認証できません"
"Permissions" "許可"
"Role" "役割"
"Role Administration" "役割管理"
"Roles" "役割"
"User" "ユーザー"
"User Administration" "ユーザー管理"
"Users" "ユーザー"
"Settings" "設定"
"Phone" "電話番号"

# Tooltips
"Open submenu" "サブメニューを開く"
"Close submenu" "サブメニューを閉じる"
"Next object of the same type" "次の同じタイプへ"
"Find or create an object of the same type" "同じタイプを探す/新規"
"Choose a suitable value" "適したバリューを選ぶ"
"Adopt this value" "このバリューを採用する"
"Go to first line" "最初の列にいく"
"Scroll up one page" "一ページ上へスクロール"
"Scroll up one line" "一行上へスクロール"
"Scroll down one line" "一行下へスクロール"
"Scroll down one page" "一ページ下へスクロール"
"Go to last line" "最後の列にいく"
"Insert empty row" "空の行挿入"
"Delete row" "行を消す"
"Shift row up" "行を上へ移す"
"Clear all input fields" "全ての入力フィールドを消す"
"Release exclusive write access for this object" "Release exclusive write access for this object"
"Gain exclusive write access for this object" "Gain exclusive write access for this object"
"Start search" "検索スタート"
"Create new object" "オブジェクトを新規"
"Create a new copy of this object" "このオブジェクトを新しくコピーする"
"Mark this object as \"not deleted\"" "このオブジェクトを消さない状態にする"
"Mark this object as \"deleted\"" "このオブジェクトを消された状態にする"
"Update" "更新"
pil21/loc/jp0000777000000000000000000000000014022147255010320 2jaustar  pil21/loc/no0000644000000000000000000000531613151030433010005 0ustar  # 28aug17abu
# Jon Kleiser 

"Language" "Språk"

# lib/db.l
"Boolean input expected" "Boolsk verdi forventet"
"Numeric input expected" "Numerisk verdi forventet"
"Symbolic type expected" "Symbol-type forventet"
"String type expected" "Tekststreng forventet"
"Type error" "Type-feil"
"Not unique" "Ikke unik"
"Input required" "Input-data påkrevet"

# lib/form.l
"Cancel" "Avbryt"
"Yes" "Ja"
"No" "Nei"
"Select" "Velg"
"Delete row?" "Slett rad?"
"Show" "Vis"
"Bad date format" "Ugyldig datoformat"
"Bad time format" "Ugyldig tidsformat"
"Bad phone number format" "Ugyldig telefonnummer-format"
"male" "mannlig"
"female" "kvinnelig"
"New" "Ny"
"Edit" "Rediger"
"Save" "Lagre"
"Done" "Ferdig"
"Currently edited by '@2' (@1)" "Redigeres nå av '@2' (@1)"
"Search" "Søk"
"Reset" "Tilbakestill"
"New/Copy" "Ny/Kopi"
"Restore" "Gjenopprett"
"Restore @1?" "Gjenopprette @1?"
"Delete" "Slett"
"Delete @1?" "Slett @1?"
"Data not found" "Data ble ikke funnet"
"Undo" "Angre"
"Undo: '@1'" "Angre: '@1'"
"Redo" "Utfør likevel"
"Redo: '@1'" "Utfør likevel: '@1'"

# General
"login" "logg inn"
"logout" "logg ut"
"' logged in" "' er innlogget"
"Name" "Navn"
"Login Name" "Innloggingsnavn"
"Full Name" "Fullt navn"
"Password" "Passord"
"Permission denied" "Ingen adgangsrett"
"Permissions" "Adgangsrettigheter"
"Role" "Rolle"
"Role Administration" "Rolle-administrasjon"
"Roles" "Roller"
"User" "Bruker"
"User Administration" "Bruker-administrasjon"
"Users" "Brukere"
"Settings" "Innstillinger"
"Phone" "Telefon"

# Tooltips
"Open submenu" "Åpne undermeny"
"Close submenu" "Lukk undermeny"
"Next object of the same type" "Neste objekt av samme type"
"Find or create an object of the same type" "Finn eller opprett et objekt av samme type"
"Choose a suitable value" "Velg en passende verdi"
"Adopt this value" "Overta denne verdien"
"Go to first line" "Gå til første linje"
"Scroll up one page" "Scroll opp en side"
"Scroll up one line" "Scroll opp en linje"
"Scroll down one line" "Scroll ned en linje"
"Scroll down one page" "Scroll ned en side"
"Go to last line" "Gå til siste linje"
"Insert empty row" "Sett inn tom rad"
"Delete row" "Slett rad"
"Shift row up" "Forskyv en rad opp"
"Clear all input fields" "Slett alle input-felter"
"Release exclusive write access for this object" "Frigi eksklusiv skrivetilgang til dette objektet"
"Gain exclusive write access for this object" "Innhent eksklusiv skrivetilgang til dette objektet"
"Start search" "Start søk"
"Create new object" "Opprett nytt objekt"
"Create a new copy of this object" "Opprett ny kopi av dette objektet"
"Mark this object as \"not deleted\"" "Merk dette objektet som \"ikke slettet\""
"Mark this object as \"deleted\"" "Merk dette objektet som \"slettet\""
"Update" "Oppdater"
pil21/loc/ru0000644000000000000000000001011114024317461010015 0ustar  # 17mar21abu
# Mansur Mamkin 
# Mike Pechkin 
# Constantine Bytensky 

"Language" "Язык"

# lib/db.l
"Boolean input expected" "Ожидается булев тип"
"Numeric input expected" "Ожидается числовой тип"
"Symbolic type expected" "Ожидается символьный тип"
"String type expected" "Ожидается строковый тип"
"Type error" "Ошибка типа"
"Not unique" "Не уникальный"
"Input required" "Требуется ввод"

# lib/form.l
"Cancel" "Отменить"
"Yes" "Да"
"No" "Нет"
"Select" "Выбрать"
"Delete row?" "Удалить строку?"
"Show" "Показать"
"Bad date format" "Некорректный формат даты"
"Bad time format" "Некорректный формат времени"
"Bad phone number format" "Некорректный формат номера телефона"
"male" "мужской"
"female" "женский"
"New" "Новый"
"Edit" "Редактировать"
"Save" "Сохранить"
"Done" "Готово"
"Currently edited by '@2' (@1)" "Редактируется пользователем «@2» (@1)"
"Search" "Искать"
"Reset" "Сбросить"
"New/Copy" "Новый/копировать"
"Restore" "Восстановить"
"Restore @1?" "Восстановить @1?"
"Delete" "Удалить"
"Delete @1?" "Удалить @1?"
"Data not found" "Данные не найдены"
"Undo" "Отменить"
"Undo: '@1'" "Отменить: «@1»"
"Redo" "Повторить"
"Redo: '@1'" "Повторить: «@1»"

# General
"login" "Войти"
"logout" "Выйти"
"' logged in" "' вошёл"
"Name" "Имя"
"Login Name" "Имя пользователя"
"Full Name" "Полное имя"
"Password" "Пароль"
"Permission denied" "В доступе отказано"
"Permissions" "Права доступа"
"Role" "Роль"
"Role Administration" "Управление ролями"
"Roles" "Роли"
"User" "Пользователь"
"User Administration" "Управление пользователями"
"Users" "Пользователи"
"Settings" "Настройки"
"Phone" "Телефон"

# Tooltips
"Open submenu" "Открыть подменю"
"Close submenu" "Закрыть подменю"
"Next object of the same type" "Следующий объект того же типа"
"Find or create an object of the same type" "Найти или создать объект того же типа"
"Choose a suitable value" "Выберите подходящее значение"
"Adopt this value" "Принять это значение"
"Go to first line" "Перейти к первой строке"
"Scroll up one page" "Прокрутить вверх на одну страницу"
"Scroll up one line" "Прокрутить вверх на одну строку"
"Scroll down one line" "Прокрутить вниз на одну строку"
"Scroll down one page" "Прокрутить вниз на одну страницу"
"Go to last line" "Перейти к последней строке"
"Insert empty row" "Вставить пустую строку"
"Delete row" "Удалить строку"
"Shift row up" "Сдвинуть строку вверх"
"Clear all input fields" "Очистить все поля ввода"
"Release exclusive write access for this object" "Освободить эксклюзивный доступ на запись этого объекта"
"Gain exclusive write access for this object" "Получить эксклюзивный доступ на запись этого объекта"
"Start search" "Начать поиск"
"Create new object" "Создать новый объект"
"Create a new copy of this object" "Создать новую копию этого объекта"
"Mark this object as \"not deleted\"" "Отметить этот объект как «не удалённый»"
"Mark this object as \"deleted\"" "Отметить этот объект как «удалённый»"
"Update" "Обновить"
pil21/loc/sv0000644000000000000000000000522213151030532010015 0ustar  # 28aug17abu
# Mattias Sundblad 

"Language" "Språk"

# lib/db.l
"Boolean input expected" "Boolskt värde förväntades"
"Numeric input expected" "Numeriskt värde förväntades"
"Symbolic type expected" "Symbol-typ förväntades"
"String type expected" "Sträng förväntades"
"Type error" "Felaktig typ"
"Not unique" "Ej unikt värde"
"Input required" "Obligatoriskt värde"

# lib/form.l
"Cancel" "Avbryt"
"Yes" "Ja"
"No" "Nej"
"Select" "Välj"
"Delete row?" "Radera rad?"
"Show" "Visa"
"Bad date format" "Ogiltigt datumformat"
"Bad time format" "Ogiltigt tidsformat"
"Bad phone number format" "Ogiltigt telefonnummerformat"
"male" "Man"
"female" "Kvinna"
"New" "Ny"
"Edit" "Redigera"
"Save" "Spara"
"Done" "Klar"
"Currently edited by '@2' (@1)" "Redigeras nu av '@2' (@1)"
"Search" "Sök"
"Reset" "Återställ"
"New/Copy" "Ny/Kopiera"
"Restore" "Återställ"
"Restore @1?" "Återställ @1?"
"Delete" "Radera"
"Delete @1?" "Radera @1?"
"Data not found" "Ingen data hittades"
"Undo" "Ångra"
"Undo: '@1'" "Ångra: '@1'"
"Redo" "Upprepa"
"Redo: '@1'" "Upprepa: '@1'"

# General
"login" "Logga in"
"logout" "Logga ut"
"' logged in" "' är inloggad"
"Name" "Namn"
"Login Name" "Användarnamn"
"Full Name" "För- och efternamn"
"Password" "Lösenord"
"Permission denied" "Ej behörig"
"Permissions" "Behörigheter"
"Role" "Roll"
"Role Administration" "Rollhantering"
"Roles" "Roller"
"User" "Användare"
"User Administration" "Användarhantering"
"Users" "Användare"
"Settings" "Inställningar"
"Phone" "Telefon"

# Tooltips
"Open submenu" "Öppna undermeny"
"Close submenu" "Stäng undermeny"
"Next object of the same type" "Nästa objekt av samma typ"
"Find or create an object of the same type" "Hitta eller skapa ett objekt av samma typ"
"Choose a suitable value" "Välj ett värde"
"Adopt this value" "Använd detta värde"
"Go to first line" "Gå till första raden"
"Scroll up one page" "Bläddra en sida framåt"
"Scroll up one line" "Gå upp en rad"
"Scroll down one line" "Gå ner en rad"
"Scroll down one page" "Bläddra en sida bakåt"
"Go to last line" "Gå till sista raden"
"Insert empty row" "Infoga ny rad"
"Delete row" "Radera raden"
"Shift row up" "Flytta raden uppåt"
"Clear all input fields" "Töm alla fält"
"Release exclusive write access for this object" "Släpp lås för detta objekt"
"Gain exclusive write access for this object" "Lås detta objekt"
"Start search" "Sök"
"Create new object" "Skapa nytt objekt"
"Create a new copy of this object" "Skapa en kopia av detta objekt"
"Mark this object as \"not deleted\"" "Markera detta objekt som \"ej raderat\""
"Mark this object as \"deleted\"" "Markera detta objekt som \"raderat\""
"Update" "Uppdatera"
pil21/loc/tr0000644000000000000000000000005214146653047010027 0ustar  # 22nov21 Software Lab. Alexander Burger

pil21/loc/uk0000644000000000000000000001002214024317465010013 0ustar  # 17mar21abu
# Constantine Bytensky 

"Language" "Мова"

# lib/db.l
"Boolean input expected" "Очікується булевий тип"
"Numeric input expected" "Очікується числовий тип"
"Symbolic type expected" "Очікується символьний тип"
"String type expected" "Очікується строковий тип"
"Type error" "Помилка типу"
"Not unique" "Не унікальний"
"Input required" "Потребується введення"

# lib/form.l
"Cancel" "Відмінити"
"Yes" "Так"
"No" "Ні"
"Select" "Вибрати"
"Delete row?" "Видалити строку?"
"Show" "Показати"
"Bad date format" "Неправильний формат дати"
"Bad time format" "Неправильний формат часу"
"Bad phone number format" "Неправильний формат номера телефону"
"male" "чоловіча"
"female" "жіноча"
"New" "Новий"
"Edit" "Редагувати"
"Save" "Зберегти"
"Done" "Готово"
"Currently edited by '@2' (@1)" "Редагується користувачем «@2» (@1)"
"Search" "Шукати"
"Reset" "Скинути"
"New/Copy" "Новий/копіювати"
"Restore" "Відновити"
"Restore @1?" "Відновити @1?"
"Delete" "Видалити"
"Delete @1?" "Видалити @1?"
"Data not found" "Дані не знайдені"
"Undo" "Відмінити"
"Undo: '@1'" "Відмінити: «@1»"
"Redo" "Повторити"
"Redo: '@1'" "Повторити: «@1»"

# General
"login" "Увійти"
"logout" "Вийти"
"' logged in" "' увійшов"
"Name" "Ім’я"
"Login Name" "Ім’я користувача"
"Full Name" "Повне ім’я"
"Password" "Пароль"
"Permission denied" "У доступі відмовлено"
"Permissions" "Права доступу"
"Role" "Роль"
"Role Administration" "Управління ролями"
"Roles" "Ролі"
"User" "Користувач"
"User Administration" "Управління користувачами"
"Users" "Користувачі"
"Settings" "Налаштування"
"Phone" "Телефон"

# Tooltips
"Open submenu" "Відкрити підменю"
"Close submenu" "Закрити підменю"
"Next object of the same type" "Наступний об’ект цього ж типу"
"Find or create an object of the same type" "Знайти або створити об’ект цього ж типу"
"Choose a suitable value" "Оберіть відповідне значення"
"Adopt this value" "Прийняти це значення"
"Go to first line" "Перейти до першого рядка"
"Scroll up one page" "Прокрутити вгору на одну сторінку"
"Scroll up one line" "Прокрутити вгору на один рядок"
"Scroll down one line" "Прокрутити вниз на один рядок"
"Scroll down one page" "Прокрутити вниз на одну сторінку"
"Go to last line" "Перейти до останнього рядка"
"Insert empty row" "Вставити пустий рядок"
"Delete row" "Видалити рядок"
"Shift row up" "Зсунути рядок вгору"
"Clear all input fields" "Очистити усі поля введення"
"Release exclusive write access for this object" "Звільнити ексклюзивний доступ на запис цього об’єкту"
"Gain exclusive write access for this object" "Отримати ексклюзивний доступ на запис цього об’єкту"
"Start search" "Почати пошук"
"Create new object" "Створити новый об’єкт"
"Create a new copy of this object" "Створити нову копію цього об’єкту"
"Mark this object as \"not deleted\"" "Позначити цей об’єкт як «не видаленний»"
"Mark this object as \"deleted\"" "Позначити цей об’єкт як «видаленний»"
"Update" "Оновити"
pil21/misc/bigtest0000755000000000000000000000502514243624173011225 0ustar  #!bin/picolisp lib.l
# 26may22abu
# misc/bigtest 

(load "@lib/misc.l")

(seed (car (argv)))

#  Random patterns:
#  cnt
#     xxx0000000000000000000000000xxxx0000000000000000000000000xxx
#        (| 7 (>> -28 15) (>> -57 7))
#
#     xxx1111111111111111111111111xxxx1111111111111111111111111xxx
#        1FFFFFF0FFFFFF8
#
#
#  dig
#     xxx000000000000000000000000000xxxx000000000000000000000000000xxx
#        (| 7 (>> -30 15) (>> -61 7))
#
#     xxx111111111111111111111111111xxxx111111111111111111111111111xxx
#        1FFFFFFC3FFFFFF8

(de rnd ()
   (let Big (| (rand 0 7) (>> -28 (rand 0 15)) (>> -57 (rand 0 7)))
      (when (rand T)
         (setq Big (| Big `(hex "1FFFFFF0FFFFFF8"))) )
      (do (rand 0 2)
         (let Dig (| (rand 0 7) (>> -30 (rand 0 15)) (>> -61 (rand 0 7)))
            (when (rand T)
               (setq Dig (| Dig `(hex "1FFFFFFC3FFFFFF8"))) )
            (setq Big (| Dig (>> -64 Big))) ) )
      (if (rand T) Big (- Big)) ) )


(de test1 (S N1)
   (let (N (read)  X (eval (list S N1)))
      (unless (= N X)
         (prinl "\n" N ": (" S " " N1 ") -> " X)
         (bye) ) ) )

(de test2 (S N1 N2)
   (let (N (read)  X (eval (list S N1 N2)))
      (unless (= N X)
         (prinl "\n" N ": (" S " " N1 " " N2 ") -> " X)
         (bye) ) ) )

(de cmp2 (S N1 N2)
   (let (N (n0 (read))  X (eval (list S N1 N2)))
      (unless (== N X)
         (prinl "\n" N ": (" S " " N1 " " N2 ") -> " X)
         (bye) ) ) )


(sys "BC_LINE_LENGTH" "200")

(pipe
   (out '("bc")
      (do 10000000
         (setq N1 (rnd))
         (while (=0 (setq N2 (rnd))))
         (prinl N1)
         (prinl N2)
         (prinl N1 " + " N2)
         (prinl N1 " + 1")
         (prinl N1 " + 1")
         (prinl N1 " - " N2)
         (prinl N1 " - 1")
         (prinl N1 " - 1")
         (prinl N1 " * " N2)
         (prinl N1 " * 2")
         (prinl N1 " % " N2)
         (prinl N1 " / " N2)
         (prinl N1 " / 2")
         (prinl N1 " >= " N2)
         (prinl N1 " > " N2)
         (prinl "sqrt(" (abs N1) ")")
         (at (0 . 1000) (wait 100)) ) )
   (do 100
      (do 100000
         (setq
            N1 (read)
            N2 (read) )
         (test2 '+ N1 N2)
         (test2 '+ N1 1)
         (test1 'inc N1)
         (test2 '- N1 N2)
         (test2 '- N1 1)
         (test1 'dec N1)
         (test2 '* N1 N2)
         (test2 '* N1 2)
         (test2 '% N1 N2)
         (test2 '/ N1 N2)
         (test2 '/ N1 2)
         (cmp2 '>= N1 N2)
         (cmp2 '> N1 N2)
         (test1 'sqrt (abs N1)) )
      (prin ".")
      (flush) )
   (prinl) )

(bye)
pil21/misc/stress.l0000644000000000000000000000270013742770550011337 0ustar  # 18oct20 Software Lab. Alexander Burger
# Use: nice pil misc/stress.l -main -go -bye; rm db/test jnl db/test2

(load "@lib/too.l")

(class +A +Entity)
(rel key (+Key +Number))               # Key  1 .. 999
(rel dat (+Ref +Number))               # Data 1 .. 999

(de rnd ()
   (rand 1 999) )

(de modify (N)
   (do N
      (do (rand 10 40)
         (let K (rnd)
            (with (db 'key '+A K)
               (unless (= K (: key))
                  (quit "key mismatch" K) ) ) ) )
      (dbSync)
      (let (D (rnd)  X (db 'key '+A (rnd)))
         (inc *DB (- D (get X 'dat)))
         (put> X 'dat D) )
      (commit 'upd) ) )

(de verify ()
   (dbCheck)
   (let N 0
      (scan (tree 'dat '+A)
         '((K V)
            (unless (= (car K) (get V 'dat))
               (quit "dat mismatch" K) )
            (inc 'N (car K)) ) )
      (unless (= N (val *DB))
         (quit "val mismatch" (- N (val *DB))) ) ) )

(de main ()
   (seed (in "/dev/urandom" (rd 8)))
   (call "mkdir" "-p" "db")
   (call "rm" "-f" "db/test" "jnl" "db/test2")
   (pool "db/test" NIL "jnl")
   (set *DB 0)
   (for K 999
      (let D (rnd)
         (new T '(+A)  'key K  'dat D)
         (inc *DB D) ) )
   (commit) )

(de go ()
   (do 12
      (do 99
         (rand)
         (unless (fork)
            (modify 999)
            (bye) ) )
      (while (kids)
         (wait 999) )
      (rollback) )
   (verify)
   (pool "db/test2")
   (journal "jnl")
   (call "cmp" "db/test" "db/test2") )
pil21/doc/rc.sample0000644000000000000000000000105214717414770011261 0ustar  # 20nov24 Software Lab. Alexander Burger
# Copy to ~/.pil/rc

(history
   (make
      (skip "#")
      (while (line T) (link @))  # Global history
      (while (read) (eval @))  # Initial commands
      (when (info ".pilrc")  # Local history and commands
         (in @@
            (skip "#")
            (while (line T) (link @))
            (while (read) (eval @)) ) ) ) )

# Initial history
(stack)
(gc 1200) (dbCheck)
(show (; *FormLst 1 2))
(vi (; *FormLst 1 2 *Dbg 1 -1))
(show (; *FormLst 1 2 obj))

# Initial commands
(de x ()
   (load "x.l") )
pil21/doc/viprc.sample0000644000000000000000000000445214571645241012004 0ustar  # 05mar24 Software Lab. Alexander Burger
# Copy to ~/.pil/viprc

(map+q "d" ":bd\r")

## If you prefer LEFT and RIGHT to move the cursor:
## (map+ "\e[D" "h")
## (map+ "\e[C" "l")

(cmd "pb1n" (L Lst Cnt)  # Pastebin
   (pipe
      (out '("curl" "-F" "f=@-;" "pb1n.de")
         (mapc prinl (: buffer text)) )
      (prCmd (rdLines)) ) )

(cmd "ix.io" (L Lst Cnt)
   (pipe
      (out '("curl" "-sF" "f:1=<-" "ix.io")
         (mapc prinl (: buffer text)) )
      (prCmd (rdLines)) ) )

(cmd "tabs" (L Lst Cnt)
   (let N (or (format L) 3)
      (=: buffer text
         (mapcar
            '((L)
               (make
                  (for (I . C) L
                     (if (= "\t" C)
                        (loop
                           (link (name " "))
                           (T (=0 (% I N)))
                           (inc 'I) )
                        (link C) ) ) ) )
            (: buffer text) ) ) ) )

(cmd "words" (L Lst Cnt)
   (xchg 'delimNs
      (quote
         ((C)
            (nand C
               (sub? C
                  "0123456789\
                  ABCDEFGHIJKLMNOPQRSTUVWXYZ\
                  _\
                  abcdefghijklmnopqrstuvwxyz" ) ) ) ) )
   (prCmd
      (list (chop (xchg '(" C") '(" Lisp")))) ) )

(de *F7  # Find current definition
   (let L (nth (: buffer text) (: posY))
      (prCmd
         (list
            (loop
               (NIL (setq L (prior L (: buffer text))))
               (T (head '`(chop "(class ") (car L))
                  (car L) )
               (T (head '`(chop "(extend ") (car L))
                  (car L) ) ) ) ) ) )

(de *F8  # Expression size
   (evCmd (size (s-expr))) )

# Timestamp
(local) vipDat

(de vipDat (N)
   (when (<> N (: posY))
      (let (@L (get (: text) N)  @A)
         (and
            (match '(@A " " @L) @L)
            (member @A '(("#") ("/" "/") ("/" "*")))
            (>= 31 (format (cut 2 '@L)) 1)
            (member (pack (cut 3 '@L)) *mon)
            (format (cut 2 '@L))
            (mapc set
               (set (nth (: text) N)
                  (conc
                     @A
                     (list (char 32))
                     (chop (datSym (date)))
                     @L ) )
               1 ) ) ) ) )

(daemon '(save> . +Buffer)
   (or (vipDat 1) (vipDat 2) (vipDat 3)) )

# Local
(and (info ".viprc") (load ".viprc"))
pil21/doc/tut.html0000644000000000000000000010314014516413404011143 0ustar  





PicoLisp Tutorial



abu@software-lab.de


A PicoLisp Tutorial



(c) Software Lab. Alexander Burger


This document demonstrates some aspects of the PicoLisp system in detail and
example. For a general description of the PicoLisp kernel please look at the PicoLisp Reference.


This is not a Lisp tutorial, as it assumes some basic knowledge of
programming, Lisp, and even PicoLisp. Please read these sections before coming
back here: Introduction and The PicoLisp Machine. This tutorial concentrates on the
specificities of PicoLisp, and its differences with other Lisp dialects.


Now let's start



If not stated otherwise, all examples assume that PicoLisp was started from a
global installation (see Installation) from the
shell prompt as


$ pil +
:




It loads the PicoLisp base system and the debugging environment, and waits
for you to enter input lines at the interpreter prompt (:). You can
terminate the interpreter and return to the shell at any time, by either hitting
the Ctrl-D key, or by executing the function (bye).


Input editing is done via the readline(3) library. You will want
to configure it according to your taste via your "~/.inputrc" file. Useful value
for PicoLisp are


set keyseq-timeout 40
set blink-matching-paren on
TAB: menu-complete
C-y: menu-complete-backward



In addition to the above, I (preferring vi-style) do also have


set editing-mode vi
set keymap vi-command
v: ""




Table of content



If you are new to PicoLisp, you might want to read the following sections in
the given order, as some of them assume knowledge about previous ones. Otherwise
just jump anywhere you are interested in.







Browsing



PicoLisp provides some functionality for inspecting pieces of data and code
within the running system.


Basic tools


The really basic tools are of course available and their name alone is enough
to know:
print,
size
...


But you will appreciate some more powerful tools like:

  • match, a predicate which
    compares S-expressions with bindable wildcards when matching,
    • 




Inspect a symbol with show



The most commonly used tool is probably the show function. It takes a symbolic argument,
and shows the symbol's name (if any), followed by its value, and then the
contents of the property list on the following lines (assignment of such things
to a symbol can be done with set,
setq, and put).


: (setq A '(This is the value))  # Set the value of 'A'
-> (This is the value)
: (put 'A 'key1 'val1)           # Store property 'key1'
-> val1
: (put 'A 'key2 'val2)           # and 'key2'
-> val2
: (show 'A)                      # Now 'show' the symbol 'A'
A (This is the value)
   key2 val2
   key1 val1
-> A




show accepts an arbitrary number of arguments which are
processed according to the rules of get, resulting in a symbol which is showed then.


: (put 'B 'a 'A)        # Put 'A' under the 'a'-property of 'B'
-> A
: (setq Lst '(A B C))   # Create a list with 'B' as second argument
-> (A B C)
: (show Lst 2 'a)       # Show the property 'a of the 2nd element of 'Lst'
A (This is the value)   # (which is 'A' again)
   key2 val2
   key1 val1
-> A




Inspect and edit symbols in-memory



If you pass one or more symbols as a list to vi, they are written to a temporary file in a
format similar to show, and Vip is started with that
file.


: (vi '(A B))




The Vip window will look like


A (This is the value)
key1 val1
key2 val2

(=======)

B NIL
a A  # (This is the value)

(=======)




A convenient shortcut is the non-evaluating version v of
vi. An equivalent call to the above is:


(v A B)




Now you can modify values or properties. You should not touch the
parenthesized hyphens, as they serve as delimiters. If you position the cursor
on the first character of a symbol name and type 'K' ("Keyword
lookup"), the editor will be restarted with that symbol added to the editor
window. 'Q' (for "Quit") will bring you back to the previous view.


If you exit Vip with e.g. ":x", any changes you made in your editing session
will be communicated back to the REPL.


In-memory editing is also very useful to browse in a database. You can follow
the links between objects with 'K', and even - e.g. for low-level
repairs - modify the data (but only if you are really sure about what you are
doing, and don't forget to commit
when you are done).


Built-in pretty print with pp



The pretty-print function pp
takes a symbol that has a function defined (or two symbols that specify message
and class for a method definition), and displays that definition in a formatted
and indented way.


: (pp 'pretty)
(de pretty (X N)
   (setq N (abs (space (or N 0))))
   (while (and (pair X) (== 'quote (car X)))
      (prin "'")
      (pop 'X) )
   (cond
      ...
      (T (prtty0 X N)) ) )
-> pretty




The style is the same as we use in source files:


    


  • The indentation level is three spaces


  • If a list is too long (to be precise: if its size is greater than 12), pretty-print the CAR
on the current line, and each element of the CDR recursively on its own line.


  • A closing parenthesis a preceded by a space if the corresponding open
parenthesis is not on the same line





Inspect elements one by one with more



more is a simple tool that displays
the elements of a list one by one. It stops after each element and waits for
input. If you just hit ENTER, more continues with the next element,
otherwise (usually I type a dot (.) followed by ENTER) it
terminates.


: (more (1 2 3 4 5 6))
1                          # Hit ENTER
2   .                      # Hit '.' and ENTER
-> T                       # stopped




Optionally more takes a function as a second argument and
applies that function to each element (instead of the default print). Here, often show or
pp (see below) is used.


: (more '(A B))            # Step through 'A' and 'B'
A
B
-> NIL
: (more '(A B) show)       # Step through 'A' and 'B' with 'show'
A (This is the value)      # showing 'A'
   key2 val2
   key1 val1
                           # Hit ENTER
B NIL                      # showing 'B'
   a A
-> NIL




Search through available symbols with what



The what function returns a list of
all internal symbols in the system which match a given pattern (with
'@' wildcard characters).


: (what "prin@")
-> (prin print prinl print> printsp println)




Search through values or properties of symbols with who



The function who returns "who
contains that", i.e. a list of symbols that contain a given argument
somewhere in their value or property list.


: (who 'print)
-> (query _pretty spPrt prtty1 prtty2 prtty3 pretty ("syms>" . "+Buffer")
msg more show view (print> . +Date) rules select (print> . +relation) pico)




A dotted pair indicates either a method definition or a property entry. So
(print> . +relation) denotes the print> method of
the +relation class.


who can be conveniently combined with more and
pp:


: (more (who 'print) pp)
(de query ("Q" "Dbg")  # Pretty-print these functions one by one
   (use "R"
      (loop
         (NIL (prove "Q" "Dbg"))
         (T (=T (setq "R" @)) T)
         (for X "R"
            (space)
            (print (car X))
            (print '=)
            (print (cdr X))
            (flush) )
         (T (line)) ) ) )

(de pretty (X N)
   ...




The argument to who may also be a pattern list (see match):


: (who '(print @ (less (val @))))
-> (show)

: (more (who '(% @ 7)) pp)
(de day (Dat Lst)
   (when Dat
      (get
         (or Lst *DayFmt)
         (inc (% (inc Dat) 7)) ) ) )

(de _week (Dat)
   (/ (- Dat (% (inc Dat) 7)) 7) )




Find what classes can accept a given message with can



The function can returns a list
which indicates which classes can accept a given message. Again, this
list is suitable for iteration with pp:


: (can 'del>)                                   # Which classes accept 'del>' ?
-> ((del> . +List) (del> . +Entity) (del> . +relation))

: (more (can 'del>) pp)                         # Inspect the methods with 'pp'
(dm (del> . +List) (Obj Old Val)
   (and ((<> Old Val) (delete Val Old)) )

(dm (del> . +Entity) (Var Val)
   (when
      (and
         Val
         (has> (meta This Var) Val (get This Var)) )
      (let Old (get This Var)
         (rel>
            (meta This Var)
            This
            Old
            (put This Var (del> (meta This Var) This Old @)) )
         (when (asoq Var (meta This 'Aux))
            (relAux This Var Old (cdr @)) )
         (upd> This Var Old) ) ) )

(dm (del> . +relation) (Obj Old Val)
   (and ((<> Old Val) Val) )




Inspect dependencies with dep



dep shows the dependencies in a
class hierarchy. That is, for a given class it displays the tree of its
(super)class(es) above it, and the tree of its subclasses below it.


To view the complete hierarchy of input fields, we start with the root class
+relation:


: (dep '+relation)
+relation
   +Bag
   +Any
   +Blob
   +Link
      +Joint
   +Bool
   +Symbol
      +String
   +Number
      +Time
      +Date
-> +relation




If we are interested in +Link:


: (dep '+Link)
   +relation
+Link
   +Joint
-> +Link




This says that +Link is a subclass of +relation, and has a single subclass
(+Joint).





Defining Functions



Most of the time during programming is spent defining functions (or methods).
In the following we will concentrate on functions, but most will be true for
methods as well except for using dm
instead of de.


Functions with no argument



The notorious "Hello world" function must be defined:


: (de hello ()
   (prinl "Hello world") )
-> hello




The () in the first line indicates a function without arguments.
The body of the function is in the second line, consisting of a single
statement. The last line is the return value of de, which here is
the defined symbol. From now on we will omit the return values of examples when
they are unimportant.


Now you can call this function this way:


: (hello)
Hello world




Functions with one argument



A function with an argument might be defined this way:


: (de hello (X)
   (prinl "Hello " X) )
# hello redefined
-> hello




PicoLisp informs you that you have just redefined the function. This might be
a useful warning in case you forgot that a bound symbol with that name already
existed.


: (hello "world")
Hello world




: (hello "Alex")
Hello Alex




Preventing arguments evaluation and variable number of arguments



Normally, PicoLisp evaluates the arguments before it passes them to a
function:


: (hello (+ 1 2 3))
Hello 6




: (setq A 1  B 2)       # Set 'A' to 1 and 'B' to 2
-> 2
: (de foo (X Y)         # 'foo' returns the list of its arguments
   (list X Y) )
-> foo
: (foo A B)             # Now call 'foo' with 'A' and 'B'
-> (1 2)                # -> We get a list of 1 and 2, the values of 'A' and 'B'




In some cases you don't want that. For some functions (setq for example) it is better if the function
gets all arguments unevaluated, and can decide for itself what to do with them.


For such cases you do not define the function with a list of
parameters, but give it a single atomic parameter instead. PicoLisp will
then bind all (unevaluated) arguments as a list to that parameter.


: (de foo X
   (list (car X) (cadr X)) )        # 'foo' lists the first two arguments

: (foo A B)                         # Now call it again
-> (A B)                            # -> We don't get '(1 2)', but '(A B)'

: (de foo X
   (list (car X) (eval (cadr X))) ) # Now evaluate only the second argument

: (foo A B)
-> (A 2)                            # -> We get '(A 2)'




Mixing evaluated arguments and variable number of unevaluated arguments



As a logical consequence, you can combine these principles. To define a
function with 2 evaluated and an arbitrary number of unevaluated arguments:


: (de foo (X Y . Z)     # Evaluate only the first two args
   (list X Y Z) )

: (foo A B C D E)
-> (1 2 (C D E))        # -> Get the value of 'A' and 'B' and the remaining list




Variable number of evaluated arguments



More common, in fact, is the case where you want to pass an arbitrary number
of evaluated arguments to a function. For that, PicoLisp recognizes the
symbol @ as a single atomic parameter and remembers all evaluated
arguments in an internal frame. This frame can then be accessed sequentially
with the args, next, arg and rest functions.


: (de foo @
   (list (next) (next)) )     # Get the first two arguments

: (foo A B)
-> (1 2)




Again, this can be combined:


: (de foo (X Y . @)
   (list X Y (next) (next)) ) # 'X' and 'Y' are fixed arguments

: (foo A B (+ 3 4) (* 3 4))
-> (1 2 7 12)                 # All arguments are evaluated




These examples are not very useful, because the advantage of a variable
number of arguments is not used. A function that prints all its evaluated
numeric arguments, each on a line followed by its squared value:


: (de foo @
   (while (args)                    # Check if there are some args left
      (let N (next)
         (println N (* N N)) ) ) )

: (foo (+ 2 3) (- 7 1) 1234 (* 9 9))
5 25
6 36
1234 1522756
81 6561
-> 6561




This next example shows the behaviour of args and
rest:


: (de foo @
   (while (args)
      (println (next) (args) (rest)) ) )
: (foo 1 2 3)
1 T (2 3)
2 T (3)
3 NIL NIL




Finally, it is possible to pass all these evaluated arguments to another
function, using pass:


: (de foo @
   (pass println 9 8 7)       # First print all arguments preceded by 9, 8, 7
   (pass + 9 8 7) )           # Then add all these values

: (foo (+ 2 3) (- 7 1) 1234 (* 9 9))
9 8 7 5 6 1234 81             # Printing ...
-> 1350                       # Return the result




Anonymous functions without the lambda keyword


There's no distinction between code and data in PicoLisp,
quote will do what you want (see
also this FAQ entry).


: ((quote (X) (* X X)) 9)
-> 81




: (setq f '((X) (* X X)))  # This is equivalent to (de f (X) (* X X))
-> ((X) (* X X))
: f
-> ((X) (* X X))
: (f 3)
-> 9







Debugging



There are two major ways to debug functions (and methods) at runtime:
Tracing and single-stepping.


In this section we will use the REPL to explore the debugging facilities, but
in the Scripting section, you will learn how to launch
PicoLisp scripts with some selected functions debugged:


$ pil app/file1.l -"trace 'foo" -main -"debug 'bar" app/file2.l +




Tracing



Tracing means letting functions of interest print their name and arguments
when they are entered, and their name again and the return value when they are
exited.


For demonstration, let's define the unavoidable factorial function:


(de fact (N)
   (if (=0 N)
      1
      (* N (fact (dec N))) ) )




With trace we can put it in trace
mode:


: (trace 'fact)
-> fact




Calling fact now will display its execution trace.


: (fact 3)
 fact : 3
  fact : 2
   fact : 1
    fact : 0
    fact = 1
   fact = 1
  fact = 2
 fact = 6
-> 6




As can be seen here, each level of function call will indent by an additional
space. Upon function entry, the name is separated from the arguments with a
colon (:), and upon function exit with an equals sign
(=) from the return value.


trace works by modifying the function body, so generally it
works only for functions defined as lists (lambda expressions, see Evaluation). Tracing a built-in function (SUBR) is
possible, however, when it is a function that evaluates all its arguments.


So let's trace the functions =0 and
*:


: (trace '=0)
-> =0
: (trace '*)
-> *




If we call fact again, we see the additional output:


: (fact 3)
 fact : 3
  =0 : 3
  =0 = NIL
  fact : 2
   =0 : 2
   =0 = NIL
   fact : 1
    =0 : 1
    =0 = NIL
    fact : 0
     =0 : 0
     =0 = 0
    fact = 1
    * : 1 1
    * = 1
   fact = 1
   * : 2 1
   * = 2
  fact = 2
  * : 3 2
  * = 6
 fact = 6
-> 6




To reset a function to its untraced state, call untrace:


: (untrace 'fact)
-> fact
: (untrace '=0)
-> =0
: (untrace '*)
-> *




or simply use mapc:


: (mapc untrace '(fact =0 *))
-> *




Single-stepping



Single-stepping means to execute a function step by step, giving the
programmer an opportunity to look more closely at what is happening. The
function debug inserts a breakpoint
into each top-level expression of a function. When the function is called, it
stops at each breakpoint, displays the expression it is about to execute next
(this expression is also stored into the global variable ^) and enters a read-eval-loop. The programmer
can then


    


  • inspect the current environment by typing variable names or calling
functions


  • execute (d) to recursively debug the
next expression (looping through subexpressions of this expression)


  • execute (e) to evaluate the next
expression, to see what will happen without actually advancing on


  • type ENTER (that is, enter an empty line) to leave the read-eval loop and
continue with the next expression





Thus, in the simplest case, single-stepping consists of just hitting ENTER
repeatedly to step through the function.


To try it out, let's look at the stamp system function. You may need to have a
look at


    

  • =T (T test),
    • 


  • date and time (grab system date and time)


  • default (conditional
assignments)


  • pack (kind of concatenation), and


  • dat$ and tim$ (date and time formats)
    • 




to understand this definition.


: (pp 'stamp)
(de stamp (Dat Tim)
   (and (=T Dat) (setq Dat (date T)))
   (default Dat (date) Tim (time T))
   (pack (dat$ Dat "-") " " (tim$ Tim T)) )
-> stamp




: (debug 'stamp)                       # Debug it
-> T
: (stamp)                              # Call it again
(and (=T Dat) (setq Dat (date T)))     # stopped at first expression
!                                      # ENTER
(default Dat (date) Tim (time T))      # second expression
!                                      # ENTER
(pack (dat$ Dat "-") " " (tim$ ...     # third expression
! Tim                                  # inspect 'Tim' variable
-> 41908
! (time Tim)                           # convert it
-> (11 38 28)
!                                      # ENTER
-> "2004-10-29 11:38:28"               # done, as there are only 3 expressions




Now we execute it again, but this time we want to look at what's happening
inside the second expression.


: (stamp)                              # Call it again
(and (=T Dat) (setq Dat (date T)))
!                                      # ENTER
(default Dat (date) Tim (time T))
!                                      # ENTER
(pack (dat$ Dat "-") " " (tim$ ...     # here we want to look closer
! (d)                                  # debug this expression
-> T
!                                      # ENTER
(dat$ Dat "-")                         # stopped at first subexpression
! (e)                                  # evaluate it
-> "2004-10-29"
!                                      # ENTER
(tim$ Tim T)                           # stopped at second subexpression
! (e)                                  # evaluate it
-> "11:40:44"
!                                      # ENTER
-> "2004-10-29 11:40:44"               # done




The breakpoints still remain in the function body. We can see them when we
pretty-print it:


: (pp 'stamp)
(de stamp (Dat Tim)
   (! and (=T Dat) (setq Dat (date T)))
   (! default Dat (date) Tim (time T))
   (! pack
      (! dat$ Dat "-")
      " "
      (! tim$ Tim T) ) )
-> stamp




To reset the function to its normal state, call unbug:


: (unbug 'stamp)




Often, you will not want to single-step a whole function. Just use
v (see above) to insert a single breakpoint (the exclamation mark
followed by a space) as CAR of an expression, and run your program. Execution
will then stop there as described above; you can inspect the environment and
continue execution with ENTER when you are done.





Functional I/O



Input and output in PicoLisp is functional, in the sense that there are not
variables assigned to file descriptors, which need then to be passed to I/O
functions for reading, writing and closing. Instead, these functions operate on
implicit input and output channels, which are created and maintained as dynamic
environments.


Standard input and standard output are the default channels. Try reading a
single expression:


: (read)
(a b c)        # Console input
-> (a b c)




To read from a file, we redirect the input with in. Note that comments and whitespace are
automatically skipped by read:


: (in "@lib.l" (read))
-> (de task (Key . Prg) (nond (...




The skip function can also be used
directly. To get the first non-white character in the file with char:


: (in "@lib.l" (skip "#") (char))
-> "("




from searches through the input
stream for given patterns. Typically, this is not done with Lisp source files
(there are better ways), but for a simple example let's extract all items
immediately following fact in the file,


: (in "@lib.l" (while (from "nond") (println (read))))
(Prg (del (assoc Key *Run) '*Run))
((pair "X") (or (pair (getd "X")) (expr "X")))
("Prg" (caar (idx "Var" "K")))




or the word following "(de " with till:


: (in "@lib.l" (from "(de ") (till " " T))
-> "task"




 To read the contents of a whole file (or the rest of it starting from the
current position):


: (in "f.l" (till NIL T))
-> "... file contents ..."





With line, a line of characters is
read, either into a single transient symbol
(the type used by PicoLisp for strings),


: (in "@doc/tut.html" (line T))
-> "<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" "http://..."




or into a list of symbols (characters):


: (in "@doc/tut.html" (line))
-> ("<" "!" "D" "O" "C" "T" "Y" "P" "E" " " "H" "T" "M" "L" ...




line is typically used to read tabular data from a file.
Additional arguments can split the line into fixed-width fields, as described in
the reference manual. If, however, the
data are of variable width, delimited by some special character, the split function can be used to extract the
fields. A typical way to import the contents of such a file is:


(in '("bin/utf2" "importFile.txt")              # Pipe: Convert to UTF-8
   (until (eof)                                 # Process whole file
      (let L (split (line) "\t")                # TAB-delimited data
         ...                                    # process them




Some more examples with echo:


(in "a"                                         # Copy the first 40 Bytes
   (out "b"                                     # from file "a" to file "b"
      (echo 40) ) )

(in "@doc/tut.html"                             # Show the HTTP-header
   (line)
   (echo "<body>") )

(out "file.mac"                                 # Convert to Macintosh
   (in "file.txt"                               # from Unix or DOS format:
      (while (char)
         (prin
            (case @
               ("\r" NIL)                       # ignore CR
               ("\n" "\r")                      # convert LF to CR
               (T @) ) ) ) ) )                  # otherwise no change

(out "c"                                        # Merge the contents of "a"
   (in "b"                                      # and "b" into "c"
      (in "a"
         (while (read)                          # Read an item from "a",
            (println @ (in -1 (read))) ) ) ) )  # print it with an item from "b"







Scripting



There are two possibilities to get the PicoLisp interpreter into doing useful
work: via command line arguments, or as a stand-alone script.


Command line arguments for the PicoLisp interpreter



The command line can specify either files for execution, or arbitrary Lisp
expressions for direct evaluation (see Invocation):
if an argument starts with a hyphen, it is evaluated, otherwise it is loaded as a file. A typical invocation might
look like:


$ pil app/file1.l -main app/file2.l +




It loads the debugging environment, an application source file, calls the
main function, and then loads another application source. In a typical
development and debugging session, this line is often modified using the shell's
history mechanisms, e.g. by inserting debugging statements:


$ pil app/file1.l -"trace 'foo" -main -"debug 'bar" app/file2.l +




Another convenience during debugging and testing is to put things into the
command line (shell history) which would otherwise have to be done each time in
the application's user interface:


$ pil app/file1.l -main app/file2.l -go -'login "name" "password"' +




The final production release of an application usually includes a shell
script, which initializes the environment, does some bookkeeping and cleanup,
and calls the application with a proper command line. It is no problem if the
command line is long and complicated.


For small utility programs, however, this is overkill. Enter full PicoLisp
scripts.


PicoLisp scripts


It is better to write
a single executable file using the mechanisms of "interpreter files". If the
first two characters in an executable file are "#!", the operating
system kernel will pass this file to an interpreter program whose pathname is
given in the first line (optionally followed by a single argument). This is fast
and efficient, because the overhead of a subshell is avoided.


Let's assume you installed PicoLisp in the directory "/home/foo/pil21/",
and put links to the executable and the installation directory as:


$ ln -s /home/foo/pil21 /usr/lib/picolisp
$ ln -s /usr/lib/picolisp/bin/picolisp /usr/bin



Then a simple hello-world script might look like:


#!/usr/bin/picolisp /usr/lib/picolisp/lib.l
(prinl "Hello world!")
(bye)




If you write this into a text file, and use chmod to set it to
"executable", it can be executed like any other command. Note that (because
# is the comment character in PicoLisp) the first line will not be
interpreted, and you can still use that file as a normal command line argument
to PicoLisp (useful during debugging).


Grab command line arguments from PicoLisp scripts



The fact that a hyphen causes evaluation of command line arguments can be
used to implement command line options. The following script defines two
functions a and f, and then calls (load T) to process the rest of the command line
(which otherwise would be ignored because of the (bye) statement):


#!/usr/bin/picolisp /usr/lib/picolisp/lib.l

(de a ()
   (println '-a '-> (opt)) )

(de f ()
   (println '-f '-> (opt)) )

(load T)
(bye)



(opt retrieves the next command line
option)


Calling this script (let's say we named it "testOpts") gives:


$ ./testOpts -f abc
-f -> "abc"
$ ./testOpts -a xxx  -f yyy
-a -> "xxx"
-f -> "yyy"




We have to be aware of the fact, however, that the aggregation of arguments
like


$ ./testOpts -axxx  -fyyy




or


$ ./testOpts -af yyy




cannot be achieved with this simple and general mechanism of command line
processing.


Run scripts from arbitrary places on the host file system



Utilities are typically used outside the context of the PicoLisp environment.
All examples above assumed that the current working directory is the PicoLisp
installation directory, which is usually all right for applications developed in
that environment. Command line file arguments like "app/file1.l" will be
properly found.


To allow utilities to run in arbitrary places on the host file system, the
concept of home directory substitution was introduced. The interpreter
remembers internally at start-up the pathname of its first argument (usually
"lib.l"), and substitutes any leading "@" character in subsequent
file names with that pathname. Thus, to run the above example in some other
place, simply write:


$ /home/foo/pil21/pil @app/file1.l -main @app/file2.l +




that is, supply a full path name to the initial command (here 'pil'), or put
it into your PATH variable, and prefix each file which has to be
loaded from the PicoLisp home directory with a @ character.
"Normal" files (not prefixed by @) will be opened or created
relative to the current working directory as usual.


Stand-alone scripts will often want to load additional modules from the
PicoLisp environment, beyond the "lib.l" we provided in the first line of the
hello-world script. Typically, at least a call to


(load "@lib/misc.l")




(note the home directory substitution) will be included near the beginning of
the script.


As a more complete example, here is a script which extracts the date, name
and size of the latest official PicoLisp release version from the download web
site, and prints it to standard output:


#!/usr/bin/picolisp /usr/lib/picolisp/lib.l

(load "@lib/misc.l" "@lib/http.l")

(use (@Date @Name @Size)
   (when
      (match
         '(@Date ~(chop " - <a href=\"") @Name "\"" ">"
             @Name ~(chop "</a> (") @Size )
         (client "software-lab.de" 80 "down.html"
            (from "Release Archive")
            (from "<li>")
            (till ",") ) )
      (prinl @Name)
      (prinl @Date " -- " @Size) ) )

(bye)





pil21/doc/faq.html0000644000000000000000000007451014616657552011125 0ustar  





PicoLisp FAQ



abu@software-lab.de



Monk: "If I have nothing in my mind, what shall I do?"

Joshu: "Throw it out."

Monk: "But if there is nothing, how can I throw it out?"

Joshu: "Well, then carry it out."

(Zen koan)



PicoLisp Frequently Asked Questions



(c) Software Lab. Alexander Burger







Why did you write yet another Lisp?



Because other Lisps are not the way I'd like them to be. They concentrate on
efficient compilation, and lost the one-to-one relationship of language and
virtual machine of an interpreted system, gave up power and flexibility, and
impose unnecessary limitations on the freedom of the programmer. Other reasons
are the case-insensitivity and complexity of current Lisp systems.





Who can use PicoLisp?



PicoLisp is for programmers who want to control their programming
environment, at all levels, from the application domain down to the bare metal,
who want to use a transparent and simple - yet universal - programming model,
and who want to know exactly what is going on.


It does not pretend to be easy to learn. There are already plenty of
languages that do so. It is not for people who don't care what's under the hood,
who just want to get their application running. They are better served with some
standard, "safe" black-box, which may be easier to learn, and which allegedly
better protects them from their own mistakes.





What are the advantages over other Lisp systems?



Simplicity


PicoLisp is easy to understand and adapt. There is no compiler enforcing
special rules, and the interpreter is simple and straightforward. There are only
three data types: Numbers, symbols and lists ("LISP" means "List-, Integer- and
Symbol Processing" after all ;-). The memory footprint is minimal, and the
tarball size of the whole system is just a few hundred kilobytes.


A Clear Model


Most other systems define the language, and leave it up to the implementation
to follow the specifications. Therefore, language designers try to be as
abstract and general as possible, leaving many questions and ambiguities to the
users of the language.


PicoLisp does the opposite. Initially, only the single-cell data structure
was defined, and then the structure of numbers, symbols and lists as they are
composed of these cells. Everything else in the whole system follows from these
axioms. This is documented in the chapter about The
PicoLisp Machine in the reference manual.


Orthogonality


There is only one symbolic data type, no distinction (confusion) between
symbols, strings, variables, special variables and identifiers.


Most data-manipulation functions operate on the values of symbols as well as
the CARs of cons pairs:


: (let (N 7  L (7 7 7)) (inc 'N) (inc (cdr L)) (cons N L))
-> (8 7 8 7)




There is only a single functional type, no "special forms". As there is no
compiler, functions can be used instead of macros. No special "syntax"
constructs are needed. This allows a completely orthogonal use of functions. For
example, most other Lisps do not allow calls like


: (mapcar if '(T NIL T NIL) (1 2 3 4) (5 6 7 8))
-> (1 6 3 8)




PicoLisp has no such restrictions. It favors the principle of "Least
Astonishment".


Object System


The OOP system is very powerful, because it is fully dynamic, yet extremely
simple:


    

  • In other systems you have to statically declare "slots". In PicoLisp,
classes and objects are completely dynamic, they are created and extended at
runtime. "Slots" don't even exist at creation time. They spring into existence
purely dynamically. You can add any new property or any new method to any single
object, at any time, regardless of its class.


  • The multiple inheritance is such that not only classes can have several
superclasses, but each individual object can be of more than one class.


  • Prefix classes can surgically change the inheritance tree for any class or
object. They behave like Mixins in this regard.


  • Fine-control of inheritance in methods with super and extra.





Pragmatism


PicoLisp has many practical features not found in other Lisp dialects. Among
them are:


    

  • Auto-quoting of lists when the CAR is a number. Instead of '(1 2
3) you can just write (1 2 3). This is possible because a
number never makes sense as a function name, and has to be checked at runtime
anyway.


  • The quote function returns all
unevaluated arguments, instead of just the first one. This is both faster
(quote does not have to take the CAR of its argument list) and
smaller (a single cell instead of two). For example, 'A expands to
(quote . A) and '(A B C) expands to (quote A B
C).


  • The symbol @ is automatically
maintained as a local variable, and set implicitly in certain flow- and
logic-functions. This makes it often unnecessary to allocate and assign local
variables.


  • Functional I/O is more convenient than
explicitly passing around file descriptors.


  • A well-defined ordinal relationship between
arbitrary data types facilitates generalized comparing and sorting.


  • Uniform handling of var locations (i.e. values of symbols and
CARs of cons pairs).


  • The universality and usefulness of symbol properties is enforced and
extended with implicit and explicit bindings of the symbol This in combination with the access functions
=:, : and ::.


  • A very convenient list-building machinery, using the link, yoke, chain and made functions in the make environment.


  • The syntax of often-used functions is kept non-verbose. For example, instead
of (let ((A 1) (B 2) C 3) ..) you write (let (A 1 B 2 C 3)
..), or just (let A 1 ..) if there is only a single
variable.


  • The use of the hash (#) as a comment character is more appropriate
today, and allows a clean hash-bang (#!) syntax for stand-alone
scripts.


  • The interpreter is invoked with a simple and
flexible syntax, where command line arguments are either files to be interpreted
or functions to be directly executed. With that, many tasks can be performed
without writing a separate script.


  • A sophisticated system of interprocess communication, file locking and
synchronization allows multi-user access to database applications.


  • A general and dynamic interface for Native C Calls
(FFI).


  • A Prolog interpreter is tightly integrated into the language. Prolog
clauses can call Lisp expressions and vice versa, and a self-adjusting
depth-first search predicate select can be used in database
queries.





Persistent Symbols


Database objects ("external" symbols) are a primary data type in PicoLisp.
They look like normal symbols to the programmer, but are managed in the database
(fetched from, and stored to) automatically by the system. Symbol manipulation
functions like set, put or get, the
garbage collector, and other parts of the interpreter know about them.


Application Server


It is a stand-alone system (it does not depend on external programs like
Apache or MySQL) and it provides a "live" user interface on the client side,
with an application server session for each connected client. The GUI layout and
behavior are described with S-expressions, generated dynamically at runtime, and
interact directly with the database structures.


Localization


Internal exclusive and full use of UTF-8 encoding, and self-translating transient symbols (strings), make it easy to
write country- and language-independent applications.





How is the performance compared to other Lisp systems?



Despite the fact that PicoLisp is an interpreted-only system, the performance
is quite good. Typical Lisp programs operating on list data structures are
executed in (interpreted) PicoLisp at about the same speed as in (compiled)
CMUCL, and about two or three times faster than in CLisp or Scheme48.


But in practice, speed was never a problem, even with the first versions of
PicoLisp in 1988 on a Mac II with a 12 MHz CPU. And certain things are cleaner
and easier to do in C (or other low-level languages) anyway. It is
very easy to write C functions in PicoLisp, either in the kernel,
as shared object libraries, or even inline in the Lisp code.


PicoLisp is very space-efficient. Other Lisp systems reserve heap space twice
as much as needed, or use rather large internal structures to store cells and
symbols. Each cell or minimal symbol in PicoLisp consists of only two pointers.
No additional tags are stored, because they are implied in the pointer
encodings. No gaps remain in the heap during allocation, as there are only
objects of a single size. As a result, consing and garbage collection are very
fast, and overall performance benefits from a better cache efficiency. Heap and
stack grow automatically, and are limited only by hardware and operating system
constraints.





What does "interpreted" mean?



It means to directly execute Lisp data as program code. No transformation to
another representation of the code (e.g. compilation), and no structural
modifications of these data, takes place.


Lisp data are the "real" things, like numbers, symbols and lists, which can
be directly handled by the system. They are not the textual
representation of these structures (which is outside the Lisp realm and taken
care of by the reading and printing functions).


The following example builds a function and immediately calls it with two
arguments:


: ((list (list 'X 'Y) (list '* 'X 'Y)) 3 4)
-> 12




Note that no time is wasted to build up a lexical environment. Variable
bindings take place dynamically during interpretation.


A PicoLisp function is able to inspect or modify itself while it is running
(though this is rarely done in application programming). The following function
modifies itself by incrementing the '0' in its body:


(de incMe ()
   (do 8
      (printsp 0)
      (inc (cdadr (cdadr incMe))) ) )

: (incMe)
0 1 2 3 4 5 6 7 -> 8
: (incMe)
8 9 10 11 12 13 14 15 -> 16




Only an interpreted Lisp can fully support such "Equivalence of Code and
Data". If executable pieces of data are used frequently, like in PicoLisp's
dynamically generated GUI, a fast interpreter is preferable over any compiler.





Is there (or will be in the future) a compiler available?



No. That would contradict the idea of PicoLisp's simple virtual machine
structure. A compiler transforms it to another (physical) machine, with the
result that many assumptions about the machine's behavior won't hold any more.
Besides that, PicoLisp primitive functions evaluate their arguments
independently and are not suited for being called from compiled code. Finally,
the gain in execution speed would probably not be worth the effort. Typical
PicoLisp applications often use single-pass code which is loaded, executed and
thrown away; a process that would be considerably slowed down by compilation.





Is it portable?



Yes and No. Though we wrote and tested PicoLisp originally only on Linux, it
now also runs on many other POSIX systems. The first versions were even fully
portable between DOS, SCO-Unix and Macintosh systems. But today we have Linux.
Linux itself is very portable, and you can get access to a Linux system almost
everywhere. So why bother?


The GUI is completely platform independent (Browser), and in the age of the
Internet an application server does not really need to be portable.





Is PicoLisp a web server?



Not really, but it evolved a great deal into that direction.


Historically it was the other way round: We had a plain X11 GUI for our
applications, and needed something platform independent. The solution was
obvious: Browsers are installed virtually everywhere. So we developed a protocol
which persuades a browser to function as a GUI front-end to our applications.
This is much simpler than to develop a full-blown web server.





I cannot find the LAMBDA keyword in PicoLisp



Because it isn't there. The reason is that it is redundant; it is equivalent
to the quote function in any aspect, because there's no distinction
between code and data in PicoLisp, and quote returns the whole
(unevaluated) argument list. If you insist on it, you can define your own
lambda:


: (def 'lambda quote)
-> lambda
: ((lambda (X Y) (+ X Y)) 3 4)
-> 7
: (mapcar (lambda (X) (+ 1 X)) (1 2 3 4 5))
-> (2 3 4 5 6)







Why do you use dynamic variable binding?



Dynamic binding is very powerful, because there is only one single,
dynamically changing environment active all the time. This makes it possible
(e.g. for program snippets, interspersed with application data and/or passed
over the network) to access the whole application context, freely, yet in a
dynamically controlled manner. And (shallow) dynamic binding is the fastest
method for a Lisp interpreter.


Lexical binding is more limited by definition, because each environment is
deliberately restricted to the visible (textual) static scope within its
establishing form. Therefore, most Lisps with lexical binding introduce "special
variables" to support dynamic binding as well, and constructs like
labels to extend the scope of variables beyond a single function.


In PicoLisp, function definitions are normal symbol values. They can be
dynamically rebound like other variables. As a useful real-world example, take
this little gem:


(de recur recurse
   (run (cdr recurse)) )




It implements anonymous recursion, by defining recur statically
and recurse dynamically. Usually it is very cumbersome to think up
a name for a function (like the following one) which is used only in a single
place. But with recur and recurse you can simply
write:


: (mapcar
   '((N)
      (recur (N)
         (if (=0 N)
            1
            (* N (recurse (- N 1))) ) ) )
   (1 2 3 4 5 6 7 8) )
-> (1 2 6 24 120 720 5040 40320)




Needless to say, the call to recurse does not have to reside in
the same function as the corresponding recur. Can you implement
anonymous recursion so elegantly with lexical binding?





Are there no problems caused by dynamic binding?



You mean the funarg problem, or problems that arise when a variable
might be bound to itself? For that reason we have a convention in
PicoLisp to use transient symbols (instead
of internal symbols) or private internal symbols


    


  1. for all parameters and locals, when functional arguments or executable lists
are passed through the current dynamic bindings


  2. for a parameter or local, when that symbol might possibly be (directly or
indirectly) bound to itself, and the bound symbol's value is accessed in the
dynamic context.





This is a form of lexical scoping - though we still have dynamic
binding - of symbols, similar to the static keyword in
C.


In fact, these problems are a real threat, and may lead to mysterious bugs
(other Lisps have similar problems, e.g. with symbol capture in macros). They
can be avoided, however, when the above conventions are observed. As an example,
consider a function which doubles the value in a variable:


(de double (Var)
   (set Var (* 2 (val Var))) )




This works fine, as long as we call it as (double 'X), but will
break if we call it as (double 'Var). Therefore, the correct
implementation of double should be:


(de double ("Var")
   (set "Var" (* 2 (val "Var"))) )




If double is defined that way in a separate source file, then
the symbol Var is locked into a private lexical context and
cannot conflict with other symbols.


Admittedly, there are two disadvantages with this solution:


    


  1. The rules for when to use transient or private symbols are a bit
complicated. Though it is safe to use them even when not necessary, it will take
more space then and be more difficult to debug.


  2. The string-like syntax of transient symbols as variables may look strange to
alumni of other languages. With private symbols this is not an issue.




Fortunately, these pitfalls do not occur so very often, and seem more likely in
utilities than in production code, so that they can be easily encapsulated.





But with dynamic binding I cannot implement closures!



This is not true. Closures are a matter of scope, not of binding.


For a closure it is necessary to build and maintain a separate environment.
In a system with lexical bindings, this has to be done at each function
call, and for compiled code it is the most efficient strategy anyway, because it
is done once by the compiler, and can then be accessed as stack frames at
runtime.


For an interpreter, however, this is quite an overhead. So it should not be
done automatically at each and every function invocation, but only if needed.


You have several options in PicoLisp. For simple cases, you can take
advantage of the static scope of transient
or private symbols. For the general case, PicoLisp has built-in functions like
bind or job, which dynamically manage statically scoped
environments.


Environments are first-class objects in PicoLisp, more flexible than
hard-coded closures, because they can be created and manipulated independently
from the code.


As an example, consider a currying function:


(de curry Args
   (list (car Args)
      (list 'list
         (lit (cadr Args))
         (list 'cons ''job
            (list 'cons
               (list 'lit (list 'env (lit (car Args))))
               (lit (cddr Args)) ) ) ) ) )




When called, it returns a function-building function which may be applied to
some argument:


: ((curry (X) (N) (* X N)) 3)
-> ((N) (job '((X . 3)) (* X N)))




or used as:


: (((curry (X) (N) (* X N)) 3) 4)
-> 12




In other cases, you are free to choose a shorter and faster solution. If (as
in the example above) the curried argument is known to be immutable:


(de curry Args
   (list
      (cadr Args)
      (list 'fill
         (lit (cons (car Args) (cddr Args)))
         (lit (cadr Args)) ) ) )




Then the function built above will just be:


: ((curry (X) (N) (* X N)) 3)
-> ((X) (* X 3))




In that case, the "environment build-up" is reduced by a simple (lexical)
constant substitution with zero runtime overhead.


Note that the actual curry
function is simpler and more pragmatic. It combines both strategies (to use
job, or to substitute), deciding at runtime what kind of function
to build.





Do you have macros?



Yes, there is a macro mechanism in PicoLisp, to build and immediately execute
a list of expressions. But it is seldom used. Macros are a kludge. Most things
where you need macros in other Lisps are directly expressible as functions in
PicoLisp, which (as opposed to macros) can be applied, passed around, and
debugged.


For example, Common Lisp's DO* macro, written as a function:


(de do* "Args"
   (bind (mapcar car (car "Args"))
      (for "A" (car "Args")
         (set (car "A") (eval (cadr "A"))) )
      (until (eval (caadr "Args"))
         (run (cddr "Args"))
         (for "A" (car "Args")
            (and (cddr "A") (set (car "A") (run @))) ) )
      (run (cdadr "Args")) ) )







Can I run threads?



This is not possible. Threads share memory and other resources (as opposed to
processes, which are better isolated from each other). Each thread has its own
stack for private data, but PicoLisp uses dynamic binding, where the stack holds
the saved values instead of the current values of symbols. As a
result, each running thread would overwrite the symbol bindings of other
threads.


Instead, PicoLisp uses separate processes - and interprocess communication -
for parallel execution, or coroutines as a
kind of cooperative threads running a controlled way and doing all
necessary housekeeping.


Another advantage of separate processes over threads: They can be distributed
across multiple machines, and therefore scale better.





Why are there no strings?



Because PicoLisp has something better: Transient symbols. They look and behave like
strings in any respect, but are nevertheless true symbols, with a value and a
property list.


This leads to interesting opportunities. The value, for example, can point to
other data that represent the string's translation. This is used extensively for
localization. When a program calls


   (prinl "Good morning!")




then changing the value of the symbol "Good morning!" to its
translation will change the program's output at runtime.


Transient symbols are also quite memory-conservative. As they are stored in
normal heap cells, no additional overhead for memory management is induced. The
cell holds the symbol's value in its CDR, and the tail in its CAR. If the string
is not longer than 7 bytes, it fits completely into the tail, and a single cell
suffices. Up to 15 bytes take up two cells, 23 bytes three etc., so that long
strings are not very efficient (needing twice the memory on the average), but
this disadvantage is made up by simplicity and uniformity. And lots of extremely
long strings are not the common case, as they are split up anyway during
processing, and stored as plain byte sequences in external files and databases.


Because transient symbols are temporarily interned (while loading the current source file), they are
shared within the same source and occupy that space only once, even if they
occur multiple times within the same file.





What about arrays?



PicoLisp has no array or vector data type. Instead, lists must be used for
any type of sequentially arranged data.


We believe that arrays are usually overrated. Textbook wisdom tells that they
have a constant access time O(1) when the index is known. Many other operations
like splits or insertions are expensive. Access with a known (numeric) index is
not typical for Lisp, and even then the advantage of an array is significant
only if it is relatively long. Holding lots of data in long arrays, however,
smells quite like a program design error, and we suspect that often more
structured representations like trees or interconnected objects would be better.


In practice, most arrays are rather short, or the program can be designed in
such a way that long arrays (or at least an indexed access) are avoided.


Using lists, on the other hand, has advantages. We have so many concerted
functions that uniformly operate on lists. There is no separate data type that
has to be handled by the interpreter, garbage collector, I/O, database and so
on. Lists can be made circular. And lists don't cause memory fragmentation.


Still, if there is really a need to access large amounts of data with a
numeric index, enum can be used. It
emulates a multidimensional - possibly sparse - array. It takes roughly 1.5 the
space a linear list would require, and is very fast.





How to do floating point arithmetic?



PicoLisp does not support real floating point numbers. You can do all kinds
of floating point calculations by calling existing library functions via
native, inline-C code, and/or by
loading the "@lib/math.l" library.


But PicoLisp has something even (arguably) better: Scaled fixpoint numbers, with unlimited precision.


The reasons for this design decision are manifold. Floating point numbers
smack of imperfection, they don't give "exact" results, have limited precision
and range, and require an extra data type. It is hard to understand what really
goes on (How many digits of precision do we have today? Are perhaps 10-byte
floats used for intermediate results? How does rounding behave?).


For fixpoint support, the system must handle just integer arithmetic, I/O and
string conversions. The rest is under programmer's control and responsibility
(the essence of PicoLisp).


Carefully scaled fixpoint calculations can do anything floating point can do.





What happens when I locally bind a symbol which has a function definition?



That's not a good idea. The next time that function gets executed within the
dynamic context the program may crash. Therefore we have a convention to use an
upper case first letter for locally bound symbols:


(de findCar (Car List)
   (when (member Car (cdr List))
      (list Car (car List)) ) )



;-)





Would it make sense to build PicoLisp in hardware?



At least it should be interesting. It would be a machine executing list
(tree) structures instead of linear instruction sequences. "Instruction
prefetch" would look down the CAR- and CDR-chains, and perhaps need only a
single cache for both data and instructions.


Primitive functions like set, val, if
and while, which are written in C or assembly language
now, would be implemented in microcode. Plus a few I/O functions for hardware
access. EVAL itself would be a microcode subroutine.


Only a single heap and a single stack is needed. They grow towards each
other, and cause garbage collection if they get too close. Heap compaction is
trivial due to the single cell size.


There would be no assembly-language. The lowest level (above the hardware and
microcode levels) are s-expressions: The machine language is Lisp.





I get a segfault if I ...



It is easy to produce a segfault in PicoLisp. Just set a symbol to a value
which is not a function, and call it:


: (setq foo 1)
-> 1
: (foo)
Segmentation fault



There is another example in the Evaluation section of the reference manual.


PicoLisp is a pragmatic language. It doesn't check at runtime for all
possible error conditions which won't occur during normal usage. Such errors are
usually detected quickly at the first test run, and checking for them after that
would just produce runtime overhead.


Catching the segmentation violation and bus fault signals is also not a good
idea, because the Lisp heap is most probably be damaged afterwards, possibly
creating further havoc if execution continues.


It is recommended to inspect the code periodically with lint. It will detect many potential errors.
And, most of these errors are avoided by following the PicoLisp naming conventions.





Where can I ask questions?



The best place is the PicoLisp Mailing
List (see also The Mail
Archive), or the IRC #picolisp
channel on FreeNode.net.



pil21/doc/native.html0000644000000000000000000006146714713155441011637 0ustar  





Native C Calls



abu@software-lab.de


Native C Calls



(c) Software Lab. Alexander Burger


This document describes how to call C functions in shared object files
(libraries) from PicoLisp, using the built-in native function - possibly with the help of
the struct and lisp functions.








Overview




native calls a C function in a
shared library. It tries to


    

  1. find a library by name

  2. find a function by name in the library

  3. convert the function's argument(s) from Lisp to C data structures

  4. call the function's C code

  5. convert the function's return value(s) from C to Lisp data structures




The direct return value of native is the Lisp representation of
the C function's return value. Further values, returned by reference from the C
function, are available in Lisp variables (symbol values).


struct is a helper function,
which can be used to manipulate C data structures in memory. It may take a
scalar (a numeric representation of a C value) to convert it to a Lisp item, or
(more typically) a pointer to a memory area to build and extract data
structures. lisp allows you to install callback functions, callable
from C code, written in Lisp.


%@ is a convenience function,
simplifying the most common use case of native.


In combination, these functions can interface PicoLisp to almost any C
function.


The above steps are fully dynamic; native doesn't have (and
doesn't require) a priori knowledge about the library, the function or the
involved data. No need to write any glue code, interfaces or include files. All
functions can even be called interactively from the REPL.





Syntax



The arguments to native are


    

  1. a library

  2. a function

  3. a return value specification

  4. optional arguments




The simplest form is a call to a function without return value and without
arguments. If we assume a library "lib.so", containing a function with the
prototype


void fun(void);




then we can call it as


(native "lib.so" "fun")







Libraries



The first argument to native specifies the library. It is either
the name of a library (a symbol), or the handle of a previously
found library (a number).


As a special case, a transient symbol "@" can be passed for the
library name. It then refers to the current main program (instead of an external
library), and can be used for standard functions like "malloc" or
"free".
Because this is needed so often,


(%@ "fun" ...)




can be used instead of


(native "@" "fun" ...)




native uses dlopen(3) internally to find and open
the library, and to obtain the handle. If the name contains a slash ('/'), then
it is interpreted as a (relative or absolute) pathname. Otherwise, the dynamic
linker searches for the library according to the system's environment and
directories. See the man page of dlopen(3) for further details.


If called with a symbolic argument, native automatically caches
the handle of the found library in the value of that symbol. The most natural
way is to pass the library name as a transient
symbol ("lib.so" above): The initial value of a transient symbol is
that symbol itself, so that native receives the library name upon
the first call. After successfully finding and opening the library,
native stores the handle of that library in the value of the passed
symbol ("lib.so"). As native evaluates its arguments
in the normal way, subsequent calls within the same transient scope will receive
the numeric value (the handle), and don't need to open and search the library
again.





Functions



The same rules applies to the second argument, the function. When called with
a symbol, native stores the function handle in its value, so that
subsequent calls evaluate to that handle, and native can directly
jump to the function.


native uses dlsym(3) internally to obtain the
function pointer. See the man page of dlsym(3) for further details.


In most cases a program will call more than one function from a given
library. If we keep the code within the same transient scope (i.e. in the same
source file), each library will be opened - and each function searched - only
once.


(native "lib.so" "fun1")
(native "lib.so" "fun2")
(native "lib.so" "fun3")




After "fun1" was called, "lib.so" will be open, and
won't be re-opened for "fun2" and "fun3". Consider
the definition of helper functions:


(de fun1 ()
   (native "lib.so" "fun1") )

(de fun2 ()
   (native "lib.so" "fun2") )

(de fun3 ()
   (native "lib.so" "fun3") )




After any one of fun1, fun2 or fun3
was called, the symbol "lib.so" will hold the library handle. And
each function "fun1", "fun2" and "fun3"
will be searched only when called the first time.


Note that the function handle points to a structure in memory, which is
automatically allocated. This implies that a memory leak may occur if the
transient symbol holding the function handle goes out of scope (e.g. by repeated
(re)loading the library after
executing its functions).


Warning: It should be avoided to put more than one library into a single
transient scope if there is a chance that two different functions with the same
name will be called in two different libraries. Because of the function handle
caching, the second call would otherwise (wrongly) go to the first function.





Return Value



The (optional) third argument to native specifies the return
value. A C function can return many types of values, like integer or floating
point numbers, string pointers, or pointers to structures which in turn consist
of those types, and even other structures or pointers to structures.
native tries to cover most of them.


As described in the result specification,
the third argument should consist of a pattern which tells native
how to extract the proper value.



Primitive Types



In the simplest case, the result specification is NIL like in
the examples so far. This means that either the C function returns
void, or that we are not interested in the value. The return value
of native will be NIL in that case.


If the result specification is one of the symbols B,
I or N, an integer number is returned, by interpreting
the result as a char (8 bit unsigned byte), int (32
bit signed integer), or long number (64 bit signed integer),
respectively. Other (signed or unsigned numbers, and of different sizes) can be
produced from these types with logical and arithmetic operations if necessary.


If the result specification is the symbol C, the result is
interpreted as a 16 bit number, and a single-char transient symbol (string) is
returned.


A specification of S tells native to interpret the
result as a pointer to a C string (null terminated), and to return a transient
symbol (string).


If the result specification is a number, it will be used as a scale to
convert a returned double (if the number is positive) or
float (if the number is negative) to a scaled fixpoint number.


Examples for function calls, with their corresponding C prototypes:


(native "lib.so" "fun" 'I)             # int fun(void);
(native "lib.so" "fun" 'N)             # long fun(void);
(native "lib.so" "fun" 'P)             # void *fun(void);
(native "lib.so" "fun" 'S)             # char *fun(void);
(native "lib.so" "fun" 1.0)            # double fun(void);





Arrays and Structures



If the result specification is a list, it means that the C function returned
a pointer to an array, or an arbitrary memory structure. The specification list
should then consist of either the above primitive specifications (symbols or
numbers), or of cons pairs of a primitive specification and a repeat count, to
denote arrays of the given type.


Examples for function calls, with their corresponding pseudo C prototypes:


(native "lib.so" "fun" '(I . 8))       # int *fun(void);  // 8 integers
(native "lib.so" "fun" '(B . 16))      # unsigned char *fun(void);  // 16 bytes

(native "lib.so" "fun" '(I I))         # struct {int i; int j;} *fun(void);
(native "lib.so" "fun" '(I . 4))       # struct {int i[4];} *fun(void);

(native "lib.so" "fun" '(I (B . 4)))   # struct {
                                       #    int i;
                                       #    unsigned char c[4];
                                       # } *fun(void);

(native "lib.so" "fun"                 # struct {
   '(((B . 4) I) (S . 12) (N . 8)) )   #    struct {unsigned char c[4]; int i;}
                                       #    char *names[12];
                                       #    long num[8];
                                       # } *fun(void);




If a returned structure has an element which is a pointer to some
other structure (i.e. not an embedded structure like in the last example above),
this pointer must be first obtained with a N pattern, which can
then be passed to struct for further
extraction.





Arguments



The (optional) fourth and following arguments to native specify
the arguments to the C function.



Primitive Types



Integer arguments (up to 64 bits, signed or unsigned char,
short, int or long) can be passed as they
are: As numbers.


(native "lib.so" "fun" NIL 123)        # void fun(int);
(native "lib.so" "fun" NIL 1 2 3)      # void fun(int, long, short);




String arguments can be specified as symbols. native allocates
memory for each string on the stack, passes the pointer to the C function, and
cleans up the stack when done.


(native "lib.so" "fun" NIL "abc")      # void fun(char*);
(native "lib.so" "fun" NIL 3 "def")    # void fun(int, char*);




Note that the allocated string memory is released after the return
value is extracted. This allows a C function to return the argument string
pointer, perhaps after modifying the data in-place, and receive the new string
as the return value (with the S specification).


(native "lib.so" "fun" 'S "abc")       # char *fun(char*);




Also note that specifying NIL as an argument passes an empty
string ("", which also reads as NIL in PicoLisp) to the C function.
Physically, this is a pointer to a NULL-byte, and is not a NULL-pointer.
Be sure to pass 0 (the number zero) if a NULL-pointer is desired.


Floating point arguments are specified as cons pairs, where the value is in
the CAR, and the CDR holds the fixpoint scale. If the scale is positive, the
number is passed as a double, otherwise as a float.


(native "lib.so" "fun" NIL             # void fun(double, float);
   (12.3 . 1.0) (4.56 . -1.0) )





Arrays and Structures



Composite arguments are specified as nested list structures.
native allocates memory for each array or structure (with
malloc(3)), passes the pointer to the C function, and releases the
memory (with free(3)) when done.


This implies that such an argument can be both an input and an output value
to a C function (pass by reference).


The CAR of the argument specification can be NIL (then it is an
input-only argument). Otherwise, it should be a variable which receives the
returned structure data.


The CADR of the argument specification must be a cons pair with the total
size of the structure in its CAR. The CDR is ignored for input-only arguments,
and should contain a result specification for
the output value to be stored in the variable.


For example, a minimal case is a function that takes an integer reference,
and stores the number '123' in that location:


void fun(int *i) {
   *i = 123;
}




We call native with a variable X in the CAR of the
argument specification, a size of 4 (i.e. sizeof(int)), and
I for the result specification. The stored value is then available
in the variable X:


: (native "lib.so" "fun" NIL '(X (4 . I)))
-> NIL
: X
-> 123




The rest (CDDR) of the argument specification may contain initialization
data, if the C function expects input values in the structure. It should be a
list of initialization items, optionally with a
fill-byte value in the CDR of the last cell.


If there are no initialization items and just the final fill-byte,
then the whole buffer is filled with that byte. For example, to pass a buffer of
20 bytes, initialized to zero:


: (native "lib.so" "fun" NIL '(NIL (20) . 0))




A buffer of 20 bytes, with the first 4 bytes initialized to 1, 2, 3, and 4,
and the rest filled with zero:


: (native "lib.so" "fun" NIL '(NIL (20) 1 2 3 4 . 0))




and the same, where the buffer contents are returned as a list of bytes in
the variable X:


: (native "lib.so" "fun" NIL '(X (20 B . 20) 1 2 3 4 . 0))




For a more extensive example, let's use the following definitions:


typedef struct value {
   int x, y;
   double a, b, c;
   int z;
   char nm[4];
} value;

void fun(value *val) {
   printf("%d %d\n", val->x, val->y);
   val->x = 3;
   val->y = 4;
   strcpy(val->nm, "OK");
}




We call this function with a structure of 40 bytes, requesting the returned
data in V, with two integers (I . 2), three doubles
(100 . 3) with a scale of 2 (1.0 = 100), another integer
I and four characters (C . 4). If the structure gets
initialized with two integers 7 and 6, three doubles 0.11, 0.22 and 0.33, and
another integer 5 while the rest of the 40 bytes is cleared to zero


: (native "lib.so" "fun" NIL
   '(V (40 (I . 2) (100 . 3) I (C . 4)) -7 -6 (100 11 22 33) -5 . 0) )




then it will print the integers 7 and 6, and V will contain the
returned list


((3 4) (11 22 33) 5 ("O" "K" NIL NIL))




i.e. the original integer values 7 and 6 replaced with 3 and 4.


Note that the allocated structure memory is released after the return
value is extracted. This allows a C function to return the argument structure
pointer, perhaps after modifying the data in-place, and receive the new
structure as the return value - instead of (or even in addition to) to the
direct return via the argument reference.





Memory Management



The preceding Arguments section mentions that
native implicitly allocates and releases memory for strings, arrays
and structures.


Technically, this mimics automatic variables in C.


For a simple example, let's assume that we want to call read(2)
directly, to fetch a 4-byte integer from a given file descriptor. This could be
done with the following C function:


int read4bytes(int fd) {
   char buf[4];

   read(fd, buf, 4);
   return *(int*)buf;
}




buf is an automatic variable, allocated on the stack, which
disappears when the function returns. A corresponding native call
would be:


(%@ "read" 'I Fd '(Buf (4 . I)) 4)




The structure argument (Buf (4 . I)) says that a space of 4
bytes should be allocated and passed to read, then an integer
I returned in the variable Buf (the return value of
native itself is the integer returned by read). The
memory space is released after that.


(Note that we can call %@ here, as read resides in
the main program.)


Instead of a single integer, we might want a list of four bytes to be
returned from native:


(%@ "read" 'I Fd '(Buf (4 B . 4)) 4)




The difference is that we wrote (B . 4) (a list of 4 bytes)
instead of I (a single integer) for the result specification (see the Arrays and Structures section).


Let's see what happens if we extend this example. We'll write the four bytes
to another file descriptor, after reading them from the first one:


void copy4bytes(int fd1, int fd2) {
   char buf[4];

   read(fd1, buf, 4);
   write(fd2, buf, 4);
}




Again, buf is an automatic variable. It is passed to both
read and write. A direct translation would be:


(%@ "read" 'I Fd '(Buf (4 B . 4)) 4)
(%@ "write" 'I Fd2 (cons NIL (4) Buf) 4)




This works as expected. read returns a list of four bytes in
Buf. The call to cons builds the structure


(NIL (4) 1 2 3 4)




i.e. no return variable, a four-byte memory area, filled with the four bytes
(assuming that read returned 1, 2, 3 and 4). Then this structure is
passed to write.


But: This solution induces quite some overhead. The four-byte buffer is
allocated before the call to read and released after that, then
allocated and released again for write. Also, the bytes are
converted to a list to be stored in Buf, then that list is extended
for the structure argument to write, and converted again back to
the raw byte array. The data in the list itself are never used.


If the above operation is to be used more than once, it is better to allocate
the buffer manually, use it for both reading and writing, and then release it.
This also avoids all intermediate list conversions.


(let Buf (%@ "malloc" 'P 4)  # Allocate memory
   (%@ "read" 'I Fd Buf 4)   # (Possibly repeat this several times)
   (%@ "write" 'I Fd2 Buf 4)
   (%@ "free" NIL Buf) )     # Release memory




To allocate such a buffer locally on the stack (just like a C function would
do), buf can be used. Equivalent to the
above is:


(buf Buf 4  # Allocate local memory
   (%@ "read" 'I Fd Buf 4)
   (%@ "write" 'I Fd2 Buf 4) )





Fast Fourier Transform



For a more typical example, we might call the Fast Fourier Transform using
the library from the FFTW package. With the
example code for calculating Complex One-Dimensional DFTs:


#include <fftw3.h>
...
{
   fftw_complex *in, *out;
   fftw_plan p;
   ...
   in = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * N);
   out = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * N);
   p = fftw_plan_dft_1d(N, in, out, FFTW_FORWARD, FFTW_ESTIMATE);
   ...
   fftw_execute(p); /* repeat as needed */
   ...
   fftw_destroy_plan(p);
   fftw_free(in); fftw_free(out);
}




we can build the following equivalent:


(load "@lib/math.l")

(de FFTW_FORWARD . -1)
(de FFTW_ESTIMATE . 64)

(de fft (Lst)
   (let
      (Len (length Lst)
         In (native "libfftw3.so" "fftw_malloc" 'P (* Len 16))
         Out (native "libfftw3.so" "fftw_malloc" 'P (* Len 16))
         P (native "libfftw3.so" "fftw_plan_dft_1d" 'N
            Len In Out FFTW_FORWARD FFTW_ESTIMATE ) )
      (struct In NIL (cons 1.0 (apply append Lst)))
      (native "libfftw3.so" "fftw_execute" NIL P)
      (prog1
         (struct Out (make (do Len (link (1.0 . 2)))))
         (native "libfftw3.so" "fftw_destroy_plan" NIL P)
         (native "libfftw3.so" "fftw_free" NIL Out)
         (native "libfftw3.so" "fftw_free" NIL In) ) ) )




This assumes that the argument list Lst is passed as a list
of complex numbers, each as a list of two numbers for the real and imaginary
part, like


(fft '((1.0 0) (1.0 0) (1.0 0) (1.0 0) (0 0) (0 0) (0 0) (0 0)))




The above translation to Lisp is quite straightforward. After the two buffers
are allocated, and a plan is created, struct is called to store the argument list
in the In structure as a list of double numbers (according to the
1.0 initialization item). Then
fftw_execute is called, and struct is called again to
retrieve the result from Out and return it from fft
via the prog1. Finally, all memory is
released.



Constant Data



If such allocated data (strings, arrays or structures passed to
native) are constant during the lifetime of a program, it makes
sense to allocate them only once, before their first use. A typical candidate is
the format string of a printf call. Consider a function which
prints a floating point number in scientific notation:


(load "@lib/math.l")

: (de prf (Flt)
   (%@ "printf" NIL "%e\n" (cons Flt 1.0)) )
-> prf

: (prf (exp 12.3))
2.196960e+05







Callbacks



Sometimes it is necessary to do the reverse: Call Lisp code from C code.


This mechanism uses the Lisp-level function lisp. No C source code access is
required.


lisp returns a function pointer, which can be passed to
C functions via native. When this function pointer is
dereferenced and called from the C code, the corresponding Lisp function
is invoked. Only five numeric arguments and a numeric return value can
be used, and other data types must be handled by the Lisp function with
struct and memory management
operations.


Callbacks are often used in user interface libraries, to handle key-, mouse-
and other events. Examples can be found in "@lib/openGl.l". The
following function mouseFunc takes a Lisp function, installs it
under the tag mouseFunc (any other tag would be all right too) as a
callback, and passes the resulting function pointer to the OpenGL
glutMouseFunc() function, to set it as a callback for the current
window:


(de mouseFunc (Fun)
   (native `*GlutLib "glutMouseFunc" NIL (lisp 'mouseFunc Fun)) )




(The global *GlutLib holds the library
"/usr/lib/libglut.so". The backquote (`) is important
here, so that the transient symbol with the library name (and not the global
*GlutLib) is evaluated by native, resulting in the
proper library handle at runtime).


A program using OpenGL may then use mouseFunc to install a
function


(mouseFunc
   '((Btn State X Y)
      (do-something-with Btn State X Y) ) )




so that future clicks into the window will pass the button, state and
coordinates to that function.



pil21/doc/search.html0000644000000000000000000003133414623547632011613 0ustar  





The 'search' Function



abu@software-lab.de


The 'search' Function



(c) Software Lab. Alexander Burger


The search function allows to search the database for a combination of search criteria.


It finds all objects - directly from the criteria or after traversing all
associations - which fulfill all given search criteria, and returns them
one at a time.








Examples



The examples in this document will use the demo application in "app/*.l" (in
demoApp.tgz).


To get an interactive prompt, start it as:


$ pil app/main.l -ap~main +
:




As ever, you can terminate the interpreter by hitting Ctrl-D.





Syntax



search is called in two different forms.


The first form initializes a query. It takes two or more arguments, and
returns a query structure (a list).


The second form can then be called repeatedly with that structure, and will
subsequently return the next resulting object, or NIL if no more
results can be found.


To start a new query, search is called with an arbitrary number
of argument pairs, each consisting of a search criterion and a list of relation
specifications, and an optional extraction function which filters and possibly
modifies the results.


For example, to find the item with the number 2:


ap: (search 2 '((nr +Item)))
-> (NIL ...




The first argument 2 is a search criterion (the key to
look for), and ((nr +Item)) is a list with a single relation
specification (the nr index of the +Item class).


The returned query structure is abbreviated here, because it is big and not
relevant. It can now be used to fetch the result:


ap: (search @)
-> {B2}
ap: (show @)
{B2} (+Item)
   nr 2
   pr 1250
   inv 100
   sup {C2}
   nm "Spare Part"
-> {B2}




There are no further results, because nr is a unique key:


ap: (search @@@)  # '@@@' refers to the third-last REPL result, the query
-> NIL





Search Criteria



Each criterion is an attribute of a database object (like name, e-mail,
address etc.), or some given database object. It may be used to find objects
directly, or as a starting point for a recursive search for other objects
reachable by this object.


For every search criterion which is NIL, no search is performed,
and the following relation specification is ignored. If, however, all
search criteria are NIL, a full search over the last relation
specification is forced.



Numbers



If the search criterion is numeric (including derived types like date or
time), it can be atomic for an exact search, or a cons pair for searching a
range of numbers.


Extending the above example, we may search for all items with a number
between 2 and (including) 6:


ap: (search (2 . 6) '((nr +Item)))
-> (NIL ...




We may use a for loop to retrieve all results:


ap: (for
   (Q
      (search (2 . 6) '((nr +Item)))
      (search Q) )
   (printsp @) )
{B2} {B3} {B4} {B5} {B6}





Strings



If the search criterion is a string (transient symbol) or an internal symbol,
or a cons pair of those, the exact behavior depends on the relation type. It
includes all cases where it matches the heads of the result attributes (string
prefixes), but may also match substrings and/or tolerant (folded or soundex-encoded) searches.


ap: (for
   (Q
      (search "Api" '((em +CuSu)))
      (search Q) )
   (println (; @ em)) )
"info@api.tld"




ap: (for
   (Q
      (search "part" '((nm +Item)))
      (search Q) )
   (with @
      (println (: nr) (: nm)) ) )
1 "Main Part"
2 "Spare Part"




Or, combined with a number range search:


ap: (for
   (Q
      (search
         (2 . 6) '((nr +Item))
         "part" '((nm +Item)) )
      (search Q) )
   (with @
      (println (: nr) (: nm)) ) )
2 "Spare Part"





Objects



A database object can also be used as a search criterion. A cons pair (i.e. a
range) of objects makes no sense, because objects by themselves are not ordered.


Searching for all items from a given supplier:


ap: (for
   (Q
      (search '{C1} '((sup +Item)))
      (search Q) )
   (printsp @) )
{B1} {B3} {B5}




or for all positions in a given order:


ap: (for
   (Q
      (search '{B7} '((ord . pos)))
      (search Q) )
   (printsp @) )
{A1} {A2} {A3}





Relation Specifications



Every second argument to search is a list of relation
specifications. In typical use cases, a relation specification is either


    

  • a list (var cls [hook]) for an index relation, or

  •  a cons pair (sym . sym) for a +Joint relation




For general cases, the first specification in the list may be replaced
by two custom functions: A generator function and a filter function. This allows
to start the search from arbitrary resources like remote databases or
coroutines.


If a specification is (var cls) but var is not an
index of cls, a brute force search through the objects in the
database file of cls will be performed. This should only be done
for small files with ideally all objects of type cls.


The rest of the list contains associations (which are also relation
specifications) to recursively search through associated objects. They are
typically (+Joint), (+List +Joint),
or (+Ref +Link) relations.


Look for example at the choOrd ("choose Order") function in the
demo application. You can access it directly in the REPL with (vi
'choOrd). The search call is


(search
   *OrdCus '((nm +CuSu) (cus +Ord))
   *OrdOrt '((ort +CuSu) (cus +Ord))
   *OrdItem '((nm +Item) (itm +Pos) (pos . ord))
   *OrdSup '((nm +CuSu) (sup +Item) (itm +Pos) (pos . ord))
   (and *OrdNr (cons @)) '((nr +Ord))
   (and *OrdDat (cons @)) '((dat +Ord)) )




The global variables *OrdCus through *OrdDat hold
the search criteria from the search fields in the dialog GUI.


The line with the longest chain of associations is:


   *OrdSup '((nm +CuSu) (sup +Item) (itm +Pos) (pos . ord))




This means:


    

  1. Search suppliers by name

  2. For each matching supplier, go through his items

  3. For each item, find order positions where it is referred

  4. For each position, return the order where it is in




Testing this line stand-alone, searching orders only by supplier name:


ap: (for
   (Q
      (search
         "Seven Oaks"
         (quote
            (nm +CuSu)
            (sup +Item)
            (itm +Pos)
            (pos . ord) ) )
      (search Q) )
   (printsp @) )
{B7}




Custom Generators and Filters



If the list of relation specifications does not start with an index relation
(var cls) or a joint relation (sym . sym), but instead
with a function like ((X) (foo)), the first two elements of
the list are taken as generator and filter functions, respectively.


We could rewrite the last example in a slightly simplified form, but with
custom functions:


ap: (for
   (Q
      (search
         "Seven Oaks"
         (quote
            ((X)  # Generator function
               (iter> (meta '(+CuSu) 'nm)
                  "Seven Oaks"
                  '(nm +CuSu) ) )
            ((This X)  # Filter function
               (pre? "Seven Oaks" (: nm)) )
            (sup +Item)
            (itm +Pos)
            (pos . ord) ) )
      (search Q) )
   (printsp @) )
{B7}




The iter> method implements the mechanisms to produce the
internal query structures for individual relations. There is a convenience
function relQ for this. It can be used to simplify such standard
generators. Instead of:


   ((X)  # Generator function
      (iter> (meta '(+CuSu) 'nm)
         "Seven Oaks"
         '(nm +CuSu) ) )




we can write:


   ((X)  # Generator function
      (relQ "Seven Oaks" '(nm +CuSu)) )





Multiple Indexes



While relQ is normally not used directly by application
programs, because its functionality is provided by the standard relation
specification syntax, there is a function relQs which is indeed
useful.


relQs produces proper generator and filter functions which can
search multiple indexes for a singe search criterion.


The general syntax is:


   (relQs '((var1 +Cls1) (var2 +Cls2) ..) (sym1 ..) (sym2 ..)..)




to search first the index (var1 +Cls1), then (var2
+Cls2) etc., and then follow the optional associations (sym1
..), (sym2 ..) etc.


A typical use case is searching for a telephone number in both the landline
and mobile attributes. You find an example in the choCuSu ("choose
Customer/Supplier") function in the demo application, in the line:


   *CuSuTel (relQs '((tel +CuSu) (mob +CuSu)))




Note that (relQs ..) must not be quoted, because it needs
to be evaluate to produce the right functions and query structure.



Extraction Function



Sometimes it is necessary to to do further checks on a search result, which
may not be covered by the standard matching of combined search criteria.


An example can be found in the tut.tgz tutorial in the file
"db/family.l", in the contemporaries report. It searches for people
living roughly at the same time as the given person:


   '(let @Fin
      (or
         (: home obj fin)
         (+ (: home obj dat) 36525) )
      (search
         (cons (- (: home obj dat) 36525) @Fin) '((dat +Person))
         (curry (@Fin) (Obj)
            (and
               (n== Obj (: home obj))
               (>= (; Obj fin) (: home obj dat))
               (>= @Fin (; Obj dat))
               Obj ) ) ) )




@Fin is set to either the date when the given person died, or to
the birth date plus ten years if not known. Then all persons born in the range
of ten years before the given person and @Fin are searched.


curry builds the filter function, taking an
object and doing range checks to see if that person died after the given person
was born, and that he or she was born before @Fin.


If those conditions are not met, the function returns NIL, and
search continues to search for the next result.


The extraction function may also - instead of returning the object or
NIL, return some other value as appropriate for the application.



Sorting



In general, the values returned by search are not sorted when
multiple search criteria are given. This is because the indexes are iterated
over in an unpredictable order.


If, however, only a single search criterion is given, or only one of the
search criteria is non-NIL, then the results will be returned in
sorted order according to the given index.


If all search criteria are NIL, and thus the last
relation specification is used (see above under Search
Criteria), then the results will turn up in increasing order.



pil21/doc/select.html0000644000000000000000000004313214516413307011614 0ustar  





The 'select' Predicate



abu@software-lab.de


The 'select' Predicate



(c) Software Lab. Alexander Burger


The Pilog select/3 predicate is rather complex, and quite
different from other predicates. This document tries to explain it in detail,
and shows some typical use cases.








Syntax



select takes at least three arguments:


    

  • A list of unification variables,

  • a list of generator clauses

  • and an arbitrary number of filter clauses




We will describe these arguments in the following, but demonstrate them first
on a concrete example.





First Example



The examples in this document will use the demo application in "app/*.l" (in
demoApp.tgz). To get an
interactive prompt, start it as


$ pil app/main.l -ap~main +
:




As ever, you can terminate the interpreter by hitting Ctrl-D.


For a first, typical example, let's write a complete call to solve that returns a list of articles with numbers
between 1 and 4, which contain "Part" in their description, and have a price
less than 100:


(let (Nr (1 . 4)  Nm "Part"  Pr '(NIL . 100.00))
   (solve
      (quote
         @Nr Nr
         @Nm Nm
         @Pr Pr
         (select (@Item)
            ((nr +Item @Nr) (nm +Item @Nm) (pr +Item @Pr))
               (range @Nr @Item nr)
               (part @Nm @Item nm)
               (range @Pr @Item pr) ) )
      @Item ) )




This expression will return, with the default database setup of "app/init.l",
a list of exactly one item ({B2}), the item with the number 2.


The let statement assigns values to
the search parameters for number Nr, description Nm
and price Pr. The Pilog query (the first argument to
solve) passes these values to the Pilog variables @Nr,
@Nm and @Pr. Ranges of values are always specified by
cons pairs, so (1 . 4) includes the numbers 1 through 4, while
(NIL . 100.00) includes prices from minus infinite up to one
hundred.


The list of unification variables is


   (@Item)




The list of generator clauses is


      ((nr +Item @Nr) (nm +Item @Nm) (pr +Item @Pr))




The filter clauses are


         (range @Nr @Item nr)
         (part @Nm @Item nm)
         (range @Pr @Item pr)







Unification Variables



As stated above, the first argument to select should be a list
of variables. These variables communicate values (via unify) from the select
environment to the enclosing Pilog environment.


The first variable in this list (@Item in the above example) is
mandatory, it takes the direct return value of select. Additional
optional variables may be unified by clauses in the body of select,
and return further values.





Generator Clauses



The second argument to select is a list of "generator clauses".
Each of these clauses specifies some kind of database B-Tree +index, to be traversed by
select, step by step, where each step returns a suitable single
database object. In the simplest case, they consist like here just of a relation
name (e.g. nr), a class (e.g. +Item), an optional hook
specifier (not in this example), and a pattern (values or ranges, e.g. (1 . 4)
or "Part").


The generator clauses are the core of 'select'. In some way, they behave
analog to or/2, as each of them
generates a sequence of values. However, the generator clauses behave different,
as they will not generate an exhaustive set of values upon backtracking, one
after the other, where the next gets its turn when the previous one is
exhausted. Instead, all clauses will generate their values quasi-parallel, with
a built-in optimization so that successful clauses will be called with a higher
probability. "Successful" means that the returned values successfully pass
select's filter clauses.





B-Tree Stepping



In its basic form, a generator clause is equivalent to the db/3 predicate, stepping through a single
B-Tree. The clause


(nr +Item @Nr)




generates the same values as would be produced by a stand-alone Pilog clause


(db nr +Item @Nr @Item)




as can be seen in the following two calls:


: (? (db nr +Item (1 . 4) @Item))
 @Item={B1}
 @Item={B2}
 @Item={B3}
 @Item={B4}
-> NIL
: (? (select (@Item) ((nr +Item (1 . 4)))))
 @Item={B1}
 @Item={B2}
 @Item={B3}
 @Item={B4}
-> NIL







Interaction of Generator Clauses



select is mostly useful if more than one generator clause is
involved. The tree search parameters of all clauses are meant to form a logical
AND. Only those objects should be returned, for which all search
parameters (and the associated filter clauses) are valid. As soon as one of the
clauses finishes stepping through its database (sub)tree, the whole call to
select will terminate, because further values returned from other
generator clauses cannot be part of the result set.


Therefore, select would find all results most quickly if it
could simply call only the generator clause with the smallest (sub)tree.
Unfortunately, this is usually not known in advance. It depends on the
distribution of the data in the database, and on the search parameters to each
generator clause.


Instead, select single-steps each generator clause in turn, in a
round-robin scheme, applies the filter clauses to each generated object, and
re-arranges the order of generator clauses so that the more successful clauses
will be preferred. This process usually converges quickly and efficiently.





Combined Indexes



A generator clause can also combine several (similar) indexes into a single
one. Then the clause is written actually as a list of clauses.


For example, a generator clause to search for a customer by phone number is


(tel +CuSu @Tel)



If we want to search for a customer without knowing whether a given number is a
normal or a mobile phone number, then a combined generator clause searching both
index trees could look like


((tel +CuSu @Tel  mob +CuSu @Tel))




The generator will first traverse all matching entries in the +Ref tree of the tel relation, and
then, when these are exhausted, all matching entries in the mob
index tree.





Indirect Object Associations



But generator clauses are not limited to the direct B-Tree interaction of
db/3. They can also traverse trees of
associated objects, and then follow +Link / +Joint relations, or tree relations like
+Ref to arrive at database objects
with a type suitable for return values from select.


To locate appropriate objects from associated objects, the generator clause
can contain - in addition to the standard relation/class/pattern specification
(see Generator Clauses above) - an arbitrary number of
association specifiers. Each association specifier can be


    

  1. A symbol. Then a +Link or
+Joint will be followed, or a
+List of those will be traversed to
locate appropriate objects.


  2. A list. Then this list should hold a relation and a class (and an optional
hook) which specify some B-Tree +index to be traversed to locate appropriate
objects.




In this way, a single generator clause can cause the traversal of a tree of
object relations to generate the desired sequence of objects.

An example can be found in "app/gui.l", in the 'choOrd' function which
implements the search dialog for +Ord (order) objects. Orders can
be searched for order number and date, customer name and city, item description
and supplier name:


(select (@@)
   ((nr +Ord @Nr) (dat +Ord @Dat)
      (nm +CuSu @Cus (cus +Ord))
      (ort +CuSu @Ort (cus +Ord))
      (nm +Item @Item (itm +Pos) ord)
      (nm +CuSu @Sup (sup +Item) (itm +Pos) ord) )




While (nr +Ord @Nr) and (dat +Ord @Dat) are direct
index traversals, (nm +CuSu @Cus (cus +Ord)) iterates the
nm (name) index of customers/suppliers +CuSu, and then
follows the +Ref +Link of the cus relation to the
orders. The same applies to the search for city names via ort.


The most complex example is (nm +CuSu @Sup (sup +Item) (itm +Pos)
ord), where the supplier name is searched in the nm tree of
+CuSu, then the +Ref tree
(sup +Item) tree is followed to locate items of that supplier, then
all positions for those items are found using (itm +Pos), and
finally the ord +Joint
is followed to arrive at the order object(s).





Nested Pilog Queries



In the most general case, a generator clause can be an arbitrary Pilog query.
Often this is a query to a database on a remote machine, using the remote/2 predicate, or some other resource
not accessible via database indexes, like iterating a +List of +Links or +Joints.


Syntactically, such a generator clause is recognized by the fact that its CAR
is a Pilog variable to denote the return value.


The second argument is a list of Pilog variables to communicate values (via
unify) from the surrounding
select environment.


The third argument is the actual list of clauses for the nested query.


Finally, an arbitrary number of association specifiers may follow, as
described in the Indirect Object Associations
section.


We can illustrate this with a somewhat useless (but simple) example, which
replaces the standard generators for item number and supplier name


(select (@Item)
   ((nr +Item @Nr) (nm +CuSu @Sup (sup +Item)))
   ...




with the equivalent form


(select (@Item)
   ((@A (@Nr) ((db nr +Item @Nr @A)))
      (@B (@Sup) ((db nm +CuSu @Sup @B)) (sup +Item)) )




That is, a query with the db/3 tree
iteration predicate is used to generate appropriate values.





Filter Clauses



The generator clauses produce - independent from each other - lots of
objects, which match the patterns of individual generator clauses, but not
necessarily the desired result set of the total select call.
Therefore, the filter clauses are needed to retain the good, and throw away the
bad objects. In addition, they give feedback to the generator for optimizing its
traversal priorities (as described in Generator Clauses).


select then collects all objects which passed through the
filters into a unique list, to avoid duplicates which would otherwise appear,
because most objects can be found by more than one generator clause.


Technically, the filters are normal Pilog clauses, which just happen to be
evaluated in the context of select. Arbitrary Pilog predicates can
be used, though there exist some predicates (e.g. isa/2, same/3, bool/3, range/3, head/3, fold/3, part/3 or tolr/3) especially suited for that task.





A Little Report



Assume we want to know how many pieces of item #2 were sold in the year 2007.
Then we must find all +Pos (position) objects referring to that
item and at the same time belonging to orders of the year 2007 (see the class
definition for +Pos in "app/er.l"). The number of sold pieces is
then in the cnt property of the +Pos objects.


As shown in the complete select below, we will hold the item
number in the variable @Nr and the date range for the year in
@Year.


Now, all positions referred by item #2 can be found by the generator clause


(nr +Item @Nr (itm +Pos))




and all positions sold in 2007 can be found by


(dat +Ord @Year pos)




However, the combination of both generator clauses


(select (@Pos)
   ((nr +Item @Nr (itm +Pos)) (dat +Ord @Year pos)) )




will probably generate too many results, namely all positions with item #2
OR from the year 2007. Thus, we need two filter clauses. With them, the
full search expression will be:


(?
   @Nr 2                                                 # Item number
   @Year (cons (date 2007 1 1) (date 2007 12 31))        # Date range 2007
   (select (@Pos)
      ((nr +Item @Nr (itm +Pos)) (dat +Ord @Year pos))   # Generator clauses
      (same @Nr @Pos itm nr)                             # Filter item number
      (range @Year @Pos ord dat) ) )                     # Filter order date




For completeness, let's calculate the total count of sold items:


(let Cnt 0     # Counter variable
   (pilog
      (quote
         @Nr 2
         @Year (cons (date 2007 1 1) (date 2007 12 31))
         (select (@Pos)
            ((nr +Item @Nr (itm +Pos)) (dat +Ord @Year pos))
            (same @Nr @Pos itm nr)
            (range @Year @Pos ord dat) ) )
      (inc 'Cnt (get @Pos 'cnt)) )  # Increment total count
   Cnt )  # Return count







Filter Predicates



As mentioned under Filter Clauses, some predicates
exists mainly for select filtering.


Some of these predicates are of general use: isa/2 can be used to check for a type,
same/3 checks for a definite value,
bool/3 looks if the value is
non-NIL. These predicates are rather independent of the +relation type.


range/3 checks whether a value
is within a given range. This could be used with any +relation type, but typically it will be
used for numeric (+Number) or time
( +Date and +Time) relations.


Other predicates make only sense in the context of a certain +relation type:






pil21/doc/des.html0000644000000000000000000002173414531705751011120 0ustar  





Discrete-Event Simulation



abu@software-lab.de


Discrete-Event Simulation (DES)



(c) Software Lab. Alexander Burger


PicoLisp has a Discrete-Event
Simulation library in "@lib/simul.l".








Implementation



The simulated objects (often called "Agents") are implemented as separate coroutines. These are
created the normal way with co, and the library functions
use yield to transfer
control between them.


Only one coroutine may be running at one point in time. All others are either


    

  • ready to run,

  • waiting for the next scheduled point in time, and/or

  • waiting for one or several specific signals (events).




A running coroutine can suspend itself, and cause another coroutine to
resume, by either


    

  • passing control to the next coroutine, or

  • pausing for a given amount of time and/or waiting for signals.




The simulation can optionally run in realtime mode. In that case, it sleeps
between the scheduled points in time, and accepts key strokes for user
interaction.


The library consists of five global variables and four functions.





Global Variables






*Time


Simulated system time since the start of the simulation. It can be in any
unit, but should be in milliseconds if in realtime mode.



*Ready


Queue of coroutines ready to run.



*Next


idx tree of
coroutines pausing for a given time.



*Rt


Realtime: Either NIL (default), or 1 for wall clock speed, 2
for double speed etc.



*Keys


Holds possibly queued key presses (only in realtime mode).









Functions






(des [. prg])


Performs one discrete-event simulation step. It first runs all coroutines in
*Ready until that queue is empty. Then - if *Next is
not empty - advances the simulation to the next point in time, and resumes all
corresponding coroutines. In that case, if in realtime mode, it delays execution
as necessary, handles possible key presses, and runs prg after each
key.



(pause ['cnt|sym] ..) -> any


Waits for events (i.e. a time span elapsed or a signal arrived). For a
numeric argument, the current coroutine is scheduled in *Next for a
point in time after that number of time units. For symbolic arguments, the
current coroutine is queued into those symbol's event queues. In any case,
control is passed to the next coroutine.



(event 'sym [. prg])


Sends the signal sym to all coroutines waiting in that symbol's
event queue. As a result, these coroutines are removed from the queue and
appended to the *Ready queue, with the optional prg
body to be executed when resumed. The current coroutine continues to run.



(wake 'sym [. prg])


Wakes up another coroutine sym, by appending it to the
*Ready queue with the optional 'prg' body to be executed when
resumed. This means that if sym is currently waiting for a point in
time in *Next, it is removed from that index (i.e. the pause is
aborted). Also, if sym is waiting for signals, it is removed from
those event queues. The current coroutine continues to run.









Usage



A typical DES program will start some coroutines and let them perform their
initial work until they need to pause.


That means, if a given operation in the simulation is supposed to take
cnt time units, this coroutine calls pause with that
number. Or, if it depends on some signals from another part of the program, it
may call pause with those symbols. In any case - as it has nothing
else to do - it goes to sleep.


When all of them wait for a time or signal, control is returned to the main
program. All coroutines are now waiting in *Next or some signal
event queue (or in *Ready if they just gave up control with
(pause)).


The main program may now check *Next and perhaps
*Ready. If both are empty, no further events can occur, and the
program may terminate.


Otherwise, it calls des to continue with the next step(s).


At any time, a coroutine or the main program may call wake, for
example to interrupt another coroutine and cause it to throw into some other
context, or have that coroutine's pause return a special value by
running the prg argument.






An Example



Let's use DES to demonstrate the well-known Dining
Philosophers Problem.


 Put the following code into a file "dining.l".




# 07sep23 Software Lab. Alexander Burger
# Dining Philosophers
# pil dining.l -dining~main +

(load "@lib/simul.l")

(symbols 'dining 'simul 'pico)

(local) (*ForkA *ForkB *ForkC *ForkD *ForkE now think)

(de now (Str)
   (prinl (tim$ (* 60 *Time)) " " (co) " " Str) )

(de think (Left Right)
   (loop
      (now "thinking")
      (pause (rand 180 240))  # 3 to 4 hours
      (now "hungry")
      (while (or (val Left) (val Right))
         (now "waiting")
         (pause Left Right) )
      (set Left (set Right (co)))
      (now "eating")
      (pause 20)  # 20 minutes
      (set Left (set Right NIL))
      (event Left)
      (event Right) ) )

(local) main

(de main ()
   (symbols '(dining simul pico))
   (co 'Aristotle
      (think '*ForkA '*ForkB) )
   (co 'Kant
      (think '*ForkB '*ForkC) )
   (co 'Spinoza
      (think '*ForkC '*ForkD) )
   (co 'Marx
      (think '*ForkD '*ForkE) )
   (co 'Russell
      (think '*ForkE '*ForkA) ) )






It uses five global variables *ForkA through *ForkE
and five coroutines Aristotle, Kant,
Spinoza, Marx and Russell. They all run
the same function think, with their neighboring forks as
Left and Right arguments.


In think, each philospher is first "thinking" for a random time
between three and four hours. Then it gets "hungry", tries to pick up both
forks, and - if at least one of the forks is in use - starts "waiting" for a
left or right fork signal from another philosopher, and checks the forks again.


Now both forks are free. The philosopher puts himself into both (it could put
in fact any non-NIL value), then is "eating" for 20 minutes,
releases both forks by setting them to NIL, and sends a left and a
right fork signal to the neighboring philosophers possibly waiting for the
forks.


The simulation cannot deadlock, because both forks are picked up and released
atomically, and because coroutines waiting for fork signals are always queued
after the other waiting coroutines.


Sample Run



$ ./pil misc/dining.l -dining~main +
00:00 Aristotle thinking
00:00 Kant thinking
00:00 Spinoza thinking
00:00 Marx thinking
00:00 Russell thinking
dining: (more (stack))
(Russell . 62)
(Marx . 62)
(Spinoza . 62)
(Kant . 62)
(Aristotle . 62)
(T . 155)
-> NIL
dining: *Ready
-> NIL
dining: (idx '*Next)
-> ((180 . Aristotle) (194 . Marx) (198 . Russell) (201 . Spinoza) (229 . Kant))
dining: (des)
03:00 Aristotle hungry
03:00 Aristotle eating
-> NIL
dining: (des)
03:14 Marx hungry
03:14 Marx eating
-> NIL
dining: (des)
03:18 Russell hungry
03:18 Russell waiting
-> NIL
dining: (do 10 (des))
03:20 Aristotle thinking
03:20 Russell waiting
03:21 Spinoza hungry
03:21 Spinoza waiting
03:34 Marx thinking
03:34 Spinoza eating
03:34 Russell eating
03:49 Kant hungry
03:49 Kant waiting
03:54 Russell thinking
03:54 Spinoza thinking
03:54 Kant eating
04:14 Kant thinking
06:27 Aristotle hungry
06:27 Aristotle eating
06:47 Aristotle thinking
06:47 Marx hungry
06:47 Marx eating
07:07 Marx thinking
07:40 Russell hungry
07:40 Russell eating
-> NIL
dining:





pil21/doc/httpGate.html0000644000000000000000000001754514516410153012122 0ustar  





The 'httpGate' Proxy Server



mattias@inogu.se


The 'httpGate' Proxy Server



(c) Software Lab. Mattias Sundblad


This document describes the httpGate utility which is included
in the PicoLisp distribution.


For basic information about the PicoLisp system please look at the PicoLisp Reference and the PicoLisp
Tutorial.







Purpose



httpGate is a central element of the PicoLisp application server
architecture. Its purpose is to perform the following tasks:


    

  • Provide a single application entry port (e.g. 80 or 443).

  • Allow PicoLisp applications to run as non-root.

  • Start application servers on demand.

  • Handle HTTPS/SSL communication.




Basic functionality



A HTTP request to port 80, respectively 443, of the form


   http[s]://server.org/12345/path/file




is forwarded to a server on localhost listening on port 12345, to ask for the
resource "path/file".


If httpGate was started with a config file, and that file contains an entry
for "app", then also the following request is accepted:


   http[s]://server.org/app/path/file




In that case, the "app" server process is started automatically (if it is not
already running) listening on port 12345, and the request is forwarded as above.


Only GET and POST requests will be forwarded, and only to ports >= 1024.
The main httpGate process then forks two child processes, one for each
direction. These child processes terminate automatically if the connection is
idle for more than 7 minutes.


Running httpGate



The simplest way to run httpGate is to start it with an explicit port
argument:


   bin/httpGate 80 8080
   bin/httpGate 443 8080 pem/www.domain.key,pem/domain.crt




When started in this way, httpGate forwards requests from port 80 and 443
respectively to a PicoLisp application on port 8080. This form has a drawback
though, since it only allows for a single application to be handled. Usually,
there are many PicoLisp applications running on the same machine, and we need
httpGate to forward requests to all of them.


To handle several applications, start httpGate with a "names" config file:


      bin/httpGate 80 names
      bin/httpGate 443 names pem/www.domain.key,pem/domain.crt




httpGate needs to be started as root, but application servers should run
under normal user accounts. The easiest way to start httpGate automatically is
to add lines like the ones above to '/etc/rc.local'.


Configuring httpGate



The "names" config file



The "names" config file contains one line per application server. Each line
holds six whitespace separated tokens, for example:


   app 12345 tom /home/tom log/app ./pil app/main.l lib/app.l -main -go -wait




    

  1. "app" is the name of the application, and the key to this line.

  2. "12345" is the port where this server should listen at.

  3. "tom" is the user under whose ID the server should run.

  4. "/home/tom" is the working directory where the server should start.

  5. "log/app" is a log file to redirect stdout/stderr to.

  6. The rest of the line "./pil app/main.l ..." is the command to start the application.




Empty lines, and lines starting with a "#", are ignored. If the key in a
config file record is the special name "@", then it denotes the default
application for this machine. URLs without name will be forwarded to that port.
If the key contains a slash followed by a string (e.g. "app/foo") then this
string is inserted in front of URLs.


Optional tokens (e.g. log files) or empty arguments to the commands must be
written as single caret (^) characters to denote empty strings. Double or single
quotes are not parsed.


If the port is zero, then a single additional token is expected which should
denote an URL to redirect the request to:


   app 0 https://domain/foo/bar



This will cause httpGate to respnd with "302 Found" and "Location:
https://domain/foo/bar".


Balanced names file



If the config file contains many (hundreds or thousands) entries, then it is
recommended to sort it with the 'balance' utility. This may greatly accelerate
name (key) lookup at runtime. For that, put the above config lines into a file
"config". The tool 'balance' can be built - together with httpGate - with


   (cd src; make tools gate)




The following command will create a balanced "names" file:


   cat config | bin/balance -sort > names




The "void" file



If the local application server cannot be connected on the requested port
(typically because a session timed out), and a file with the name "void" exists
in the current working directory (token 4 in the config line), then the contents
of that file (normally HTML) are sent as response to the client.


Reloading the configuration



When the config file is modified, it can be reloaded by sending SIGHUP to all
running top-level httpGate processes:


   $ sudo pkill -HUP -P1 httpGate




Another possibility is to restart httpGate(s). This is not a problem, and can
be done also while the server is in production.


Just kill the top level httpGate parent process. This is not harmful, because
existing user sessions are handled by pairs of child processes, which continue
to run (until they terminate normally) even if their parent is stopped. Note
that this is different from PicoLisp DB applications, where the parent should
*never* be hard-stopped (eg. with 'kill -9 <pid>') while child processes
are running ('kill <pid>' is OK though, because the parent takes care of
stopping the children).


An example for stopping and restarting a running httpGate is:


   (let L
      # Build list of all httpGate parents (i.e. on 80 and 443)
      (make
         (in '("sudo" "pgrep" "-P1" "httpGate")
            (while (read)
               (link @) ) ) )
      # Stop them
      (for P L
         (call "sudo" "kill" P) )
      # Wait until all are gone
      (while (find '((P) (kill P 0)) L)
         (wait 200) )
      # Start new
      (call "sudo" "bin/httpGate" 80 "names")
      (call "sudo" "bin/httpGate" 443 "names" "pem/...") )




Keep-alive and retirement



Applications should call


   (retire 20)




before they call 'server'. This causes the parent server process to terminate
automatically 20 minutes after the last child process (user session) terminated.
It will be started by httpGate again on demand. User sessions in turn terminate
automatically after 5 minutes (if nobody logged in) or 1 hour (if a user is
logged in), unless JavaScript is enabled in the client browser and the
application calls


   (<ping> 7)




in its main 'action' function. In that case, the user session will not
terminate until the user closes the last window or tab to this application.



pil21/doc/search0000644000000000000000000000303714511741450010635 0ustar  Search criteria
   Numbers
      3
      (3 . 4)
   Strings
      "abc"
      ("a" . "z")
   Objects
      {2}
   Symbols
      abc
      (a . z)

Relation types
   Number, Date, Time
      (+Key +Number)
         7 {2}

      (+Ref +Number)
         (7 . {2}) {2}

   Keywords
      (+Key +String)
         "Regen Axer" {2}

      (+Ref +String)
         ("Regen Axer" . {2}) {2}

   Phone numbers
      (+Fold +Ref +String)
         ("regenaxer" . {2}) {2}

   E-Mail addresses
      (+Fold +Idx +String)
         ("axer" {2}) {2}
         ("egenaxer" {2}) {2}
         ("enaxer" {2}) {2}
         ("genaxer" {2}) {2}
         ("naxer" {2}) {2}
         ("regenaxer" . {2}) {2}
         ("xer" {2}) {2}

   Personal names
      (+Sn +IdxFold +String)
         ("RSNSR" {2} . T) {2}
         ("Regen Axer" . {2}) {2}
         ("axer" {2}) {2}
         ("egen" {2}) {2}
         ("gen" {2}) {2}
         ("regenaxer" {2}) {2}
         ("xer" {2}) {2}

   Item names
      (+IdxFold +String)
         ("Regen Axer" . {2}) {2}
         ("axer" {2}) {2}
         ("egen" {2}) {2}
         ("gen" {2}) {2}
         ("regenaxer" {2}) {2}
         ("xer" {2}) {2}

      (+List +Fold +Ref +String)
         ("axer" . {2}) {2}
         ("regen" . {2}) {2}

   Identifiers
      (+Idx +String)
         ("Axer" {2}) {2}
         ("Regen Axer" . {2}) {2}
         ("egen" {2}) {2}
         ("gen" {2}) {2}
         ("xer" {2}) {2}

   GIS coordinates
      (+UB +Aux +Ref +Number)
         (56919522950766600 . {2}) {2}

   Objects
      (+Ref +Link)
         ({7} . {2}) {2}
pil21/doc/microTemplates0000644000000000000000000000361114631354156012364 0ustar           Micro-Templates

* Each template file in the @lib/xhtml/ directory applies to one type of
  component in the @lib/xhtml.l functions.

* The template files are line oriented. One micro-template per line.

* A micro-template can be continued on the following line(s) by
  indenting these lines with space(s).

* Each line has a defined meaning. Except for indented lines, no lines
  can be added or removed.

* A micro-template may contain either variables or expressions enclosed
  by "¦" (broken bar character, hex "00A6").

* An empty line is denoted by "<>".

* "~" is replaced at runtime with the session ID.

* At program start, all templates from @lib/xhtml/ are loaded.

* The application may override one or more files in a local directory,
  and call 'xhtml' with that path. Also more than once.

* Available templates:

   html
      1. DOCTYPE
      2. HTML start
      3. HEAD
      4. BODY
      5. HTML end

   table
      1. Table start
      2. Caption
      3. Header row start
      4. Header row entry
      5. Header row end
      6. Data row start
      7. Data row entry
      8. Data row end
      9. Table end

   grid
      1. Grid start
      2. Grid row start
      3. Grid row entry
      4. Grid row end
      5. Grid end

   layout
      Variable number of lines, one per code block

   menu
      1. Menu start
      2. Submenu start
      3. Plain HTML
      4. Disabled link
      5. Enabled link
      6. Enabled active link
      7. Closed submenu
      8. Open submenu start
      9. Open submenu end
      10. Submenu end
      11. Menu end

   tab
      1. TABLE start
      2. Disabled entry
      3. Enabled entry
      4. TABLE end

   input
      1. (Non-text) Input element

   field
      1. Text input element

   area
      1. TEXTAREA start
      2. TEXTAREA end

   select
      1. SELECT start
      2. OPTION
      3. SELECT end

   submit
      1. Submit input element
pil21/doc/Tracks0000644000000000000000000000137614433660720010626 0ustar  # VIP @lib/vip/draw.l
# 25may23 Software Lab. Alexander Burger

(label 1 1 "Connectors:")

(cells 7 6 '(| | | . |))
(go 1 3 "-")
(right 9 "+")
(down 2 "v")
(go 10 8 "+")
(down 8 "v")
(go 28 6 "+")
(up 3 "+")
(right 14 ">")
(go 46 6 "+")
(up 3 "+")
(right 30 ">")

(box 7 17 13 6 "Track"
   (label 1 1 "- a")
   (label 10 1 "b -")
   (label 2 5 "x")
   (label 11 5 "y") )
(go 7 18 "+")
(left 4 "+")
(up 11 "+")
(right 3 ">")
(go 20 18 "+")
(right 4 ">")

(cells 25 17 '(| | | . |))
(go 28 17 "+")
(up 3 "+")
(left 11 "+")
(down 2 "v")
(go 76 22 "-")
(left 48 "+")
(up 2 "\^")
(go 46 19 "+")
(down 6 "+")
(left 45 "<")
(go 64 19 "+")
(down 6 "+")
(left 14 "<")

(go 70 17 "+")
(up 6 "+")
(left 58 "+")
(up 2 "\^")
(go 52 8 "+")
(down 6 "+")
(left 22 "+")
(down 2 "v")